export declare class ApiError {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    code: string;
    message: string;
    description: string;
    dateTime: Date;
    innerError: ApiError;
    constructor(init?: Partial<ApiError>);
}
export declare class ApiErrorResponse {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    requestId: string;
    error: ApiError;
    constructor(init?: Partial<ApiErrorResponse>);
}
/**
 * Metered license consumption information
 */
export declare class ConsumptionResult {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Amount of used credits
     */
    credit: number;
    /**
     * Amount of MBs processed
     */
    quantity: number;
    constructor(init?: Partial<ConsumptionResult>);
}
/**
 * ConvertOptions base
 */
export declare class ConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Start conversion from FromPage page
     */
    fromPage: number;
    /**
     * Number of pages to convert
     */
    pagesCount: number;
    /**
     * Convert specific pages. The list contains the page indexes of the pages to be converted
     */
    pages: Array<number>;
    /**
     * Watermark specific options
     */
    watermarkOptions: WatermarkOptions;
    constructor(init?: Partial<ConvertOptions>);
}
/**
 * Defines conversion request
 */
export declare class ConvertSettings {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * StorageName which contains the file
     */
    storageName: string;
    /**
     * Gets or sets absolute path to a file in the storage
     */
    filePath: string;
    /**
     * Gets or sets requested conversion format
     */
    format: string;
    /**
     * Gets or sets format specific load options for source file
     */
    loadOptions: LoadOptions;
    /**
     * Gets or sets format specific convert options for output file
     */
    convertOptions: ConvertOptions;
    /**
     * Gets or sets converted file save path
     */
    outputPath: string;
    /**
     * The path to directory containing custom fonts in storage
     */
    fontsPath: string;
    constructor(init?: Partial<ConvertSettings>);
}
/**
 * Class for disc space information.
 */
export declare class DiscUsage {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Application used disc space.
     */
    usedSize: number;
    /**
     * Total disc space.
     */
    totalSize: number;
    constructor(init?: Partial<DiscUsage>);
}
/**
 * Contains a document metadata
 */
export declare class DocumentMetadata {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Document file type
     */
    fileType: string;
    /**
     * Gets pages count if applicable to the current document format
     */
    pageCount: number;
    /**
     * Document bytes size
     */
    size: number;
    /**
     * Returns detected width if applicable to the current document format
     */
    width: number;
    /**
     * Returns detected height if applicable to the current document format
     */
    height: number;
    /**
     * Returns detected horizontal resolution if applicable to the current document format
     */
    horizontalResolution: number;
    /**
     * Returns detected vertical resolution if applicable to the current document format
     */
    verticalResolution: number;
    /**
     * Returns detected bits per pixel if applicable to the current document format
     */
    bitsPerPixel: number;
    /**
     * Returns document title width if applicable to the current document format
     */
    title: string;
    /**
     * Returns detected document author if applicable to the current document format
     */
    author: string;
    /**
     * Returns detected document creation date if it's applicable to the current document format
     */
    createdDate: Date;
    /**
     * Returns detected document modification date if applicable to the current document format
     */
    modifiedDate: Date;
    /**
     * Returns list of layer names if applicable to the current document format
     */
    layers: Array<string>;
    /**
     * Is document password protected
     */
    isPasswordProtected: boolean;
    constructor(init?: Partial<DocumentMetadata>);
}
/**
 * The error details
 */
export declare class ErrorDetails {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * The request id
     */
    requestId: string;
    /**
     * Date
     */
    date: Date;
    constructor(init?: Partial<ErrorDetails>);
}
/**
 * Represents field label
 */
export declare class FieldLabel {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * The field name
     */
    field: FieldLabel.FieldEnum;
    /**
     * The label e.g. \"Sender\"
     */
    label: string;
    constructor(init?: Partial<FieldLabel>);
}
export declare namespace FieldLabel {
    enum FieldEnum {
        Start,
        TabField,
        Subject,
        ShowTimeAs,
        Sent,
        RequiredAttendees,
        RecurrencePattern,
        Recurrence,
        PageHeader,
        Organizer,
        Location,
        Importance,
        From,
        End,
        Bcc,
        Attachments,
        To
    }
}
/**
 * File versions FileVersion.
 */
export declare class FileVersions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * File versions FileVersion.
     */
    value: Array<FileVersion>;
    constructor(init?: Partial<FileVersions>);
}
/**
 * Files list
 */
export declare class FilesList {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Files and folders contained by folder StorageFile.
     */
    value: Array<StorageFile>;
    constructor(init?: Partial<FilesList>);
}
/**
 * File upload result
 */
export declare class FilesUploadResult {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * List of uploaded file names
     */
    uploaded: Array<string>;
    /**
     * List of errors.
     */
    errors: Array<Error>;
    constructor(init?: Partial<FilesUploadResult>);
}
/**
 * Current license information
 */
export declare class LicenseInfo {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * True, if license was applied and valid, otherwise False
     */
    isLicensed: boolean;
    constructor(init?: Partial<LicenseInfo>);
}
/**
 * Load document options
 */
export declare class LoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * The format of input file, (\"docx\", for example). This field must be filled with correct input file format when using ConvertDirect method, which accept input file as binary stream, and, because of that, API can correctly handle LoadOptions. In regular conversion, the input file format taken from the input file name and this field ignored.
     */
    format: string;
    constructor(init?: Partial<LoadOptions>);
}
/**
 * Error
 */
export declare class ModelError {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Code
     */
    code: string;
    /**
     * Message
     */
    message: string;
    /**
     * Description
     */
    description: string;
    /**
     * Inner Error
     */
    innerError: ErrorDetails;
    constructor(init?: Partial<ModelError>);
}
/**
 * Object exists
 */
export declare class ObjectExist {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Indicates that the file or folder exists.
     */
    exists: boolean;
    /**
     * True if it is a folder, false if it is a file.
     */
    isFolder: boolean;
    constructor(init?: Partial<ObjectExist>);
}
/**
 * Operation status result
 */
export declare class OperationResult {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    id: string;
    method: OperationResult.MethodEnum;
    status: OperationResult.StatusEnum;
    created: Date;
    started: Date;
    failed: Date;
    canceled: Date;
    finished: Date;
    result: Array<StoredConvertedResult>;
    error: string;
    constructor(init?: Partial<OperationResult>);
}
export declare namespace OperationResult {
    enum MethodEnum {
        Convert,
        ConvertAndSave
    }
    enum StatusEnum {
        Created,
        Started,
        Failed,
        Canceled,
        Finished
    }
}
/**
 * Storage exists
 */
export declare class StorageExist {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Shows that the storage exists.
     */
    exists: boolean;
    constructor(init?: Partial<StorageExist>);
}
/**
 * File or folder information
 */
export declare class StorageFile {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * File or folder name.
     */
    name: string;
    /**
     * True if it is a folder.
     */
    isFolder: boolean;
    /**
     * File or folder last modified DateTime.
     */
    modifiedDate: Date;
    /**
     * File or folder size.
     */
    size: number;
    /**
     * File or folder path.
     */
    path: string;
    constructor(init?: Partial<StorageFile>);
}
/**
 * Contains single converted item. Result is provided as url to a storage
 */
export declare class StoredConvertedResult {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Name of converted item
     */
    name: string;
    /**
     * Size of converted item
     */
    size: number;
    /**
     * Path of resource file in storage
     */
    path: string;
    /**
     * Uri in the storage of the converted item
     */
    url: string;
    constructor(init?: Partial<StoredConvertedResult>);
}
/**
 * Represents information about supported conversion for SourceFormat
 */
export declare class SupportedFormat {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Gets or sets source format
     */
    sourceFormat: string;
    /**
     * Gets or sets target formats
     */
    targetFormats: Array<string>;
    constructor(init?: Partial<SupportedFormat>);
}
/**
 * Options for settings watermark to the converted document
 */
export declare class WatermarkOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Watermark text
     */
    text: string;
    /**
     * Watermark font name if text watermark is applied
     */
    fontName: string;
    /**
     * Watermark font name if text watermark is applied
     */
    fontSize: number;
    /**
     * Watermark font bold style if text watermark is applied
     */
    bold: boolean;
    /**
     * Watermark font italic style if text watermark is applied
     */
    italic: boolean;
    /**
     * Watermark font color if text watermark is applied
     */
    color: string;
    /**
     * Watermark width
     */
    width: number;
    /**
     * Watermark height
     */
    height: number;
    /**
     * Watermark top position
     */
    top: number;
    /**
     * Watermark left position
     */
    left: number;
    /**
     * Watermark rotation angle
     */
    rotationAngle: number;
    /**
     * Watermark transparency. Value between 0 and 1. Value 0 is fully visible, value 1 is invisible.
     */
    transparency: number;
    /**
     * Indicates that the watermark is stamped as background. If the value is true, the watermark is layed at the bottom. By default is false and the watermark is layed on top.
     */
    background: boolean;
    /**
     * Image watermark
     */
    image: string;
    /**
     * Auto scale the watermark. If the value is true the font size and the position is automatically calculated to fit the page size.
     */
    autoAlign: boolean;
    constructor(init?: Partial<WatermarkOptions>);
}
/**
 * Options for loading CAD documents
 */
