deserialize method

  1. @override
void deserialize(
  1. Map<String, dynamic>? json
)
override

Implementation

@override
void deserialize(Map<String, dynamic>? json) {
  if (json == null) {
    throw ApiException(
        400, 'Failed to deserialize PdfSaveOptionsData data model.');
  }

  super.deserialize(json);
  if (json.containsKey('AllowEmbeddingPostScriptFonts')) {
    allowEmbeddingPostScriptFonts =
        json['AllowEmbeddingPostScriptFonts'] as bool;
  } else {
    allowEmbeddingPostScriptFonts = null;
  }

  if (json.containsKey('CustomTimeZoneInfoData')) {
    customTimeZoneInfoData = ModelBase.createInstance<TimeZoneInfoData>(
        json['CustomTimeZoneInfoData'] as Map<String, dynamic>);
  } else {
    customTimeZoneInfoData = null;
  }

  if (json.containsKey('Dml3DEffectsRenderingMode')) {
    switch (json['Dml3DEffectsRenderingMode'] as String) {
      case 'Basic':
        dml3DEffectsRenderingMode =
            SaveOptionsData_Dml3DEffectsRenderingModeEnum.basic;
        break;
      case 'Advanced':
        dml3DEffectsRenderingMode =
            SaveOptionsData_Dml3DEffectsRenderingModeEnum.advanced;
        break;
      default:
        dml3DEffectsRenderingMode = null;
        break;
    }
  } else {
    dml3DEffectsRenderingMode = null;
  }

  if (json.containsKey('DmlEffectsRenderingMode')) {
    switch (json['DmlEffectsRenderingMode'] as String) {
      case 'Simplified':
        dmlEffectsRenderingMode =
            SaveOptionsData_DmlEffectsRenderingModeEnum.simplified;
        break;
      case 'None':
        dmlEffectsRenderingMode =
            SaveOptionsData_DmlEffectsRenderingModeEnum.none;
        break;
      case 'Fine':
        dmlEffectsRenderingMode =
            SaveOptionsData_DmlEffectsRenderingModeEnum.fine;
        break;
      default:
        dmlEffectsRenderingMode = null;
        break;
    }
  } else {
    dmlEffectsRenderingMode = null;
  }

  if (json.containsKey('DmlRenderingMode')) {
    switch (json['DmlRenderingMode'] as String) {
      case 'Fallback':
        dmlRenderingMode = SaveOptionsData_DmlRenderingModeEnum.fallback;
        break;
      case 'DrawingML':
        dmlRenderingMode = SaveOptionsData_DmlRenderingModeEnum.drawingML;
        break;
      default:
        dmlRenderingMode = null;
        break;
    }
  } else {
    dmlRenderingMode = null;
  }

  if (json.containsKey('FileName')) {
    fileName = json['FileName'] as String;
  } else {
    fileName = null;
  }

  if (json.containsKey('ImlRenderingMode')) {
    switch (json['ImlRenderingMode'] as String) {
      case 'Fallback':
        imlRenderingMode = SaveOptionsData_ImlRenderingModeEnum.fallback;
        break;
      case 'InkML':
        imlRenderingMode = SaveOptionsData_ImlRenderingModeEnum.inkML;
        break;
      default:
        imlRenderingMode = null;
        break;
    }
  } else {
    imlRenderingMode = null;
  }

  if (json.containsKey('UpdateCreatedTimeProperty')) {
    updateCreatedTimeProperty = json['UpdateCreatedTimeProperty'] as bool;
  } else {
    updateCreatedTimeProperty = null;
  }

  if (json.containsKey('UpdateFields')) {
    updateFields = json['UpdateFields'] as bool;
  } else {
    updateFields = null;
  }

  if (json.containsKey('UpdateLastPrintedProperty')) {
    updateLastPrintedProperty = json['UpdateLastPrintedProperty'] as bool;
  } else {
    updateLastPrintedProperty = null;
  }

  if (json.containsKey('UpdateLastSavedTimeProperty')) {
    updateLastSavedTimeProperty = json['UpdateLastSavedTimeProperty'] as bool;
  } else {
    updateLastSavedTimeProperty = null;
  }

  if (json.containsKey('ZipOutput')) {
    zipOutput = json['ZipOutput'] as bool;
  } else {
    zipOutput = null;
  }

  if (json.containsKey('ColorMode')) {
    switch (json['ColorMode'] as String) {
      case 'Normal':
        colorMode = FixedPageSaveOptionsData_ColorModeEnum.normal;
        break;
      case 'Grayscale':
        colorMode = FixedPageSaveOptionsData_ColorModeEnum.grayscale;
        break;
      default:
        colorMode = null;
        break;
    }
  } else {
    colorMode = null;
  }

  if (json.containsKey('JpegQuality')) {
    jpegQuality = json['JpegQuality'] as int;
  } else {
    jpegQuality = null;
  }

  if (json.containsKey('MetafileRenderingOptions')) {
    metafileRenderingOptions =
        ModelBase.createInstance<MetafileRenderingOptionsData>(
            json['MetafileRenderingOptions'] as Map<String, dynamic>);
  } else {
    metafileRenderingOptions = null;
  }

  if (json.containsKey('NumeralFormat')) {
    switch (json['NumeralFormat'] as String) {
      case 'European':
        numeralFormat = FixedPageSaveOptionsData_NumeralFormatEnum.european;
        break;
      case 'ArabicIndic':
        numeralFormat =
            FixedPageSaveOptionsData_NumeralFormatEnum.arabicIndic;
        break;
      case 'EasternArabicIndic':
        numeralFormat =
            FixedPageSaveOptionsData_NumeralFormatEnum.easternArabicIndic;
        break;
      case 'Context':
        numeralFormat = FixedPageSaveOptionsData_NumeralFormatEnum.context;
        break;
      case 'System':
        numeralFormat = FixedPageSaveOptionsData_NumeralFormatEnum.system;
        break;
      default:
        numeralFormat = null;
        break;
    }
  } else {
    numeralFormat = null;
  }

  if (json.containsKey('OptimizeOutput')) {
    optimizeOutput = json['OptimizeOutput'] as bool;
  } else {
    optimizeOutput = null;
  }

  if (json.containsKey('PageCount')) {
    pageCount = json['PageCount'] as int;
  } else {
    pageCount = null;
  }

  if (json.containsKey('PageIndex')) {
    pageIndex = json['PageIndex'] as int;
  } else {
    pageIndex = null;
  }

  if (json.containsKey('CacheBackgroundGraphics')) {
    cacheBackgroundGraphics = json['CacheBackgroundGraphics'] as bool;
  } else {
    cacheBackgroundGraphics = null;
  }

  if (json.containsKey('Compliance')) {
    switch (json['Compliance'] as String) {
      case 'Pdf17':
        compliance = PdfSaveOptionsData_ComplianceEnum.pdf17;
        break;
      case 'Pdf20':
        compliance = PdfSaveOptionsData_ComplianceEnum.pdf20;
        break;
      case 'PdfA1a':
        compliance = PdfSaveOptionsData_ComplianceEnum.pdfA1a;
        break;
      case 'PdfA1b':
        compliance = PdfSaveOptionsData_ComplianceEnum.pdfA1b;
        break;
      case 'PdfA2a':
        compliance = PdfSaveOptionsData_ComplianceEnum.pdfA2a;
        break;
      case 'PdfA2u':
        compliance = PdfSaveOptionsData_ComplianceEnum.pdfA2u;
        break;
      case 'PdfA4':
        compliance = PdfSaveOptionsData_ComplianceEnum.pdfA4;
        break;
      case 'PdfUa1':
        compliance = PdfSaveOptionsData_ComplianceEnum.pdfUa1;
        break;
      default:
        compliance = null;
        break;
    }
  } else {
    compliance = null;
  }

  if (json.containsKey('CreateNoteHyperlinks')) {
    createNoteHyperlinks = json['CreateNoteHyperlinks'] as bool;
  } else {
    createNoteHyperlinks = null;
  }

  if (json.containsKey('CustomPropertiesExport')) {
    switch (json['CustomPropertiesExport'] as String) {
      case 'None':
        customPropertiesExport =
            PdfSaveOptionsData_CustomPropertiesExportEnum.none;
        break;
      case 'Standard':
        customPropertiesExport =
            PdfSaveOptionsData_CustomPropertiesExportEnum.standard;
        break;
      case 'Metadata':
        customPropertiesExport =
            PdfSaveOptionsData_CustomPropertiesExportEnum.metadata;
        break;
      default:
        customPropertiesExport = null;
        break;
    }
  } else {
    customPropertiesExport = null;
  }

  if (json.containsKey('DigitalSignatureDetails')) {
    digitalSignatureDetails =
        ModelBase.createInstance<PdfDigitalSignatureDetailsData>(
            json['DigitalSignatureDetails'] as Map<String, dynamic>);
  } else {
    digitalSignatureDetails = null;
  }

  if (json.containsKey('DisplayDocTitle')) {
    displayDocTitle = json['DisplayDocTitle'] as bool;
  } else {
    displayDocTitle = null;
  }

  if (json.containsKey('DownsampleOptions')) {
    downsampleOptions = ModelBase.createInstance<DownsampleOptionsData>(
        json['DownsampleOptions'] as Map<String, dynamic>);
  } else {
    downsampleOptions = null;
  }

  if (json.containsKey('EmbedAttachments')) {
    embedAttachments = json['EmbedAttachments'] as bool;
  } else {
    embedAttachments = null;
  }

  if (json.containsKey('EmbedFullFonts')) {
    embedFullFonts = json['EmbedFullFonts'] as bool;
  } else {
    embedFullFonts = null;
  }

  if (json.containsKey('EncryptionDetails')) {
    encryptionDetails = ModelBase.createInstance<PdfEncryptionDetailsData>(
        json['EncryptionDetails'] as Map<String, dynamic>);
  } else {
    encryptionDetails = null;
  }

  if (json.containsKey('ExportDocumentStructure')) {
    exportDocumentStructure = json['ExportDocumentStructure'] as bool;
  } else {
    exportDocumentStructure = null;
  }

  if (json.containsKey('ExportLanguageToSpanTag')) {
    exportLanguageToSpanTag = json['ExportLanguageToSpanTag'] as bool;
  } else {
    exportLanguageToSpanTag = null;
  }

  if (json.containsKey('FontEmbeddingMode')) {
    switch (json['FontEmbeddingMode'] as String) {
      case 'EmbedAll':
        fontEmbeddingMode = PdfSaveOptionsData_FontEmbeddingModeEnum.embedAll;
        break;
      case 'EmbedNonstandard':
        fontEmbeddingMode =
            PdfSaveOptionsData_FontEmbeddingModeEnum.embedNonstandard;
        break;
      case 'EmbedNone':
        fontEmbeddingMode =
            PdfSaveOptionsData_FontEmbeddingModeEnum.embedNone;
        break;
      default:
        fontEmbeddingMode = null;
        break;
    }
  } else {
    fontEmbeddingMode = null;
  }

  if (json.containsKey('HeaderFooterBookmarksExportMode')) {
    switch (json['HeaderFooterBookmarksExportMode'] as String) {
      case 'None':
        headerFooterBookmarksExportMode =
            PdfSaveOptionsData_HeaderFooterBookmarksExportModeEnum.none;
        break;
      case 'First':
        headerFooterBookmarksExportMode =
            PdfSaveOptionsData_HeaderFooterBookmarksExportModeEnum.first;
        break;
      case 'All':
        headerFooterBookmarksExportMode =
            PdfSaveOptionsData_HeaderFooterBookmarksExportModeEnum.all;
        break;
      default:
        headerFooterBookmarksExportMode = null;
        break;
    }
  } else {
    headerFooterBookmarksExportMode = null;
  }

  if (json.containsKey('ImageColorSpaceExportMode')) {
    switch (json['ImageColorSpaceExportMode'] as String) {
      case 'Auto':
        imageColorSpaceExportMode =
            PdfSaveOptionsData_ImageColorSpaceExportModeEnum.auto;
        break;
      case 'SimpleCmyk':
        imageColorSpaceExportMode =
            PdfSaveOptionsData_ImageColorSpaceExportModeEnum.simpleCmyk;
        break;
      default:
        imageColorSpaceExportMode = null;
        break;
    }
  } else {
    imageColorSpaceExportMode = null;
  }

  if (json.containsKey('ImageCompression')) {
    imageCompression = json['ImageCompression'] as String;
  } else {
    imageCompression = null;
  }

  if (json.containsKey('InterpolateImages')) {
    interpolateImages = json['InterpolateImages'] as bool;
  } else {
    interpolateImages = null;
  }

  if (json.containsKey('OpenHyperlinksInNewWindow')) {
    openHyperlinksInNewWindow = json['OpenHyperlinksInNewWindow'] as bool;
  } else {
    openHyperlinksInNewWindow = null;
  }

  if (json.containsKey('OutlineOptions')) {
    outlineOptions = ModelBase.createInstance<OutlineOptionsData>(
        json['OutlineOptions'] as Map<String, dynamic>);
  } else {
    outlineOptions = null;
  }

  if (json.containsKey('PageMode')) {
    switch (json['PageMode'] as String) {
      case 'UseNone':
        pageMode = PdfSaveOptionsData_PageModeEnum.useNone;
        break;
      case 'UseOutlines':
        pageMode = PdfSaveOptionsData_PageModeEnum.useOutlines;
        break;
      case 'UseThumbs':
        pageMode = PdfSaveOptionsData_PageModeEnum.useThumbs;
        break;
      case 'FullScreen':
        pageMode = PdfSaveOptionsData_PageModeEnum.fullScreen;
        break;
      case 'UseOC':
        pageMode = PdfSaveOptionsData_PageModeEnum.useOC;
        break;
      case 'UseAttachments':
        pageMode = PdfSaveOptionsData_PageModeEnum.useAttachments;
        break;
      default:
        pageMode = null;
        break;
    }
  } else {
    pageMode = null;
  }

  if (json.containsKey('PreblendImages')) {
    preblendImages = json['PreblendImages'] as bool;
  } else {
    preblendImages = null;
  }

  if (json.containsKey('PreserveFormFields')) {
    preserveFormFields = json['PreserveFormFields'] as bool;
  } else {
    preserveFormFields = null;
  }

  if (json.containsKey('TextCompression')) {
    switch (json['TextCompression'] as String) {
      case 'None':
        textCompression = PdfSaveOptionsData_TextCompressionEnum.none;
        break;
      case 'Flate':
        textCompression = PdfSaveOptionsData_TextCompressionEnum.flate;
        break;
      default:
        textCompression = null;
        break;
    }
  } else {
    textCompression = null;
  }

  if (json.containsKey('UseBookFoldPrintingSettings')) {
    useBookFoldPrintingSettings = json['UseBookFoldPrintingSettings'] as bool;
  } else {
    useBookFoldPrintingSettings = null;
  }

  if (json.containsKey('UseCoreFonts')) {
    useCoreFonts = json['UseCoreFonts'] as bool;
  } else {
    useCoreFonts = null;
  }

  if (json.containsKey('ZoomBehavior')) {
    switch (json['ZoomBehavior'] as String) {
      case 'None':
        zoomBehavior = PdfSaveOptionsData_ZoomBehaviorEnum.none;
        break;
      case 'ZoomFactor':
        zoomBehavior = PdfSaveOptionsData_ZoomBehaviorEnum.zoomFactor;
        break;
      case 'FitPage':
        zoomBehavior = PdfSaveOptionsData_ZoomBehaviorEnum.fitPage;
        break;
      case 'FitWidth':
        zoomBehavior = PdfSaveOptionsData_ZoomBehaviorEnum.fitWidth;
        break;
      case 'FitHeight':
        zoomBehavior = PdfSaveOptionsData_ZoomBehaviorEnum.fitHeight;
        break;
      case 'FitBox':
        zoomBehavior = PdfSaveOptionsData_ZoomBehaviorEnum.fitBox;
        break;
      default:
        zoomBehavior = null;
        break;
    }
  } else {
    zoomBehavior = null;
  }

  if (json.containsKey('ZoomFactor')) {
    zoomFactor = json['ZoomFactor'] as int;
  } else {
    zoomFactor = null;
  }
}