@adobe/pdfservices-node-sdk/lib/internal/util/ValidationUtil.d.ts

The Adobe PDF Services Node.js SDK provides APIs for creating, combining, exporting and manipulating PDFs.

/// <reference types="node" />
import { ExecutionContext } from "../ExecutionContext";
import { PageRanges } from "../../pdfjobs/params/PageRanges";
import { CombinePDFJobInput } from "../params/CombinePDFJobInput";
import { EncryptionAlgorithm } from "../../pdfjobs/params/protectpdf/EncryptionAlgorithm";
import { ContentEncryption } from "../../pdfjobs/params/protectpdf/ContentEncryption";
import { Permissions } from "../../pdfjobs/params/protectpdf/Permissions";
import { Asset } from "../../io/Asset";
import { PageAction } from "../dto/request/pagemanipulation/PageAction";
import { OutputFormat } from "../../pdfjobs/params/documentmerge/OutputFormat";
import { CompressionLevel } from "../../pdfjobs/params/compresspdf/CompressionLevel";
import { DocumentLanguage } from "../../pdfjobs/params/createpdf/DocumentLanguage";
import { ExportPDFTargetFormat } from "../../pdfjobs/params/exportpdf/ExportPDFTargetFormat";
import { ExportOCRLocale } from "../../pdfjobs/params/exportpdf/ExportOCRLocale";
import { ExportPDFToImagesOutputType } from "../../pdfjobs/params/exportpdftoimages/ExportPDFToImagesOutputType";
import { ExportPDFToImagesTargetFormat } from "../../pdfjobs/params/exportpdftoimages/ExportPDFToImagesTargetFormat";
import { TableStructureType } from "../../pdfjobs/params/extractpdf/TableStructureType";
import { ExtractRenditionsElementType } from "../../pdfjobs/params/extractpdf/ExtractRenditionsElementType";
import { ExtractElementType } from "../../pdfjobs/params/extractpdf/ExtractElementType";
import { PageLayout } from "../../pdfjobs/params/htmltopdf/PageLayout";
import { OCRSupportedLocale } from "../../pdfjobs/params/ocr/OCRSupportedLocale";
import { OCRSupportedType } from "../../pdfjobs/params/ocr/OCRSupportedType";
import { Permission } from "../../pdfjobs/params/protectpdf/Permission";
import { ExternalStorageType } from "../../io/ExternalStorageType";
import { ProxyScheme } from "../../config/proxy/ProxyScheme";
import { ProxyAuthenticationCredentials } from "../../config/proxy/ProxyAuthenticationCredentials";
import { Region } from "../../Region";
import { ProxyServerConfig } from "../../config/proxy/ProxyServerConfig";
import { NotifierType } from "../../config/notifier/NotifierType";
import { CallbackNotifierData } from "../../config/notifier/CallbackNotifierData";
import { SignatureFormat } from "../../pdfjobs/params/electronicseal/SignatureFormat";
import { DocumentLevelPermission } from "../../pdfjobs/params/electronicseal/DocumentLevelPermission";
import { CertificateCredentials } from "../../pdfjobs/params/electronicseal/CertificateCredentials";
import { TSAOptions } from "../../pdfjobs/params/electronicseal/TSAOptions";
import { FieldOptions } from "../../pdfjobs/params/electronicseal/FieldOptions";
import { AppearanceOptions } from "../../pdfjobs/params/electronicseal/AppearanceOptions";
import { AppearanceItem } from "../../pdfjobs/params/electronicseal/AppearanceItem";
import { CSCAuthContext } from "../../pdfjobs/params/electronicseal/CSCAuthContext";
import { FieldLocation } from "../../pdfjobs/params/electronicseal/FieldLocation";
import { TSABasicAuthCredentials } from "../../pdfjobs/params/electronicseal/TSABasicAuthCredentials";
import { PDFElectronicSealParams } from "../../pdfjobs/params/electronicseal/PDFElectronicSealParams";
import { AutotagPDFParams } from "../../pdfjobs/params/autotagpdf/AutotagPDFParams";
import { CombinePDFParams } from "../../pdfjobs/params/combinepdf/CombinePDFParams";
import { CompressPDFParams } from "../../pdfjobs/params/compresspdf/CompressPDFParams";
import { CreatePDFParams } from "../../pdfjobs/params/createpdf/CreatePDFParams";
import { DeletePagesParams } from "../../pdfjobs/params/deletepages/DeletePagesParams";
import { DocumentMergeParams } from "../../pdfjobs/params/documentmerge/DocumentMergeParams";
import { ExportPDFParams } from "../../pdfjobs/params/exportpdf/ExportPDFParams";
import { ExportPDFToImagesParams } from "../../pdfjobs/params/exportpdftoimages/ExportPDFToImagesParams";
import { ExtractPDFParams } from "../../pdfjobs/params/extractpdf/ExtractPDFParams";
import { HTMLToPDFParams } from "../../pdfjobs/params/htmltopdf/HTMLToPDFParams";
import { InsertPagesParams } from "../../pdfjobs/params/insertpages/InsertPagesParams";
import { OCRParams } from "../../pdfjobs/params/ocr/OCRParams";
import { PDFPropertiesParams } from "../../pdfjobs/params/pdfproperties/PDFPropertiesParams";
import { ProtectPDFParams } from "../../pdfjobs/params/protectpdf/ProtectPDFParams";
import { RemoveProtectionParams } from "../../pdfjobs/params/removeprotection/RemoveProtectionParams";
import { ReorderPagesParams } from "../../pdfjobs/params/reorderpages/ReorderPagesParams";
import { ReplacePagesParams } from "../../pdfjobs/params/replacepages/ReplacePagesParams";
import { RotatePagesParams } from "../../pdfjobs/params/rotatepages/RotatePagesParams";
import { SplitPDFParams } from "../../pdfjobs/params/splitpdf/SplitPDFParams";
import { Credentials } from "../../auth/Credentials";
import { ClientConfig } from "../../config/ClientConfig";
import { MimeType } from "../../MimeType";
import { PDFServicesJob } from "../../pdfjobs/jobs/PDFServicesJob";
import { NotifierConfig } from "../../config/notifier/NotifierConfig";
import { PDFAccessibilityCheckerParams } from "../../pdfjobs/params/pdfaccessibilitychecker/PDFAccessibilityCheckerParams";
import { PDFWatermarkParams } from "../../pdfjobs/params/pdfwatermark/PDFWatermarkParams";
import { WatermarkAppearance } from "../../pdfjobs/params/pdfwatermark/WatermarkAppearance";
export declare class ValidationUtil {
    private static readonly PASSWORD_MAX_LENGTH;
    private static readonly PAGE_ACTIONS_MAX_LIMIT;
    private static readonly USER_STRING;
    private static readonly OWNER_STRING;
    private static readonly REMOVE_PROTECTION_PASSWORD_MAX_LENGTH;
    private static readonly SPLIT_PDF_OUTPUT_COUNT_LIMIT;
    static validateExecutionContext(executionContext: ExecutionContext): void;
    static validateSplitPDFParams(params: {
        pageRanges?: PageRanges;
        pageCount?: number;
        fileCount?: number;
    }): void;
    static validatePDFWatermarkParams(params: {
        watermarkAppearance?: WatermarkAppearance;
        pageRanges?: PageRanges;
    }): void;
    static validateWatermarkAppearanceParams(params: {
        appearOnForeground?: boolean;
        opacity?: number;
    }): void;
    private static validatePageRangesOverlap;
    static validateAssetWithPageOptions(input: CombinePDFJobInput): void;
    private static validatePageOptions;
    static validateProtectPDFParams(params: {
        userPassword?: string;
        ownerPassword?: string;
        encryptionAlgorithm: EncryptionAlgorithm;
        contentEncryption?: ContentEncryption;
        permissions?: Permissions;
    }): void;
    private static validatePassword;
    private static isLatin;
    static validateReorderPagesParams(params: {
        asset: Asset;
        pageRanges: PageRanges;
    }): void;
    static validateReplaceFilesInputs(baseAsset: Asset, assetsToReplace: Map<number, CombinePDFJobInput>): void;
    static validateInsertAssetInputs(baseAsset: Asset, assetsToInsert: Map<number, CombinePDFJobInput[]>): void;
    static validatePageRanges(pageRanges: PageRanges): void;
    static validateRotatePageActions(pageActions: PageAction[]): void;
    static validateDocumentMergeParams(params: {
        jsonDataForMerge: object;
        fragments?: Array<object>;
        outputFormat?: OutputFormat;
    }): void;
    static validateAutotagPDFParams(params: {
        generateReport?: boolean;
        shiftHeadings?: boolean;
    }): void;
    static validateRemoveProtectionParams(params: {
        password: string;
    }): void;
    static validateCompressPDFParams(params: {
        compressionLevel?: CompressionLevel;
    }): void;
    static validateCreatePDFParams(params: {
        documentLanguage?: DocumentLanguage;
        createTaggedPDF?: boolean;
    }): void;
    static validateDeletePagesParams(params: {
        pageRanges: PageRanges;
    }): void;
    static validateExportPDFParams(params: {
        targetFormat: ExportPDFTargetFormat;
        ocrLocale?: ExportOCRLocale;
    }): void;
    static validateExportPDFToImagesParams(params: {
        outputType: ExportPDFToImagesOutputType;
        targetFormat: ExportPDFToImagesTargetFormat;
    }): void;
    static validateExtractPDFParams(params: {
        tableStructureType?: TableStructureType;
        addCharInfo?: boolean;
        getStylingInfo?: boolean;
        elementsToExtractRenditions?: ExtractRenditionsElementType[];
        elementsToExtract?: ExtractElementType[];
    }): void;
    static validatePageLayoutParams(params: {
        pageHeight?: number;
        pageWidth?: number;
    }): void;
    static validateHTMLToPDFParams(params: {
        includeHeaderFooter?: boolean;
        pageLayout?: PageLayout;
        dataToMerge?: object;
    }): void;
    static validateOCRParams(params: {
        ocrLocale?: OCRSupportedLocale;
        ocrType?: OCRSupportedType;
    }): void;
    static validatePDFPropertiesParams(params: {
        includePageLevelProperties?: boolean;
    }): void;
    static validatePermissions(params: {
        permissions: Permission[];
    }): void;
    static validateExternalAssetParams(params: {
        uri: string;
        storageType?: ExternalStorageType;
    }): void;
    static validateProxyServerConfigParams(params: {
        host: string;
        port: number;
        scheme?: ProxyScheme;
        credentials?: ProxyAuthenticationCredentials;
    }): void;
    static validateClientConfigParams(params: {
        timeout?: number;
        region?: Region;
        proxyServerConfig?: ProxyServerConfig;
        filePath?: string;
    }): void;
    static validateUsernamePasswordCredentialsParams(params: {
        username: string;
        password: string;
    }): void;
    private static validateProxyScheme;
    private static validateRegion;
    static validateCallbackNotifierDataParams(params: {
        url: string;
        headers?: {
            [p: string]: string;
        };
    }): void;
    static validateNotifierConfigParams(params: {
        type: NotifierType;
        data: CallbackNotifierData;
    }): void;
    private static validateNotifierType;
    static validatePDFElectronicSealParams(params: {
        signatureFormat?: SignatureFormat;
        documentLevelPermission?: DocumentLevelPermission;
        certificateCredentials: CertificateCredentials;
        tsaOptions?: TSAOptions;
        sealFieldOptions: FieldOptions;
        sealAppearanceOptions?: AppearanceOptions;
    }): void;
    private static validateSignatureFormat;
    private static validateDocumentLevelPermission;
    static validateAppearanceOptions(params: {
        items?: AppearanceItem[];
    }): void;
    private static validateAppearanceItem;
    static validateCSCAuthContext(params: {
        accessToken: string;
        tokenType?: string;
    }): void;
    static validateCSCCredential(params: {
        providerName: string;
        credentialId: string;
        pin: string;
        authorizationContext: CSCAuthContext;
    }): void;
    static validateFieldOptions(params: {
        visible?: boolean;
        location?: FieldLocation;
        fieldName: string;
        pageNumber?: number;
    }): void;
    static validateRFC3161TSAOptions(params: {
        url: string;
        credentialAuthParameters?: TSABasicAuthCredentials;
    }): void;
    static validateTSAAuthCredentials(params: {
        username: string;
        password: string;
    }): void;
    static validatePDFElectronicSealJobParams(params: {
        inputAsset: Asset;
        sealImageAsset?: Asset;
        params: PDFElectronicSealParams;
        outputAsset?: Asset;
    }): void;
    static validateAutotagPDFJobParams(params: {
        inputAsset: Asset;
        params?: AutotagPDFParams;
        outputAsset?: Asset;
    }): void;
    static validateCombinePDFJobParams(params: {
        params: CombinePDFParams;
        outputAsset?: Asset;
    }): void;
    static validateCompressPDFJobParams(params: {
        inputAsset: Asset;
        params?: CompressPDFParams;
        outputAsset?: Asset;
    }): void;
    static validateCreatePDFJobParams(params: {
        inputAsset: Asset;
        params?: CreatePDFParams;
        outputAsset?: Asset;
    }): void;
    static validateDeletePagesJobParams(params: {
        inputAsset: Asset;
        params: DeletePagesParams;
        outputAsset?: Asset;
    }): void;
    static validateDocumentMergeJobParams(params: {
        inputAsset: Asset;
        params: DocumentMergeParams;
        outputAsset?: Asset;
    }): void;
    static validateExportPDFJobParams(params: {
        inputAsset: Asset;
        params: ExportPDFParams;
        outputAsset?: Asset;
    }): void;
    static validateExportPDFToImagesJobParams(params: {
        inputAsset: Asset;
        params: ExportPDFToImagesParams;
        outputAsset?: Asset;
    }): void;
    static validateExtractPDFJobParams(params: {
        inputAsset: Asset;
        params?: ExtractPDFParams;
        outputAsset?: Asset;
    }): void;
    static validateHTMLToPDFJobParams(params: {
        inputAsset?: Asset;
        inputURL?: string;
        outputAsset?: Asset;
        params?: HTMLToPDFParams;
    }): void;
    static validateInsertPagesJobParams(params: {
        params: InsertPagesParams;
        outputAsset?: Asset;
    }): void;
    static validateLinearizePDFJobParams(params: {
        inputAsset: Asset;
        outputAsset?: Asset;
    }): void;
    static validateOCRPDFJobParams(params: {
        inputAsset: Asset;
        params?: OCRParams;
        outputAsset?: Asset;
    }): void;
    static validatePDFPropertiesJobParams(params: {
        inputAsset: Asset;
        params?: PDFPropertiesParams;
    }): void;
    static validateProtectPDFJobParams(params: {
        inputAsset: Asset;
        params: ProtectPDFParams;
        outputAsset?: Asset;
    }): void;
    static validateRemoveProtectionJobParams(params: {
        inputAsset: Asset;
        params: RemoveProtectionParams;
        outputAsset?: Asset;
    }): void;
    static validateReorderPagesJobParams(params: {
        params: ReorderPagesParams;
        outputAsset?: Asset;
    }): void;
    static validateReplacePagesJobParams(params: {
        params: ReplacePagesParams;
        outputAsset?: Asset;
    }): void;
    static validateRotatePagesJobParams(params: {
        inputAsset: Asset;
        params: RotatePagesParams;
        outputAsset?: Asset;
    }): void;
    static validateSplitPDFJobParams(params: {
        inputAsset: Asset;
        params: SplitPDFParams;
        outputAsset?: Asset;
    }): void;
    static validateAccessibiltyCheckerPDFJobParams(params: {
        inputAsset: Asset;
        params?: PDFAccessibilityCheckerParams;
        outputAsset?: Asset;
    }): void;
    static validateWatermarkJobParams(params: {
        inputAsset: Asset;
        watermarkAsset: Asset;
        params?: PDFWatermarkParams;
        outputAsset?: Asset;
    }): void;
    static validateTokenCredentials(params: {
        clientId: string;
        token: string;
    }): void;
    static validateServicePrincipalCredentials(params: {
        clientId: string;
        clientSecret: string;
    }): void;
    static validatePDFServicesParams(params: {
        credentials: Credentials;
        clientConfig?: ClientConfig;
    }): void;
    static validateUploadParams(params: {
        readStream: NodeJS.ReadableStream;
        mimeType: MimeType | string;
    }): void;
    static validateSubmitParams(params: {
        job: PDFServicesJob;
        notifiers?: NotifierConfig[];
    }): void;
    static validateGetJobResultParams(params: {
        pollingURL: string;
        resultType: object;
    }): void;
    static validateGetJobStatusParams(params: {
        pollingURL: string;
    }): void;
    static validateGetContentParams(params: {
        asset: Asset;
    }): void;
    static validateDeleteAssetParams(params: {
        asset: Asset;
    }): void;
    static validateRefreshDownloadURIParams(params: {
        asset: Asset;
    }): void;
    static validateUploadAssetsParams(params: {
        streamAssets: {
            readStream: NodeJS.ReadableStream;
            mimeType: MimeType | string;
        }[];
    }): void;
    static validateFieldLocation(params: {
        left: number;
        top: number;
        right: number;
        bottom: number;
    }): void;
    static validateAccessibilityCheckerParams(params: {
        pageStart?: number;
        pageEnd?: number;
    }): void;
}