export declare class CadLoadOptions extends LoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Render specific CAD layouts
     */
    layoutNames: Array<string>;
    /**
     * Gets or sets a background color.
     */
    backgroundColor: string;
    /**
     * Gets or sets type of drawing.
     */
    drawType: CadLoadOptions.DrawTypeEnum;
    constructor(init?: Partial<CadLoadOptions>);
}
export declare namespace CadLoadOptions {
    enum DrawTypeEnum {
        UseDrawColor,
        UseObjectColor
    }
}
/**
 * Diagram document load options
 */
export declare class DiagramLoadOptions extends LoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Default font for Diagram document. The following font will be used if a font is missing.
     */
    defaultFont: string;
    constructor(init?: Partial<DiagramLoadOptions>);
}
/**
 * Ebook convert options
 */
export declare class EBookConvertOptions extends ConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Specifies page size
     */
    pageSize: EBookConvertOptions.PageSizeEnum;
    /**
     * Specifies page orientation
     */
    pageOrientation: EBookConvertOptions.PageOrientationEnum;
    constructor(init?: Partial<EBookConvertOptions>);
}
export declare namespace EBookConvertOptions {
    enum PageSizeEnum {
        Default,
        A3,
        Statement,
        Quarto,
        Paper11x17,
        Paper10x14,
        Letter,
        Legal,
        Ledger,
        Folio,
        Executive,
        EnvelopeDL,
        Custom,
        B5,
        B4,
        A5,
        A4,
        Tabloid
    }
    enum PageOrientationEnum {
        Default,
        Landscape,
        Portrait
    }
}
/**
 * Options for loading Email documents
 */
export declare class EmailLoadOptions extends LoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Option to display or hide the email header. Default: true
     */
    displayHeader: boolean;
    /**
     * Option to display or hide \"from\" email address. Default: true
     */
    displayFromEmailAddress: boolean;
    /**
     * Option to display or hide \"to\" email address. Default: true
     */
    displayToEmailAddress: boolean;
    /**
     * Option to display or hide \"Cc\" email address. Default: false
     */
    displayCcEmailAddress: boolean;
    /**
     * Option to display or hide \"Bcc\" email address. Default: false
     */
    displayBccEmailAddress: boolean;
    /**
     * Gets or sets the Coordinated Universal Time (UTC) offset for the message dates. This property defines the time zone difference, between the localtime and UTC.
     */
    timeZoneOffset: string;
    /**
     * Option to convert attachments in source email or not. Default: false.
     */
    convertAttachments: boolean;
    /**
     * The mapping between email message field and field text representation
     */
    fieldLabels: Array<FieldLabel>;
    /**
     * Defines whether need to keep original date header string in mail message when saving or not (Default value is true)
     */
    preserveOriginalDate: boolean;
    constructor(init?: Partial<EmailLoadOptions>);
}
/**
 * File Version
 */
export declare class FileVersion extends StorageFile {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * File Version ID.
     */
    versionId: string;
    /**
     * Specifies whether the file is (true) or is not (false) the latest version of an file.
     */
    isLatest: boolean;
    constructor(init?: Partial<FileVersion>);
}
/**
 * Options for to Image conversion
 */
export declare class ImageConvertOptions extends ConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Desired image width after conversion
     */
    width: number;
    /**
     * Desired image height after conversion
     */
    height: number;
    /**
     * Desired image horizontal resolution after conversion. The default resolution is the resolution of the input file or 96dpi
     */
    horizontalResolution: number;
    /**
     * Desired image vertical resolution after conversion. The default resolution is the resolution of the input file or 96dpi
     */
    verticalResolution: number;
    /**
     * Convert to grayscale image
     */
    grayscale: boolean;
    /**
     * Image rotation angle
     */
    rotateAngle: number;
    /**
     * If true, the input firstly is converted to PDF and after that to desired format
     */
    usePdf: boolean;
    /**
     * Adjust image brightness
     */
    brightness: number;
    /**
     * Adjust image contrast
     */
    contrast: number;
    /**
     * Adjust image gamma
     */
    gamma: number;
    /**
     * Image flip mode
     */
    flipMode: ImageConvertOptions.FlipModeEnum;
    /**
     * Gets or sets a background color.
     */
    backgroundColor: string;
    constructor(init?: Partial<ImageConvertOptions>);
}
export declare namespace ImageConvertOptions {
    enum FlipModeEnum {
        None,
        FlipX,
        FlipY,
        FlipXY
    }
}
/**
 * Image document load options
 */
export declare class ImageLoadOptions extends LoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Default font for Psd, Emf, Wmf document types. The following font will be used if a font is missing.
     */
    defaultFont: string;
    constructor(init?: Partial<ImageLoadOptions>);
}
/**
 * One document load options
 */
export declare class OneLoadOptions extends LoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Default font for Note document. The following font will be used if a font is missing.
     */
    defaultFont: string;
    /**
     * Substitute specific fonts when converting Note document.
     */
    fontSubstitutes: {
        [key: string]: string;
    };
    /**
     * Set password to unprotect protected document
     */
    password: string;
    constructor(init?: Partial<OneLoadOptions>);
}
/**
 * Page description langusge convert options
 */
export declare class PDLConvertOptions extends ConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<PDLConvertOptions>);
}
/**
 * Options for to PDF conversion
 */
export declare class PdfConvertOptions extends ConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Desired page width in pixels after conversion
     */
    width: number;
    /**
     * Desired page height in pixels after conversion
     */
    height: number;
    /**
     * Desired page DPI after conversion. The default resolution is: 96dpi
     */
    dpi: number;
    /**
     * Set this property if you want to protect the converted document with a password
     */
    password: string;
    /**
     * Desired page top margin in pixels after conversion
     */
    marginTop: number;
    /**
     * Desired page bottom margin in pixels after conversion
     */
    marginBottom: number;
    /**
     * Desired page left margin in pixels after conversion
     */
    marginLeft: number;
    /**
     * Desired page right margin in pixels after conversion
     */
    marginRight: number;
    /**
     * Set the pdf format of the converted document.
     */
    pdfFormat: PdfConvertOptions.PdfFormatEnum;
    /**
     * Remove Pdf-A Compliance
     */
    removePdfaCompliance: boolean;
    /**
     * Specifies the zoom level in percentage. Default is 100.
     */
    zoom: number;
    /**
     * Linearize PDF Document for the Web
     */
    linearize: boolean;
    /**
     * Link duplicate streams
     */
    linkDuplicateStreams: boolean;
    /**
     * Remove unused objects
     */
    removeUnusedObjects: boolean;
    /**
     * Remove unused streams
     */
    removeUnusedStreams: boolean;
    /**
     * If CompressImages set to true, all images in the document are recompressed. The compression is defined by the ImageQuality property.
     */
    compressImages: boolean;
    /**
     * Value in percent where 100% is unchanged quality and image size. To decrease the image size, use ImageQuality less than 100
     */
    imageQuality: number;
    /**
     * Make fonts not embedded if set to true
     */
    unembedFonts: boolean;
    /**
     * Convert a PDF from RGB colorspace to Grayscale
     */
    grayscale: boolean;
    /**
     * Specify whether position of the document's window will be centered on the screen. Default: false.
     */
    centerWindow: boolean;
    /**
     * Sets reading order of text: L2R (left to right) or R2L (right to left). Default: L2R.
     */
    direction: PdfConvertOptions.DirectionEnum;
    /**
     * Specifying whether document's window title bar should display document title. Default: false.
     */
    displayDocTitle: boolean;
    /**
     * Specify whether document window must be resized to fit the first displayed page. Default: false.
     */
    fitWindow: boolean;
    /**
     * Specify whether menu bar should be hidden when document is active. Default: false.
     */
    hideMenuBar: boolean;
    /**
     * Specifying whether toolbar should be hidden when document is active. Default: false.
     */
    hideToolBar: boolean;
    /**
     * Specify whether user interface elements should be hidden when document is active. Default: false.
     */
    hideWindowUI: boolean;
    /**
     * Sets page mode, specifying how to display the document on exiting full-screen mode.
     */
    nonFullScreenPageMode: PdfConvertOptions.NonFullScreenPageModeEnum;
    /**
     * Sets page layout which shall be used when the document is opened.
     */
    pageLayout: PdfConvertOptions.PageLayoutEnum;
    /**
     * Sets page mode, specifying how document should be displayed when opened.
     */
    pageMode: PdfConvertOptions.PageModeEnum;
    /**
     * Rotate page
     */
    rotate: PdfConvertOptions.RotateEnum;
    /**
     * Specifies page size
     */
    pageSize: PdfConvertOptions.PageSizeEnum;
    /**
     * Specifies page orientation
     */
    pageOrientation: PdfConvertOptions.PageOrientationEnum;
    constructor(init?: Partial<PdfConvertOptions>);
}
export declare namespace PdfConvertOptions {
    enum PdfFormatEnum {
        Default,
        PdfA1A,
        PdfA1B,
        PdfA2A,
        PdfA3A,
        PdfA2B,
        PdfA2U,
        PdfA3B,
        PdfA3U,
        V13,
        V14,
        V15,
        V16,
        V17,
        PdfX1A,
        PdfX3
    }
    enum DirectionEnum {
        L2R,
        R2L
    }
    enum NonFullScreenPageModeEnum {
        UseNone,
        UseOutlines,
        UseThumbs,
        FullScreen,
        UseOC,
        UseAttachments
    }
    enum PageLayoutEnum {
        Default,
        SinglePage,
        OneColumn,
        TwoColumnLeft,
        TwoColumnRight,
        TwoPageLeft,
        TwoPageRight
    }
    enum PageModeEnum {
        UseNone,
        UseOutlines,
        UseThumbs,
        FullScreen,
        UseOC,
        UseAttachments
    }
    enum RotateEnum {
        None,
        On90,
        On180,
        On270
    }
    enum PageSizeEnum {
        Default,
        A3,
        Statement,
        Quarto,
        Paper11x17,
        Paper10x14,
        Letter,
        Legal,
        Ledger,
        Folio,
        Executive,
        EnvelopeDL,
        Custom,
        B5,
        B4,
        A5,
        A4,
        Tabloid
    }
    enum PageOrientationEnum {
        Default,
        Landscape,
        Portrait
    }
}
/**
 * Pdf document load options
 */
export declare class PdfLoadOptions extends LoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Remove embedded files
     */
    removeEmbeddedFiles: boolean;
    /**
     * Set password to unprotect protected document
     */
    password: string;
    /**
     * Hide annotations in Pdf documents
     */
    hidePdfAnnotations: boolean;
    /**
     * Flatten all the fields of the PDF form
     */
    flattenAllFields: boolean;
    constructor(init?: Partial<PdfLoadOptions>);
}
/**
 * Options for loading personal storage documents.
 */
export declare class PersonalStorageLoadOptions extends LoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Folder which to be processed Default is Inbox
     */
    folder: string;
    /**
     * Controls how many levels in depth to perform conversion
     */
    depth: number;
    constructor(init?: Partial<PersonalStorageLoadOptions>);
}
/**
 * Options for to presentation conversion
 */
export declare class PresentationConvertOptions extends ConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Set this property if you want to protect the converted document with a password
     */
    password: string;
    /**
     * Specifies the zoom level in percentage. Default is 100. Default zoom is supported till Microsoft Powerpoint 2010. Starting from Microsoft Powerpoint 2013 default zoom is no longer set to document, instead it appears to use the zoom factor of the last document that was opened.
     */
    zoom: number;
    constructor(init?: Partial<PresentationConvertOptions>);
}
/**
 * Presentation document load options
 */
export declare class PresentationLoadOptions extends LoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Default font for rendering the presentation. The following font will be used if a presentation font is missing.
     */
    defaultFont: string;
    /**
     * Substitute specific fonts when converting Slides document.
     */
    fontSubstitutes: {
        [key: string]: string;
    };
    /**
     * Set password to unprotect protected document
     */
    password: string;
    /**
     * Hide comments
     */
    hideComments: boolean;
    /**
     * Show hidden slides
     */
    showHiddenSlides: boolean;
    constructor(init?: Partial<PresentationLoadOptions>);
}
/**
 * Spreadsheet сonvert options class
 */
export declare class SpreadsheetConvertOptions extends ConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Set this property if you want to protect the converted document with a password
     */
    password: string;
    /**
     * Specifies the zoom level in percentage. Default is 100.
     */
    zoom: number;
    /**
     * If true, the input firstly is converted to PDF and after that to desired format
     */
    usePdf: boolean;
    constructor(init?: Partial<SpreadsheetConvertOptions>);
}
/**
 * Spreadsheet document load options
 */
export declare class SpreadsheetLoadOptions extends LoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Default font for Cells document. The following font will be used if a font is missing.
     */
    defaultFont: string;
    /**
     * Substitute specific fonts when converting Cells document.
     */
    fontSubstitutes: {
        [key: string]: string;
    };
    /**
     * Show grid lines when converting Excel files
     */
    showGridLines: boolean;
    /**
     * Show hidden sheets when converting Excel files
     */
    showHiddenSheets: boolean;
    /**
     * If OnePagePerSheet is true the content of the sheet will be converted to one page in the PDF document. Default value is true.
     */
    onePagePerSheet: boolean;
    /**
     * Convert specific range when converting to other than cells format. Example: \"D1:F8\"
     */
    convertRange: string;
    /**
     * Skips empty rows and columns when converting. Default is True.
     */
    skipEmptyRowsAndColumns: boolean;
    /**
     * Set password to unprotect protected document
     */
    password: string;
    /**
     * Hide comments
     */
    hideComments: boolean;
    constructor(init?: Partial<SpreadsheetLoadOptions>);
}
/**
 * Txt convert options
 */
export declare class TxtConvertOptions extends ConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<TxtConvertOptions>);
}
/**
 * Txt document load options
 */
export declare class TxtLoadOptions extends LoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Allows to specify how numbered list items are recognized when plain text document is converted. The default value is true.
     */
    detectNumberingWithWhitespaces: boolean;
    /**
     * Gets or sets preferred option of a trailing space handling. Default value is Trim.
     */
    trailingSpacesOptions: TxtLoadOptions.TrailingSpacesOptionsEnum;
    /**
     * Gets or sets preferred option of a leading space handling. Default value is ConvertToIndent.
     */
    leadingSpacesOptions: TxtLoadOptions.LeadingSpacesOptionsEnum;
    /**
     * Gets or sets the encoding that will be used when loading Txt document. Can be null. Default is null.
     */
    encoding: string;
    constructor(init?: Partial<TxtLoadOptions>);
}
export declare namespace TxtLoadOptions {
    enum TrailingSpacesOptionsEnum {
        Preserve,
        Trim
    }
    enum LeadingSpacesOptionsEnum {
        ConvertToIndent,
        Preserve,
        Trim
    }
}
/**
 * Options for to Html conversion
 */
export declare class WebConvertOptions extends ConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * If true, the input firstly is converted to PDF and after that to desired format
     */
    usePdf: boolean;
    /**
     * If true fixed layout will be used e.g. absolutely positioned html elements Default:  true
     */
    fixedLayout: boolean;
    /**
     * Show page borders when converting to fixed layout. Default is True
     */
    fixedLayoutShowBorders: boolean;
    /**
     * Specifies the zoom level in percentage. Default is 100.
     */
    zoom: number;
    constructor(init?: Partial<WebConvertOptions>);
}
/**
 * Html document load options
 */
export declare class WebLoadOptions extends LoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Enable or disable generation of page numbering in converted document. Default: false
     */
    pageNumbering: boolean;
    /**
     * Get or sets the encoding to be used when loading the web document. If the property is null the encoding will be determined from document character set attribute
     */
    encoding: string;
    /**
     * Use pdf for the conversion. Default: false
     */
    usePdf: boolean;
    /**
     * Controls how HTML content is rendered. Default: AbsolutePositioning
     */
    renderingMode: WebLoadOptions.RenderingModeEnum;
    constructor(init?: Partial<WebLoadOptions>);
}
export declare namespace WebLoadOptions {
    enum RenderingModeEnum {
        Flow,
        AbsolutePositioning
    }
}
/**
 * Options for to word processing conversion
 */
export declare class WordProcessingConvertOptions extends ConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Desired page width after conversion
     */
    width: number;
    /**
     * Desired page height after conversion
     */
    height: number;
    /**
     * Desired page DPI after conversion. The default resolution is: 96dpi
     */
    dpi: number;
    /**
     * Set this property if you want to protect the converted document with a password
     */
    password: string;
    /**
     * Specifies the zoom level in percentage. Default is 100. Default zoom is supported till Microsoft Word 2010. Starting from Microsoft Word 2013 default zoom is no longer set to document, instead it appears to use the zoom factor of the last document that was opened.
     */
    zoom: number;
    /**
     * Recognition mode when converting from pdf
     */
    pdfRecognitionMode: WordProcessingConvertOptions.PdfRecognitionModeEnum;
    /**
     * Page size
     */
    pageSize: WordProcessingConvertOptions.PageSizeEnum;
    /**
     * Specifies page orientation
     */
    pageOrientation: WordProcessingConvertOptions.PageOrientationEnum;
    constructor(init?: Partial<WordProcessingConvertOptions>);
}
export declare namespace WordProcessingConvertOptions {
    enum PdfRecognitionModeEnum {
        Textbox,
        Flow
    }
    enum PageSizeEnum {
        Default,
        A3,
        Statement,
        Quarto,
        Paper11x17,
        Paper10x14,
        Letter,
        Legal,
        Ledger,
        Folio,
        Executive,
        EnvelopeDL,
        Custom,
        B5,
        B4,
        A5,
        A4,
        Tabloid
    }
    enum PageOrientationEnum {
        Default,
        Landscape,
        Portrait
    }
}
/**
 * WordProcessing document load options
 */
export declare class WordProcessingLoadOptions extends LoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Default font for Words document. The following font will be used if a font is missing.
     */
    defaultFont: string;
    /**
     * If AutoFontSubstitution is disabled, GroupDocs.Conversion uses the DefaultFont for the substitution of missing fonts. If AutoFontSubstitution is enabled, GroupDocs.Conversion evaluates all the related fields in FontInfo (Panose, Sig etc) for the missing font and finds the closest match among the available font sources. Note that font substitution mechanism will override the DefaultFont in cases when FontInfo for the missing font is available in the document. The default value is True.
     */
    autoFontSubstitution: boolean;
    /**
     * Substitute specific fonts when converting Words document.
     */
    fontSubstitutes: {
        [key: string]: string;
    };
    /**
     * Set password to unprotect protected document
     */
    password: string;
    /**
     * Hide markup and track changes for Word documents
     */
    hideWordTrackedChanges: boolean;
    /**
     * Hide comments
     */
    hideComments: boolean;
    /**
     * Specifies the default level in the document outline at which to display Word bookmarks. Default is 0. Valid range is 0 to 9.
     */
    bookmarksOutlineLevel: number;
    /**
     * Specifies how many levels of headings (paragraphs formatted with the Heading styles) to include in the document outline. Default is 0. Valid range is 0 to 9.
     */
    headingsOutlineLevels: number;
    /**
     * Specifies how many levels in the document outline to show expanded when the file is viewed. Default is 0. Valid range is 0 to 9. Note that this options will not work when saving to XPS.
     */
    expandedOutlineLevels: number;
    constructor(init?: Partial<WordProcessingLoadOptions>);
}
/**
 * XML document load options
 */
export declare class XmlLoadOptions extends LoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * XSL document content to convert XML-FO using XSL
     */
    xslFo: string;
    constructor(init?: Partial<XmlLoadOptions>);
}
/**
 * Bmp convert options
 */
export declare class BmpConvertOptions extends ImageConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<BmpConvertOptions>);
}
export declare namespace BmpConvertOptions {
}
/**
 * Bmp load options
 */
export declare class BmpLoadOptions extends ImageLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<BmpLoadOptions>);
}
/**
 * Cf2 load options
 */
export declare class Cf2LoadOptions extends CadLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<Cf2LoadOptions>);
}
export declare namespace Cf2LoadOptions {
}
/**
 * Csv document load options
 */
export declare class CsvLoadOptions extends SpreadsheetLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Delimiter of a Csv file
     */
    separator: string;
    /**
     * True means the file contains several encodings
     */
    isMultiEncoded: boolean;
    /**
     * Indicates whether text is formula if it starts with \"=\"
     */
    hasFormula: boolean;
    /**
     * Indicates whether the string in the file is converted to numeric. Default is True
     */
    convertNumericData: boolean;
    /**
     * Indicates whether the string in the file is converted to date. Default is True
     */
    convertDateTimeData: boolean;
    /**
     * File encoding
     */
    encoding: string;
    constructor(init?: Partial<CsvLoadOptions>);
}
/**
 * Dcm convert options
 */
export declare class DcmConvertOptions extends ImageConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<DcmConvertOptions>);
}
export declare namespace DcmConvertOptions {
}
/**
 * Dcm load options
 */
export declare class DcmLoadOptions extends ImageLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<DcmLoadOptions>);
}
/**
 * Dgn load options
 */
export declare class DgnLoadOptions extends CadLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<DgnLoadOptions>);
}
export declare namespace DgnLoadOptions {
}
/**
 * Djvu convert options
 */
export declare class DjvuConvertOptions extends ImageConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<DjvuConvertOptions>);
}
export declare namespace DjvuConvertOptions {
}
/**
 * Dng convert options
 */
export declare class DngConvertOptions extends ImageConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<DngConvertOptions>);
}
export declare namespace DngConvertOptions {
}
/**
 * Dng load options
 */
export declare class DngLoadOptions extends ImageLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<DngLoadOptions>);
}
/**
 * Doc convert options
 */
export declare class DocConvertOptions extends WordProcessingConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<DocConvertOptions>);
}
export declare namespace DocConvertOptions {
}
/**
 * Doc load options
 */
export declare class DocLoadOptions extends WordProcessingLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<DocLoadOptions>);
}
/**
 * Docm convert options
 */
export declare class DocmConvertOptions extends WordProcessingConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<DocmConvertOptions>);
}
export declare namespace DocmConvertOptions {
}
/**
 * Docm load options
 */
export declare class DocmLoadOptions extends WordProcessingLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<DocmLoadOptions>);
}
/**
 * Docx convert options
 */
export declare class DocxConvertOptions extends WordProcessingConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<DocxConvertOptions>);
}
export declare namespace DocxConvertOptions {
}
/**
 * Docx load options
 */
export declare class DocxLoadOptions extends WordProcessingLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<DocxLoadOptions>);
}
/**
 * Dot convert options
 */
export declare class DotConvertOptions extends WordProcessingConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<DotConvertOptions>);
}
export declare namespace DotConvertOptions {
}
/**
 * Dot load options
 */
export declare class DotLoadOptions extends WordProcessingLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<DotLoadOptions>);
}
/**
 * Dotm convert options
 */
export declare class DotmConvertOptions extends WordProcessingConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<DotmConvertOptions>);
}
export declare namespace DotmConvertOptions {
}
/**
 * Dotm load options
 */
export declare class DotmLoadOptions extends WordProcessingLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<DotmLoadOptions>);
}
/**
 * Dotx convert options
 */
export declare class DotxConvertOptions extends WordProcessingConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<DotxConvertOptions>);
}
export declare namespace DotxConvertOptions {
}
/**
 * Dotx load options
 */
export declare class DotxLoadOptions extends WordProcessingLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<DotxLoadOptions>);
}
/**
 * Dwf load options
 */
export declare class DwfLoadOptions extends CadLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<DwfLoadOptions>);
}
export declare namespace DwfLoadOptions {
}
/**
 * Dwfx load options
 */
export declare class DwfxLoadOptions extends CadLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<DwfxLoadOptions>);
}
export declare namespace DwfxLoadOptions {
}
/**
 * Dwg load options
 */
export declare class DwgLoadOptions extends CadLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<DwgLoadOptions>);
}
export declare namespace DwgLoadOptions {
}
/**
 * Dwt load options
 */
export declare class DwtLoadOptions extends CadLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<DwtLoadOptions>);
}
export declare namespace DwtLoadOptions {
}
/**
 * Dxf load options
 */
export declare class DxfLoadOptions extends CadLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<DxfLoadOptions>);
}
export declare namespace DxfLoadOptions {
}
/**
 * Emf convert options
 */
export declare class EmfConvertOptions extends ImageConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<EmfConvertOptions>);
}
export declare namespace EmfConvertOptions {
}
/**
 * Emf load options
 */
export declare class EmfLoadOptions extends ImageLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<EmfLoadOptions>);
}
/**
 * Eml load options
 */
export declare class EmlLoadOptions extends EmailLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<EmlLoadOptions>);
}
/**
 * Emlx load options
 */
export declare class EmlxLoadOptions extends EmailLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<EmlxLoadOptions>);
}
/**
 * Gif convert options
 */
export declare class GifConvertOptions extends ImageConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<GifConvertOptions>);
}
export declare namespace GifConvertOptions {
}
/**
 * Gif load options
 */
export declare class GifLoadOptions extends ImageLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<GifLoadOptions>);
}
/**
 * Ico convert options
 */
export declare class IcoConvertOptions extends ImageConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<IcoConvertOptions>);
}
export declare namespace IcoConvertOptions {
}
/**
 * Ico load options
 */
export declare class IcoLoadOptions extends ImageLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<IcoLoadOptions>);
}
/**
 * Ifc load options
 */
export declare class IfcLoadOptions extends CadLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<IfcLoadOptions>);
}
export declare namespace IfcLoadOptions {
}
/**
 * Igs load options
 */
export declare class IgsLoadOptions extends CadLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<IgsLoadOptions>);
}
export declare namespace IgsLoadOptions {
}
/**
 * J2c load options
 */
export declare class J2cLoadOptions extends ImageLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<J2cLoadOptions>);
}
/**
 * J2k load options
 */
export declare class J2kLoadOptions extends ImageLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<J2kLoadOptions>);
}
/**
 * Jp2 load options
 */
export declare class Jp2LoadOptions extends ImageLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<Jp2LoadOptions>);
}
/**
 * Jpeg load options
 */
export declare class JpegLoadOptions extends ImageLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<JpegLoadOptions>);
}
/**
 * Jpf load options
 */
export declare class JpfLoadOptions extends ImageLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<JpfLoadOptions>);
}
/**
 * Jpg convert options
 */
export declare class JpgConvertOptions extends ImageConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Desired image quality when converting to Jpeg. The value must be between 0 and 100. The default value is 100.
     */
    quality: number;
    constructor(init?: Partial<JpgConvertOptions>);
}
export declare namespace JpgConvertOptions {
}
/**
 * Jpg load options
 */
export declare class JpgLoadOptions extends ImageLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<JpgLoadOptions>);
}
/**
 * Jpm load options
 */
export declare class JpmLoadOptions extends ImageLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<JpmLoadOptions>);
}
/**
 * Jpx load options
 */
export declare class JpxLoadOptions extends ImageLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<JpxLoadOptions>);
}
/**
 * Mht load options
 */
export declare class MhtLoadOptions extends EmailLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<MhtLoadOptions>);
}
/**
 * Mobi load options
 */
export declare class MobiLoadOptions extends WordProcessingLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<MobiLoadOptions>);
}
/**
 * Msg load options
 */
export declare class MsgLoadOptions extends EmailLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<MsgLoadOptions>);
}
/**
 * Odg convert options
 */
export declare class OdgConvertOptions extends ImageConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<OdgConvertOptions>);
}
export declare namespace OdgConvertOptions {
}
/**
 * Odg load options
 */
export declare class OdgLoadOptions extends ImageLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<OdgLoadOptions>);
}
/**
 * Odp convert options
 */
export declare class OdpConvertOptions extends PresentationConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<OdpConvertOptions>);
}
/**
 * Odp load options
 */
export declare class OdpLoadOptions extends PresentationLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<OdpLoadOptions>);
}
/**
 * Ods convert options
 */
export declare class OdsConvertOptions extends SpreadsheetConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<OdsConvertOptions>);
}
/**
 * Ods load options
 */
export declare class OdsLoadOptions extends SpreadsheetLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<OdsLoadOptions>);
}
/**
 * Odt convert options
 */
export declare class OdtConvertOptions extends WordProcessingConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<OdtConvertOptions>);
}
export declare namespace OdtConvertOptions {
}
/**
 * Odt load options
 */
export declare class OdtLoadOptions extends WordProcessingLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<OdtLoadOptions>);
}
/**
 * Ost load options
 */
export declare class OstLoadOptions extends EmailLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<OstLoadOptions>);
}
/**
 * Otp convert options
 */
export declare class OtpConvertOptions extends PresentationConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<OtpConvertOptions>);
}
/**
 * Otp load options
 */
export declare class OtpLoadOptions extends PresentationLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<OtpLoadOptions>);
}
/**
 * Ots convert options
 */
export declare class OtsConvertOptions extends SpreadsheetConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<OtsConvertOptions>);
}
/**
 * Ots load options
 */
export declare class OtsLoadOptions extends SpreadsheetLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<OtsLoadOptions>);
}
/**
 * Ott convert options
 */
export declare class OttConvertOptions extends WordProcessingConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<OttConvertOptions>);
}
export declare namespace OttConvertOptions {
}
/**
 * Ott load options
 */
export declare class OttLoadOptions extends WordProcessingLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<OttLoadOptions>);
}
/**
 * Plt load options
 */
export declare class PltLoadOptions extends CadLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<PltLoadOptions>);
}
export declare namespace PltLoadOptions {
}
/**
 * Png convert options
 */
export declare class PngConvertOptions extends ImageConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<PngConvertOptions>);
}
export declare namespace PngConvertOptions {
}
/**
 * Png load options
 */
export declare class PngLoadOptions extends ImageLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<PngLoadOptions>);
}
/**
 * Potm convert options
 */
export declare class PotmConvertOptions extends PresentationConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<PotmConvertOptions>);
}
/**
 * Potm load options
 */
export declare class PotmLoadOptions extends PresentationLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<PotmLoadOptions>);
}
/**
 * Potx convert options
 */
export declare class PotxConvertOptions extends PresentationConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<PotxConvertOptions>);
}
/**
 * Potx load options
 */
export declare class PotxLoadOptions extends PresentationLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<PotxLoadOptions>);
}
/**
 * Pps convert options
 */
export declare class PpsConvertOptions extends PresentationConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<PpsConvertOptions>);
}
/**
 * Pps load options
 */
export declare class PpsLoadOptions extends PresentationLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<PpsLoadOptions>);
}
/**
 * Ppsm convert options
 */
export declare class PpsmConvertOptions extends PresentationConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<PpsmConvertOptions>);
}
/**
 * Ppsm load options
 */
export declare class PpsmLoadOptions extends PresentationLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<PpsmLoadOptions>);
}
/**
 * Ppsx convert options
 */
export declare class PpsxConvertOptions extends PresentationConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<PpsxConvertOptions>);
}
/**
 * Ppsx load options
 */
export declare class PpsxLoadOptions extends PresentationLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<PpsxLoadOptions>);
}
/**
 * Ppt convert options
 */
export declare class PptConvertOptions extends PresentationConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<PptConvertOptions>);
}
/**
 * Ppt load options
 */
export declare class PptLoadOptions extends PresentationLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<PptLoadOptions>);
}
/**
 * Pptm convert options
 */
export declare class PptmConvertOptions extends PresentationConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<PptmConvertOptions>);
}
/**
 * Pptm load options
 */
export declare class PptmLoadOptions extends PresentationLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<PptmLoadOptions>);
}
/**
 * Pptx convert options
 */
export declare class PptxConvertOptions extends PresentationConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<PptxConvertOptions>);
}
/**
 * Pptx load options
 */
export declare class PptxLoadOptions extends PresentationLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<PptxLoadOptions>);
}
/**
 * Psd convert options
 */
export declare class PsdConvertOptions extends ImageConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Bits count per color channel
     */
    channelBitsCount: number;
    /**
     * Color channels count
     */
    channelsCount: number;
    /**
     * Psd color mode
     */
    colorMode: PsdConvertOptions.ColorModeEnum;
    /**
     * Psd compression method
     */
    compressionMethod: PsdConvertOptions.CompressionMethodEnum;
    /**
     * Psd file version
     */
    version: number;
    constructor(init?: Partial<PsdConvertOptions>);
}
export declare namespace PsdConvertOptions {
    enum ColorModeEnum {
        Bitmap,
        Grayscale,
        Indexed,
        Rgb,
        Cmyk,
        Multichannel,
        Duotone,
        Lab
    }
    enum CompressionMethodEnum {
        Raw,
        Rle,
        ZipWithoutPrediction,
        ZipWithPrediction
    }
}
/**
 * Psd load options
 */
export declare class PsdLoadOptions extends ImageLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<PsdLoadOptions>);
}
/**
 * Pst load options
 */
export declare class PstLoadOptions extends EmailLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<PstLoadOptions>);
}
/**
 * Rtf convert options
 */
export declare class RtfConvertOptions extends WordProcessingConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Specifies whether the keywords for \"old readers\" are written to RTF or not. This can significantly affect the size of the RTF document. Default is False.
     */
    exportImagesForOldReaders: boolean;
    constructor(init?: Partial<RtfConvertOptions>);
}
export declare namespace RtfConvertOptions {
}
/**
 * Stl load options
 */
export declare class StlLoadOptions extends CadLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<StlLoadOptions>);
}
export declare namespace StlLoadOptions {
}
/**
 * Tif load options
 */
export declare class TifLoadOptions extends ImageLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<TifLoadOptions>);
}
/**
 * Tiff convert options
 */
export declare class TiffConvertOptions extends ImageConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Set Tiff compression
     */
    compression: TiffConvertOptions.CompressionEnum;
    constructor(init?: Partial<TiffConvertOptions>);
}
export declare namespace TiffConvertOptions {
    enum CompressionEnum {
        Lzw,
        None,
        Ccitt3,
        Ccitt4,
        Rle
    }
}
/**
 * Tiff load options
 */
export declare class TiffLoadOptions extends ImageLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<TiffLoadOptions>);
}
/**
 * Tsv convert options
 */
export declare class TsvConvertOptions extends SpreadsheetConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<TsvConvertOptions>);
}
/**
 * Tsv load options
 */
export declare class TsvLoadOptions extends SpreadsheetLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<TsvLoadOptions>);
}
/**
 * Vdw load options
 */
export declare class VdwLoadOptions extends DiagramLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<VdwLoadOptions>);
}
/**
 * Vdx load options
 */
export declare class VdxLoadOptions extends DiagramLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<VdxLoadOptions>);
}
/**
 * Vsd load options
 */
export declare class VsdLoadOptions extends DiagramLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<VsdLoadOptions>);
}
/**
 * Vsdm load options
 */
export declare class VsdmLoadOptions extends DiagramLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<VsdmLoadOptions>);
}
/**
 * Vsdx load options
 */
export declare class VsdxLoadOptions extends DiagramLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<VsdxLoadOptions>);
}
/**
 * Vss load options
 */
export declare class VssLoadOptions extends DiagramLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<VssLoadOptions>);
}
/**
 * Vssm load options
 */
export declare class VssmLoadOptions extends DiagramLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<VssmLoadOptions>);
}
/**
 * Vssx load options
 */
export declare class VssxLoadOptions extends DiagramLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<VssxLoadOptions>);
}
/**
 * Vst load options
 */
export declare class VstLoadOptions extends DiagramLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<VstLoadOptions>);
}
/**
 * Vstm load options
 */
export declare class VstmLoadOptions extends DiagramLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<VstmLoadOptions>);
}
/**
 * Vstx load options
 */
export declare class VstxLoadOptions extends DiagramLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<VstxLoadOptions>);
}
/**
 * Vsx load options
 */
export declare class VsxLoadOptions extends DiagramLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<VsxLoadOptions>);
}
/**
 * Vtx load options
 */
export declare class VtxLoadOptions extends DiagramLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<VtxLoadOptions>);
}
/**
 * Webp convert options
 */
export declare class WebpConvertOptions extends ImageConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    /**
     * Indicates if the compression of the converted file will be lossless
     */
    lossless: boolean;
    constructor(init?: Partial<WebpConvertOptions>);
}
export declare namespace WebpConvertOptions {
}
/**
 * Webp load options
 */
export declare class WebpLoadOptions extends ImageLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<WebpLoadOptions>);
}
/**
 * Wmf convert options
 */
export declare class WmfConvertOptions extends ImageConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<WmfConvertOptions>);
}
export declare namespace WmfConvertOptions {
}
/**
 * Wmf load options
 */
export declare class WmfLoadOptions extends ImageLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<WmfLoadOptions>);
}
/**
 * Xls2003 convert options
 */
export declare class Xls2003ConvertOptions extends SpreadsheetConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<Xls2003ConvertOptions>);
}
/**
 * Xls2003 load options
 */
export declare class Xls2003LoadOptions extends SpreadsheetLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<Xls2003LoadOptions>);
}
/**
 * Xls convert options
 */
export declare class XlsConvertOptions extends SpreadsheetConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<XlsConvertOptions>);
}
/**
 * Xls load options
 */
export declare class XlsLoadOptions extends SpreadsheetLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<XlsLoadOptions>);
}
/**
 * Xlsb convert options
 */
export declare class XlsbConvertOptions extends SpreadsheetConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<XlsbConvertOptions>);
}
/**
 * Xlsb load options
 */
export declare class XlsbLoadOptions extends SpreadsheetLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<XlsbLoadOptions>);
}
/**
 * Xlsm convert options
 */
export declare class XlsmConvertOptions extends SpreadsheetConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<XlsmConvertOptions>);
}
/**
 * Xlsm load options
 */
export declare class XlsmLoadOptions extends SpreadsheetLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<XlsmLoadOptions>);
}
/**
 * Xlsx convert options
 */
export declare class XlsxConvertOptions extends SpreadsheetConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<XlsxConvertOptions>);
}
/**
 * Xlsx load options
 */
export declare class XlsxLoadOptions extends SpreadsheetLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<XlsxLoadOptions>);
}
/**
 * Xltm convert options
 */
export declare class XltmConvertOptions extends SpreadsheetConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<XltmConvertOptions>);
}
/**
 * Xltm load options
 */
export declare class XltmLoadOptions extends SpreadsheetLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<XltmLoadOptions>);
}
/**
 * Xltx convert options
 */
export declare class XltxConvertOptions extends SpreadsheetConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<XltxConvertOptions>);
}
/**
 * Xltx load options
 */
export declare class XltxLoadOptions extends SpreadsheetLoadOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<XltxLoadOptions>);
}
/**
 * J2c convert options
 */
export declare class J2cConvertOptions extends JpgConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<J2cConvertOptions>);
}
export declare namespace J2cConvertOptions {
}
/**
 * J2k convert options
 */
export declare class J2kConvertOptions extends JpgConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<J2kConvertOptions>);
}
export declare namespace J2kConvertOptions {
}
/**
 * Jp2 convert options
 */
export declare class Jp2ConvertOptions extends JpgConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<Jp2ConvertOptions>);
}
export declare namespace Jp2ConvertOptions {
}
/**
 * Jpeg convert options
 */
export declare class JpegConvertOptions extends JpgConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<JpegConvertOptions>);
}
export declare namespace JpegConvertOptions {
}
/**
 * Jpf convert options
 */
export declare class JpfConvertOptions extends JpgConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<JpfConvertOptions>);
}
export declare namespace JpfConvertOptions {
}
/**
 * Jpm convert options
 */
export declare class JpmConvertOptions extends JpgConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<JpmConvertOptions>);
}
export declare namespace JpmConvertOptions {
}
/**
 * Jpx convert options
 */
export declare class JpxConvertOptions extends JpgConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<JpxConvertOptions>);
}
export declare namespace JpxConvertOptions {
}
/**
 * Tif convert options
 */
export declare class TifConvertOptions extends TiffConvertOptions {
    /**
     * Attribute type map
     */
    static attributeTypeMap: Array<{
        name: string;
        baseName: string;
        type: string;
    }>;
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap(): {
        name: string;
        baseName: string;
        type: string;
    }[];
    constructor(init?: Partial<TifConvertOptions>);
}
export declare namespace TifConvertOptions {
}
declare const enumsMap: {
    "FieldLabel.FieldEnum": typeof FieldLabel.FieldEnum;
    "OperationResult.MethodEnum": typeof OperationResult.MethodEnum;
    "OperationResult.StatusEnum": typeof OperationResult.StatusEnum;
    "CadLoadOptions.DrawTypeEnum": typeof CadLoadOptions.DrawTypeEnum;
    "EBookConvertOptions.PageSizeEnum": typeof EBookConvertOptions.PageSizeEnum;
    "EBookConvertOptions.PageOrientationEnum": typeof EBookConvertOptions.PageOrientationEnum;
    "ImageConvertOptions.FlipModeEnum": typeof ImageConvertOptions.FlipModeEnum;
    "PdfConvertOptions.PdfFormatEnum": typeof PdfConvertOptions.PdfFormatEnum;
    "PdfConvertOptions.DirectionEnum": typeof PdfConvertOptions.DirectionEnum;
    "PdfConvertOptions.NonFullScreenPageModeEnum": typeof PdfConvertOptions.NonFullScreenPageModeEnum;
    "PdfConvertOptions.PageLayoutEnum": typeof PdfConvertOptions.PageLayoutEnum;
    "PdfConvertOptions.PageModeEnum": typeof PdfConvertOptions.PageModeEnum;
    "PdfConvertOptions.RotateEnum": typeof PdfConvertOptions.RotateEnum;
    "PdfConvertOptions.PageSizeEnum": typeof PdfConvertOptions.PageSizeEnum;
    "PdfConvertOptions.PageOrientationEnum": typeof PdfConvertOptions.PageOrientationEnum;
    "TxtLoadOptions.TrailingSpacesOptionsEnum": typeof TxtLoadOptions.TrailingSpacesOptionsEnum;
    "TxtLoadOptions.LeadingSpacesOptionsEnum": typeof TxtLoadOptions.LeadingSpacesOptionsEnum;
    "WebLoadOptions.RenderingModeEnum": typeof WebLoadOptions.RenderingModeEnum;
    "WordProcessingConvertOptions.PdfRecognitionModeEnum": typeof WordProcessingConvertOptions.PdfRecognitionModeEnum;
    "WordProcessingConvertOptions.PageSizeEnum": typeof WordProcessingConvertOptions.PageSizeEnum;
    "WordProcessingConvertOptions.PageOrientationEnum": typeof WordProcessingConvertOptions.PageOrientationEnum;
    "PsdConvertOptions.ColorModeEnum": typeof PsdConvertOptions.ColorModeEnum;
    "PsdConvertOptions.CompressionMethodEnum": typeof PsdConvertOptions.CompressionMethodEnum;
    "TiffConvertOptions.CompressionEnum": typeof TiffConvertOptions.CompressionEnum;
};
declare const typeMap: {
    ApiError: typeof ApiError;
    ApiErrorResponse: typeof ApiErrorResponse;
    ConsumptionResult: typeof ConsumptionResult;
    ConvertOptions: typeof ConvertOptions;
    ConvertSettings: typeof ConvertSettings;
    DiscUsage: typeof DiscUsage;
    DocumentMetadata: typeof DocumentMetadata;
    ErrorDetails: typeof ErrorDetails;
    FieldLabel: typeof FieldLabel;
    FileVersions: typeof FileVersions;
    FilesList: typeof FilesList;
    FilesUploadResult: typeof FilesUploadResult;
    LicenseInfo: typeof LicenseInfo;
    LoadOptions: typeof LoadOptions;
    ModelError: typeof ModelError;
    ObjectExist: typeof ObjectExist;
    OperationResult: typeof OperationResult;
    StorageExist: typeof StorageExist;
    StorageFile: typeof StorageFile;
    StoredConvertedResult: typeof StoredConvertedResult;
    SupportedFormat: typeof SupportedFormat;
    WatermarkOptions: typeof WatermarkOptions;
    CadLoadOptions: typeof CadLoadOptions;
    DiagramLoadOptions: typeof DiagramLoadOptions;
    EBookConvertOptions: typeof EBookConvertOptions;
    EmailLoadOptions: typeof EmailLoadOptions;
    FileVersion: typeof FileVersion;
    ImageConvertOptions: typeof ImageConvertOptions;
    ImageLoadOptions: typeof ImageLoadOptions;
    OneLoadOptions: typeof OneLoadOptions;
    PDLConvertOptions: typeof PDLConvertOptions;
    PdfConvertOptions: typeof PdfConvertOptions;
    PdfLoadOptions: typeof PdfLoadOptions;
    PersonalStorageLoadOptions: typeof PersonalStorageLoadOptions;
    PresentationConvertOptions: typeof PresentationConvertOptions;
    PresentationLoadOptions: typeof PresentationLoadOptions;
    SpreadsheetConvertOptions: typeof SpreadsheetConvertOptions;
    SpreadsheetLoadOptions: typeof SpreadsheetLoadOptions;
    TxtConvertOptions: typeof TxtConvertOptions;
    TxtLoadOptions: typeof TxtLoadOptions;
    WebConvertOptions: typeof WebConvertOptions;
    WebLoadOptions: typeof WebLoadOptions;
    WordProcessingConvertOptions: typeof WordProcessingConvertOptions;
    WordProcessingLoadOptions: typeof WordProcessingLoadOptions;
    XmlLoadOptions: typeof XmlLoadOptions;
    BmpConvertOptions: typeof BmpConvertOptions;
    BmpLoadOptions: typeof BmpLoadOptions;
    Cf2LoadOptions: typeof Cf2LoadOptions;
    CsvLoadOptions: typeof CsvLoadOptions;
    DcmConvertOptions: typeof DcmConvertOptions;
    DcmLoadOptions: typeof DcmLoadOptions;
    DgnLoadOptions: typeof DgnLoadOptions;
    DjvuConvertOptions: typeof DjvuConvertOptions;
    DngConvertOptions: typeof DngConvertOptions;
    DngLoadOptions: typeof DngLoadOptions;
    DocConvertOptions: typeof DocConvertOptions;
    DocLoadOptions: typeof DocLoadOptions;
    DocmConvertOptions: typeof DocmConvertOptions;
    DocmLoadOptions: typeof DocmLoadOptions;
    DocxConvertOptions: typeof DocxConvertOptions;
    DocxLoadOptions: typeof DocxLoadOptions;
    DotConvertOptions: typeof DotConvertOptions;
    DotLoadOptions: typeof DotLoadOptions;
    DotmConvertOptions: typeof DotmConvertOptions;
    DotmLoadOptions: typeof DotmLoadOptions;
    DotxConvertOptions: typeof DotxConvertOptions;
    DotxLoadOptions: typeof DotxLoadOptions;
    DwfLoadOptions: typeof DwfLoadOptions;
    DwfxLoadOptions: typeof DwfxLoadOptions;
    DwgLoadOptions: typeof DwgLoadOptions;
    DwtLoadOptions: typeof DwtLoadOptions;
    DxfLoadOptions: typeof DxfLoadOptions;
    EmfConvertOptions: typeof EmfConvertOptions;
    EmfLoadOptions: typeof EmfLoadOptions;
    EmlLoadOptions: typeof EmlLoadOptions;
    EmlxLoadOptions: typeof EmlxLoadOptions;
    GifConvertOptions: typeof GifConvertOptions;
    GifLoadOptions: typeof GifLoadOptions;
    IcoConvertOptions: typeof IcoConvertOptions;
    IcoLoadOptions: typeof IcoLoadOptions;
    IfcLoadOptions: typeof IfcLoadOptions;
    IgsLoadOptions: typeof IgsLoadOptions;
    J2cLoadOptions: typeof J2cLoadOptions;
    J2kLoadOptions: typeof J2kLoadOptions;
    Jp2LoadOptions: typeof Jp2LoadOptions;
    JpegLoadOptions: typeof JpegLoadOptions;
    JpfLoadOptions: typeof JpfLoadOptions;
    JpgConvertOptions: typeof JpgConvertOptions;
    JpgLoadOptions: typeof JpgLoadOptions;
    JpmLoadOptions: typeof JpmLoadOptions;
    JpxLoadOptions: typeof JpxLoadOptions;
    MhtLoadOptions: typeof MhtLoadOptions;
    MobiLoadOptions: typeof MobiLoadOptions;
    MsgLoadOptions: typeof MsgLoadOptions;
    OdgConvertOptions: typeof OdgConvertOptions;
    OdgLoadOptions: typeof OdgLoadOptions;
    OdpConvertOptions: typeof OdpConvertOptions;
    OdpLoadOptions: typeof OdpLoadOptions;
    OdsConvertOptions: typeof OdsConvertOptions;
    OdsLoadOptions: typeof OdsLoadOptions;
    OdtConvertOptions: typeof OdtConvertOptions;
    OdtLoadOptions: typeof OdtLoadOptions;
    OstLoadOptions: typeof OstLoadOptions;
    OtpConvertOptions: typeof OtpConvertOptions;
    OtpLoadOptions: typeof OtpLoadOptions;
    OtsConvertOptions: typeof OtsConvertOptions;
    OtsLoadOptions: typeof OtsLoadOptions;
    OttConvertOptions: typeof OttConvertOptions;
    OttLoadOptions: typeof OttLoadOptions;
    PltLoadOptions: typeof PltLoadOptions;
    PngConvertOptions: typeof PngConvertOptions;
    PngLoadOptions: typeof PngLoadOptions;
    PotmConvertOptions: typeof PotmConvertOptions;
    PotmLoadOptions: typeof PotmLoadOptions;
    PotxConvertOptions: typeof PotxConvertOptions;
    PotxLoadOptions: typeof PotxLoadOptions;
    PpsConvertOptions: typeof PpsConvertOptions;
    PpsLoadOptions: typeof PpsLoadOptions;
    PpsmConvertOptions: typeof PpsmConvertOptions;
    PpsmLoadOptions: typeof PpsmLoadOptions;
    PpsxConvertOptions: typeof PpsxConvertOptions;
    PpsxLoadOptions: typeof PpsxLoadOptions;
    PptConvertOptions: typeof PptConvertOptions;
    PptLoadOptions: typeof PptLoadOptions;
    PptmConvertOptions: typeof PptmConvertOptions;
    PptmLoadOptions: typeof PptmLoadOptions;
    PptxConvertOptions: typeof PptxConvertOptions;
    PptxLoadOptions: typeof PptxLoadOptions;
    PsdConvertOptions: typeof PsdConvertOptions;
    PsdLoadOptions: typeof PsdLoadOptions;
    PstLoadOptions: typeof PstLoadOptions;
    RtfConvertOptions: typeof RtfConvertOptions;
    StlLoadOptions: typeof StlLoadOptions;
    TifLoadOptions: typeof TifLoadOptions;
    TiffConvertOptions: typeof TiffConvertOptions;
    TiffLoadOptions: typeof TiffLoadOptions;
    TsvConvertOptions: typeof TsvConvertOptions;
    TsvLoadOptions: typeof TsvLoadOptions;
    VdwLoadOptions: typeof VdwLoadOptions;
    VdxLoadOptions: typeof VdxLoadOptions;
    VsdLoadOptions: typeof VsdLoadOptions;
    VsdmLoadOptions: typeof VsdmLoadOptions;
    VsdxLoadOptions: typeof VsdxLoadOptions;
    VssLoadOptions: typeof VssLoadOptions;
    VssmLoadOptions: typeof VssmLoadOptions;
    VssxLoadOptions: typeof VssxLoadOptions;
    VstLoadOptions: typeof VstLoadOptions;
    VstmLoadOptions: typeof VstmLoadOptions;
    VstxLoadOptions: typeof VstxLoadOptions;
    VsxLoadOptions: typeof VsxLoadOptions;
    VtxLoadOptions: typeof VtxLoadOptions;
    WebpConvertOptions: typeof WebpConvertOptions;
    WebpLoadOptions: typeof WebpLoadOptions;
    WmfConvertOptions: typeof WmfConvertOptions;
    WmfLoadOptions: typeof WmfLoadOptions;
    Xls2003ConvertOptions: typeof Xls2003ConvertOptions;
    Xls2003LoadOptions: typeof Xls2003LoadOptions;
    XlsConvertOptions: typeof XlsConvertOptions;
    XlsLoadOptions: typeof XlsLoadOptions;
    XlsbConvertOptions: typeof XlsbConvertOptions;
    XlsbLoadOptions: typeof XlsbLoadOptions;
    XlsmConvertOptions: typeof XlsmConvertOptions;
    XlsmLoadOptions: typeof XlsmLoadOptions;
    XlsxConvertOptions: typeof XlsxConvertOptions;
    XlsxLoadOptions: typeof XlsxLoadOptions;
    XltmConvertOptions: typeof XltmConvertOptions;
    XltmLoadOptions: typeof XltmLoadOptions;
    XltxConvertOptions: typeof XltxConvertOptions;
    XltxLoadOptions: typeof XltxLoadOptions;
    J2cConvertOptions: typeof J2cConvertOptions;
    J2kConvertOptions: typeof J2kConvertOptions;
    Jp2ConvertOptions: typeof Jp2ConvertOptions;
    JpegConvertOptions: typeof JpegConvertOptions;
    JpfConvertOptions: typeof JpfConvertOptions;
    JpmConvertOptions: typeof JpmConvertOptions;
    JpxConvertOptions: typeof JpxConvertOptions;
    TifConvertOptions: typeof TifConvertOptions;
};
export { enumsMap, typeMap };
/**
 * Request model for GetOperationResult operation.
 */
export declare class GetOperationResultRequest {
    /**
     * Gets or sets id
     */
    id: string;
    constructor(id: string);
}
/**
 * Request model for GetOperationStatus operation.
 */
export declare class GetOperationStatusRequest {
    /**
     * Gets or sets id
     */
    id: string;
    constructor(id: string);
}
/**
 * Request model for StartConvert operation.
 */
export declare class StartConvertRequest {
    /**
     * Requested conversion format
     */
    format: string;
    /**
     * Input file to convert
     */
    file: Buffer;
    /**
     * Page start conversion from
     */
    fromPage: number;
    /**
     * Number of pages to convert
     */
    pagesCount: number;
    constructor(format: string, file: Buffer, fromPage?: number, pagesCount?: number);
}
/**
 * Request model for StartConvertAndSave operation.
 */
export declare class StartConvertAndSaveRequest {
    /**
     * Conversion settings
     */
    convertSettings: ConvertSettings;
    constructor(convertSettings: ConvertSettings);
}
/**
 * Request model for ConvertDocument operation.
 */
export declare class ConvertDocumentRequest {
    /**
     * Gets or sets convertSettings
     */
    convertSettings: ConvertSettings;
    constructor(convertSettings: ConvertSettings);
}
/**
 * Request model for ConvertDocumentDirect operation.
 */
export declare class ConvertDocumentDirectRequest {
    /**
     * Requested conversion format
     */
    format: string;
    /**
     * Input file to convert
     */
    file: Buffer;
    /**
     * Page start conversion from
     */
    fromPage: number;
    /**
     * Number of pages to convert
     */
    pagesCount: number;
    /**
     * Input file load options
     */
    loadOptions: LoadOptions;
    /**
     * Conversion options
     */
    convertOptions: ConvertOptions;
    constructor(format: string, file: Buffer, fromPage?: number, pagesCount?: number, loadOptions?: LoadOptions, convertOptions?: ConvertOptions);
}
/**
 * Request model for CopyFile operation.
 */
export declare class CopyFileRequest {
    /**
     * Source file path e.g. '/folder/file.ext'
     */
    srcPath: string;
    /**
     * Destination file path
     */
    destPath: string;
    /**
     * Source storage name
     */
    srcStorageName: string;
    /**
     * Destination storage name
     */
    destStorageName: string;
    /**
     * File version ID to copy
     */
    versionId: string;
    constructor(srcPath: string, destPath: string, srcStorageName?: string, destStorageName?: string, versionId?: string);
}
/**
 * Request model for DeleteFile operation.
 */
export declare class DeleteFileRequest {
    /**
     * File path e.g. '/folder/file.ext'
     */
    path: string;
    /**
     * Storage name
     */
    storageName: string;
    /**
     * File version ID to delete
     */
    versionId: string;
    constructor(path: string, storageName?: string, versionId?: string);
}
/**
 * Request model for DownloadFile operation.
 */
export declare class DownloadFileRequest {
    /**
     * File path e.g. '/folder/file.ext'
     */
    path: string;
    /**
     * Storage name
     */
    storageName: string;
    /**
     * File version ID to download
     */
    versionId: string;
    constructor(path: string, storageName?: string, versionId?: string);
}
/**
 * Request model for MoveFile operation.
 */
export declare class MoveFileRequest {
    /**
     * Source file path e.g. '/src.ext'
     */
    srcPath: string;
    /**
     * Destination file path e.g. '/dest.ext'
     */
    destPath: string;
    /**
     * Source storage name
     */
    srcStorageName: string;
    /**
     * Destination storage name
     */
    destStorageName: string;
    /**
     * File version ID to move
     */
    versionId: string;
    constructor(srcPath: string, destPath: string, srcStorageName?: string, destStorageName?: string, versionId?: string);
}
/**
 * Request model for UploadFile operation.
 */
export declare class UploadFileRequest {
    /**
     * Path where to upload including filename and extension e.g. /file.ext or /Folder 1/file.ext             If the content is multipart and path does not contains the file name it tries to get them from filename parameter             from Content-Disposition header.
     */
    path: string;
    /**
     * File to upload
     */
    file: Buffer;
    /**
     * Storage name
     */
    storageName: string;
    constructor(path: string, file: Buffer, storageName?: string);
}
/**
 * Request model for CopyFolder operation.
 */
export declare class CopyFolderRequest {
    /**
     * Source folder path e.g. '/src'
     */
    srcPath: string;
    /**
     * Destination folder path e.g. '/dst'
     */
    destPath: string;
    /**
     * Source storage name
     */
    srcStorageName: string;
    /**
     * Destination storage name
     */
    destStorageName: string;
    constructor(srcPath: string, destPath: string, srcStorageName?: string, destStorageName?: string);
}
/**
 * Request model for CreateFolder operation.
 */
export declare class CreateFolderRequest {
    /**
     * Folder path to create e.g. 'folder_1/folder_2/'
     */
    path: string;
    /**
     * Storage name
     */
    storageName: string;
    constructor(path: string, storageName?: string);
}
/**
 * Request model for DeleteFolder operation.
 */
export declare class DeleteFolderRequest {
    /**
     * Folder path e.g. '/folder'
     */
    path: string;
    /**
     * Storage name
     */
    storageName: string;
    /**
     * Enable to delete folders, subfolders and files
     */
    recursive: boolean;
    constructor(path: string, storageName?: string, recursive?: boolean);
}
/**
 * Request model for GetFilesList operation.
 */
export declare class GetFilesListRequest {
    /**
     * Folder path e.g. '/folder'
     */
    path: string;
    /**
     * Storage name
     */
    storageName: string;
    constructor(path: string, storageName?: string);
}
/**
 * Request model for MoveFolder operation.
 */
export declare class MoveFolderRequest {
    /**
     * Folder path to move e.g. '/folder'
     */
    srcPath: string;
    /**
     * Destination folder path to move to e.g '/dst'
     */
    destPath: string;
    /**
     * Source storage name
     */
    srcStorageName: string;
    /**
     * Destination storage name
     */
    destStorageName: string;
    constructor(srcPath: string, destPath: string, srcStorageName?: string, destStorageName?: string);
}
/**
 * Request model for GetDocumentMetadata operation.
 */
export declare class GetDocumentMetadataRequest {
    /**
     * Absolute path to a document in the storage
     */
    filePath: string;
    /**
     * StorageName which contains the document
     */
    storageName: string;
    constructor(filePath?: string, storageName?: string);
}
/**
 * Request model for GetSupportedConversionTypes operation.
 */
export declare class GetSupportedConversionTypesRequest {
    /**
     * Absolute path to a document in the storage
     */
    filePath: string;
    /**
     * StorageName which contains the document
     */
    storageName: string;
    /**
     * If provided only supported conversions for specified format will be returned
     */
    format: string;
    constructor(filePath?: string, storageName?: string, format?: string);
}
/**
 * Request model for GetDiscUsage operation.
 */
export declare class GetDiscUsageRequest {
    /**
     * Storage name
     */
    storageName: string;
    constructor(storageName?: string);
}
/**
 * Request model for GetFileVersions operation.
 */
export declare class GetFileVersionsRequest {
    /**
     * File path e.g. '/file.ext'
     */
    path: string;
    /**
     * Storage name
     */
    storageName: string;
    constructor(path: string, storageName?: string);
}
/**
 * Request model for ObjectExists operation.
 */
export declare class ObjectExistsRequest {
    /**
     * File or folder path e.g. '/file.ext' or '/folder'
     */
    path: string;
    /**
     * Storage name
     */
    storageName: string;
    /**
     * File version ID
     */
    versionId: string;
    constructor(path: string, storageName?: string, versionId?: string);
}
/**
 * Request model for StorageExists operation.
 */
export declare class StorageExistsRequest {
    /**
     * Storage name
     */
    storageName: string;
    constructor(storageName: string);
}