export declare enum Align {
    left = "left",
    right = "right",
    center = "center",
    bottom = "bottom",
    top = "top",
    faces = "faces",
    middle = "middle"
}
/**
 * Align
 */
export type AlignOptions = Align | [Align.top | Align.middle | Align.bottom, Align.left | Align.center | Align.right];
/**
 * Fit enum
 */
export declare enum FitOptions {
    clip = "clip",
    crop = "crop",
    scale = "scale",
    max = "max"
}
/**
 * Blur enum
 */
export declare enum BlurMode {
    linear = "linear",
    gaussian = "gaussian"
}
/**
 * Shapes enum
 */
export declare enum ShapeType {
    oval = "oval",
    rect = "rect"
}
/**
 * Noise type enum
 */
export declare enum NoiseType {
    none = "none",
    low = "low",
    medium = "medium",
    high = "high"
}
/**
 * Style type enum
 */
export declare enum StyleType {
    artwork = "artwork",
    photo = "photo"
}
/**
 * Color space enum
 */
export declare enum ColorspaceType {
    RGB = "RGB",
    CMYK = "CMYK",
    Input = "Input"
}
/**
 * Crop faces options enum
 */
export declare enum CropfacesType {
    thumb = "thumb",
    crop = "crop",
    fill = "fill"
}
/**
 * Watermark postion options enum
 */
export declare enum ImageWatermarkPosition {
    top = "top",
    middle = "middle",
    bottom = "bottom",
    left = "left",
    center = "center",
    right = "right"
}
/**
 * SmartCrop options enum
 */
export declare enum SmartCropMode {
    face = "face",
    auto = "auto"
}
/**
 * Convert to format
 */
export declare enum AudioTypes {
    libmp3lame = "libmp3lame",
    libvorbis = "libvorbis",
    libfdk_aac = "libfdk_aac",
    dib_ac3 = "dib_ac3",
    pcm_s16le = "pcm_s16le",
    mp2 = "mp2",
    ac3 = "ac3",
    eac3 = "eac3"
}
/**
 * Convert to format
 */
export declare enum VideoTypes {
    h264 = "h264",
    h264_hi = "h264.hi",
    webm = "webm",
    'webm-hi' = "webm.hi",
    ogg = "ogg",
    'ogg-hi' = "ogg.hi",
    'hls-variant' = "hls.variant",
    mp3 = "mp3",
    oga = "oga",
    m4a = "m4a",
    aac = "aac",
    hls = "hls.variant.audio"
}
export declare enum URLScreenshotAgent {
    desktop = "desktop",
    mobile = "mobile"
}
export declare enum URLScreenshotMode {
    all = "all",
    window = "window"
}
export declare enum URLScreenshotOrientation {
    portrait = "portrait",
    landscape = "landscape"
}
/**
 * Video storage location
 */
export declare enum Locations {
    s3 = "s3",
    azure = "azure",
    gcs = "gcs",
    rackspace = "rackspace",
    dropbox = "dropbox"
}
export declare enum VideoAccess {
    private = "private",
    public = "public"
}
export declare enum VideoAccessMode {
    preserve = "preserve",
    constrain = "constrain",
    letterbox = "letterbox",
    pad = "pad",
    crop = "crop"
}
export interface StoreBaseParams {
    location?: string;
    path?: string;
    container?: string;
    region?: string;
    access?: string;
    disableStorageKey?: boolean;
}
/**
 * Available options for store transformations
 *
 * @export
 * @interface StoreParams
 */
export type StoreParams = StoreBaseParams & {
    filename?: string;
    base64decode?: boolean;
};
export interface AnimationParams {
    delay?: number;
    loop?: number;
    width?: number;
    height?: number;
    fit?: FitOptions;
    align?: AlignOptions;
    background?: string;
}
export interface ResizeParams {
    width?: number;
    height?: number;
    fit?: FitOptions;
    align?: AlignOptions;
}
export interface CropParams {
    dim: [number, number, number, number];
}
export interface RotateParams {
    deg: number | string;
    color?: string;
    background?: string;
}
export interface DetectFacesParams {
    minsize?: number;
    maxsize?: number;
    color?: string;
    export?: boolean;
}
export interface CropFacesParams {
    mode?: CropfacesType;
    width?: number;
    height?: number;
    faces?: number | string;
    buffer?: number;
}
export interface PixelateFacesParams {
    faces?: number | string;
    minsize?: number;
    maxsize?: number;
    buffer?: number;
    amount?: number;
    blur?: number;
    type?: ShapeType;
}
export interface BlurFacesParams {
    faces?: number | string;
    minsize?: number;
    maxsize?: number;
    buffer?: number;
    amount?: number;
    blur?: number;
    type?: ShapeType;
}
export interface RoundedCornersParams {
    radius?: number;
    blur?: number;
    background?: string;
}
export interface VignetteParams {
    amount?: number;
    blurmode?: BlurMode;
    background?: string;
}
export interface PolaroidParams {
    color?: string;
    rotate?: number;
    background?: string;
}
export interface TornEdgesParams {
    spread?: [number, number];
    background?: string;
}
export interface ShadowParams {
    blur?: number;
    opacity?: number;
    vector?: [number, number];
    color?: string;
    background?: string;
}
export interface CircleParams {
    background?: string;
}
export interface BorderParams {
    width?: number;
    color?: string;
    background?: string;
}
export interface CompressParams {
    metadata?: boolean;
}
export interface WatermarkParams {
    file: string;
    size?: number;
    position?: ImageWatermarkPosition | ImageWatermarkPosition[];
}
export interface ProgressiveJpgParams {
    quality: number;
    metadata: boolean;
}
export interface SmartCropParams {
    mode: SmartCropMode;
    width: number;
    height: number;
}
export interface SharpenParams {
    amount: number;
}
export interface BlurParams {
    amount: number;
}
export interface BlackwhiteParams {
    threshold: number;
}
export interface SepiaParams {
    tone: number;
}
export interface PixelateParams {
    amount: number;
}
export interface OilPaintParams {
    amount: number;
}
export interface ModulateParams {
    brightness?: number;
    hue?: number;
    saturation?: number;
}
export interface PartialPixelateParams {
    amount?: number;
    blur?: number;
    type?: ShapeType;
    objects?: [[number, number, number, number]];
}
export interface PartialBlurParams {
    amount: number;
    blur?: number;
    type?: ShapeType;
    objects?: [[number, number, number, number]];
}
export interface CollageParams {
    margin?: number;
    width?: number;
    height?: number;
    color?: string;
    fit?: FitOptions;
    files: [string];
}
export interface UpscaleParams {
    upscale?: boolean;
    noise?: NoiseType;
    style?: StyleType;
}
export interface AsciiParams {
    background?: string;
    foreground?: string;
    colored?: boolean;
    size?: number;
    reverse?: boolean;
}
export interface QualityParams {
    value: number;
}
export interface SecurityParams {
    policy: string;
    signature?: string;
}
export interface OutputParams {
    format: string;
    colorspace?: string;
    strip?: boolean;
    quality?: number;
    page?: number;
    compress?: boolean;
    density?: number;
    background?: string;
    secure?: boolean;
    docinfo?: boolean;
    pageformat?: string;
    pageorientation?: string;
}
export interface CacheParams {
    cache?: boolean;
    expiry: number;
}
export interface VideoConvertParams {
    aspect_mode: VideoAccessMode;
    preset?: VideoTypes;
    force?: boolean;
    title?: string;
    extname?: string;
    filename?: string;
    location?: Locations;
    path?: string;
    access?: VideoAccess;
    container?: string;
    audio_bitrate?: number;
    audio_codec?: AudioTypes;
    upscale: boolean;
    video_bitrate?: number;
    audio_sample_rate?: number;
    audio_channels?: number;
    clip_length?: string;
    clip_offset?: string;
    width?: number;
    height?: number;
    two_pass?: boolean;
    fps?: number;
    keyframe_interval?: number;
    watermark_url?: string;
    watermark_top?: number;
    watermark_bottom?: number;
    watermark_right?: number;
    watermark_left?: number;
    watermark_width?: number;
    watermark_height?: number;
}
export interface URLScreenshotParams {
    agent?: URLScreenshotAgent;
    width?: number;
    height?: number;
    mode?: URLScreenshotMode;
    delay?: number;
    orientation?: URLScreenshotOrientation;
    device?: string;
}
export declare enum EnhancePreset {
    auto = "auto",
    vivid = "vivid",
    beautify = "beautify",
    beautifyPlus = "beautify_plus",
    fixDark = "fix_dark",
    fixNoise = "fix_noise",
    fixTint = "fix_tint",
    outdor = "outdoor",
    fireworks = "fireworks"
}
export interface EnhanceParams {
    preset?: EnhancePreset;
}
export interface PdfInfoParams {
    colorinfo?: boolean;
}
export interface PdfConvertParams {
    pageorientation?: string;
    pageformat?: string;
    pages?: (string | number)[];
}
export interface FallbackParams {
    handle: string;
    cache?: number;
}
export interface MinifyCssParams {
    gzip?: boolean;
    level?: number;
}
export interface MinifyJsParams {
    gzip?: boolean;
    use_babel_polyfill?: boolean;
    keep_fn_name?: boolean;
    keep_class_name?: boolean;
    mangle?: boolean;
    merge_vars?: boolean;
    remove_console?: boolean;
    remove_undefined?: boolean;
    targets?: null | string;
}
/**
 * Class for handling filelinks. For now its supports all filestack transforms.
 * It outputs transform url or array of transforms
 * @example
 * const link = new Filelink('handle or externalUrl', 'apikey');
 * link.flip().flop().store();
 *
 * console.log(link.toString());
 * // enable base64 support
 * link.setBase64(true)
 *
 * console.log(link.toString());
 *
 * @export
 * @class Filelink
 */
export declare class Filelink {
    /**
     * Validator instance
     *
     * @private
     * @memberof Filelink
     */
    private static validator;
    /**
     * Applied transforms array
     *
     * @private
     * @memberof Filelink
     */
    private transforms;
    /**
     * Handle or multiple handles in array
     *
     * @private
     * @memberof Filelink
     */
    private source;
    /**
     * Application key
     *
     * @private
     * @type {string}
     * @memberof Filelink
     */
    private apikey;
    /**
     * Is base64 support is enabled
     *
     * @private
     * @type {boolean}
     * @memberof Filelink
     */
    private b64;
    /**
     * should use a validator to check params of every task
     * @private
     * @type {boolean}
     * @memberof Filelink
     */
    private useValidator;
    /**
     * Custom CNAME
     *
     * @private
     * @type {string}
     * @memberof Filelink
     */
    private cname;
    /**
     * Overwrite domain (test purposes)
     *
     * @private
     * @type {string}
     * @memberof Filelink
     */
    private customDomain;
    /**
     * Class for generating tranformation urls
     * @param {(string | string[])} source - handle or multiple handles (i.e. for collage)
     * @param {string} [apikey] - your apikey - required for all external sources
     *
     * @memberof Filelink
     */
    constructor(source: string | string[], apikey?: string);
    /**
     * Enable new base64 link support to avoid problems with special chars in link
     *
     * @param {boolean} flag
     * @returns
     * @memberof Filelink
     */
    setBase64(flag: boolean): this;
    /**
     * Switch the useValidator flag
     *
     * @param {boolean} flag
     * @returns
     * @memberof Filelink
     */
    setUseValidator(flag: boolean): this;
    /**
     * Set cname for transformation link
     *
     * @param {string} cname
     * @returns
     * @memberof Filelink
     */
    setCname(cname: string): this;
    /**
     * Set custom domain. Used for test purpose. It will be removed when after client.transform
     *
     * @param {string} domain
     * @returns
     * @memberof Filelink
     */
    setCustomDomain(domain: string): this;
    setSource(source: string | string[]): void;
    /**
     * Returns JSONSchema form transformations params
     *
     * @returns
     * @memberof Filelink
     */
    getValidationSchema(): {
        $schema: string;
        title: string;
        description: string;
        type: string;
        additionalProperties: boolean;
        properties: {
            flip: {
                type: string;
                additionalProperties: boolean;
            };
            auto_image: {
                type: string;
                additionalProperties: boolean;
            };
            no_metadata: {
                type: string;
                additionalProperties: boolean;
            };
            compress: {
                additionalProperties: boolean;
                oneOf: ({
                    type: string;
                    properties?: undefined;
                } | {
                    type: string;
                    properties: {
                        metadata: {
                            type: string;
                            default: boolean;
                        };
                    };
                })[];
            };
            flop: {
                type: string;
                additionalProperties: boolean;
            };
            enhance: {
                default: boolean;
                oneOf: ({
                    type: string;
                    additionalProperties?: undefined;
                    properties?: undefined;
                } | {
                    type: string;
                    additionalProperties: boolean;
                    properties: {
                        preset: {
                            type: string;
                            enum: string[];
                        };
                    };
                })[];
            };
            redeye: {
                type: string;
                additionalProperties: boolean;
            };
            monochrome: {
                type: string;
                additionalProperties: boolean; /**
                 * Watermark postion options enum
                 */
            };
            negative: {
                type: string;
                additionalProperties: boolean;
            };
            tags: {
                type: string;
                additionalProperties: boolean;
            };
            sfw: {
                type: string;
                additionalProperties: boolean;
            };
            imagesize: {
                type: string;
                additionalProperties: boolean;
            };
            smart_crop: {
                width: {
                    type: string;
                    minimum: number;
                    maximum: number;
                };
                height: {
                    type: string;
                    minimum: number;
                    maximum: number;
                };
                mode: {
                    type: string;
                    default: string;
                    enum: string[];
                };
            };
            animate: {
                type: string;
                properties: {
                    delay: {
                        type: string;
                        minimum: number;
                        maximum: number;
                        default: number;
                    };
                    loop: {
                        type: string;
                        minimum: number;
                        maximum: number;
                        default: number;
                    };
                    width: {
                        type: string;
                        minimum: number;
                        maximum: number;
                    };
                    height: {
                        type: string;
                        minimum: number;
                        maximum: number;
                    };
                    fit: {
                        type: string;
                        default: string;
                        enum: string[];
                    };
                    background: {
                        $ref: string;
                        default: string;
                    };
                    align: {
                        $ref: string;
                        default: string;
                    };
                };
            };
            metadata: {
                type: string;
                params: {
                    type: string;
                    items: {
                        type: string;
                        enum: string[];
                    };
                    minItems: number;
                    uniqueItems: boolean;
                    additionalItems: boolean;
                };
                additionalProperties: boolean;
            };
            resize: {
                type: string;
                properties: {
                    width: {
                        type: string;
                        minimum: number;
                        maximum: number;
                    };
                    height: {
                        type: string;
                        minimum: number;
                        maximum: number;
                    };
                    fit: {
                        type: string;
                        enum: string[];
                        default: string;
                    };
                    align: {
                        $ref: string;
                        default: string;
                    };
                };
                additionalProperties: boolean;
                anyOf: {
                    required: string[];
                }[];
            };
            crop: {
                type: string;
                properties: {
                    dim: {
                        type: string;
                        additionalItems: boolean;
                        minItems: number;
                        items: {
                            type: string;
                            minimum: number;
                            maximum: number;
                        }[];
                    };
                };
                required: string[];
            };
            rotate: {
                type: string;
                properties: {
                    deg: {
                        oneOf: ({
                            type: string;
                            enum: string[];
                            minimum?: undefined;
                            maximum?: undefined;
                        } | {
                            type: string;
                            minimum: number;
                            maximum: number;
                            enum?: undefined;
                        })[];
                    };
                    exif: {
                        type: string;
                    };
                    background: {
                        $ref: string;
                        default: string;
                    };
                };
                additionalProperties: boolean;
            };
            detect_faces: {
                oneOf: ({
                    type: string;
                    properties?: undefined;
                    additionalProperties?: undefined;
                } | {
                    type: string;
                    properties: {
                        maxsize: {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                        };
                        minsize: {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                        };
                        export: {
                            type: string;
                        };
                        color: {
                            $ref: string;
                            default: string;
                        };
                    };
                    additionalProperties: boolean;
                })[];
            };
            crop_faces: {
                oneOf: ({
                    type: string;
                    properties?: undefined;
                    additionalProperties?: undefined;
                } | {
                    type: string;
                    properties: {
                        faces: {
                            default: number;
                            $ref: string;
                        };
                        width: {
                            type: string;
                            minimum: number;
                            maximum: number;
                        };
                        height: {
                            type: string;
                            minimum: number;
                            maximum: number;
                        };
                        maxsize: {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                        };
                        minsize: {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                        };
                        buffer: {
                            type: string;
                            minimum: number;
                            maximum: number;
                        };
                        mode: {
                            type: string;
                            enum: string[];
                            default: string;
                        };
                    };
                    additionalProperties: boolean;
                })[];
            };
            pixelate_faces: {
                oneOf: ({
                    type: string;
                    properties?: undefined;
                    additionalProperties?: undefined;
                } | {
                    type: string;
                    properties: {
                        faces: {
                            $ref: string;
                            default: string;
                        };
                        maxsize: {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                        };
                        minsize: {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                        };
                        buffer: {
                            type: string;
                            minimum: number;
                            maximum: number;
                        };
                        amount: {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                        };
                        blur: {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                        };
                        type: {
                            type: string;
                            enum: string[];
                            default: string;
                        };
                    };
                    additionalProperties: boolean;
                })[];
            };
            blur_faces: {
                oneOf: ({
                    type: string;
                    properties?: undefined;
                    additionalProperties?: undefined;
                } | {
                    type: string;
                    properties: {
                        faces: {
                            $ref: string;
                            default: string;
                        };
                        maxsize: {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                        };
                        minsize: {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                        };
                        buffer: {
                            type: string;
                            minimum: number;
                            maximum: number;
                        };
                        amount: {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                        };
                        blur: {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                        };
                        type: {
                            type: string;
                            enum: string[];
                            default: string;
                        };
                    };
                    additionalProperties: boolean;
                })[];
            };
            rounded_corners: {
                oneOf: ({
                    type: string;
                    properties?: undefined;
                    additionalProperties?: undefined;
                } | {
                    type: string;
                    properties: {
                        radius: {
                            oneOf: ({
                                type: string;
                                minimum: number;
                                maximum: number;
                                enum?: undefined;
                            } | {
                                type: string;
                                enum: string[];
                                minimum?: undefined;
                                maximum?: undefined;
                            })[];
                        };
                        blur: {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                        };
                        background: {
                            $ref: string;
                        };
                    };
                    additionalProperties: boolean;
                })[];
            };
            vignette: {
                oneOf: ({
                    type: string;
                    properties?: undefined;
                    additionalProperties?: undefined;
                } | {
                    type: string;
                    properties: {
                        amount: {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                        };
                        blurmode: {
                            type: string;
                            enum: string[];
                            default: string;
                        };
                        background: {
                            $ref: string;
                        };
                    };
                    additionalProperties: boolean;
                })[];
            };
            polaroid: {
                oneOf: ({
                    type: string;
                    properties?: undefined;
                    additionalProperties?: undefined;
                } | {
                    type: string;
                    properties: {
                        /**
                         * Overwrite domain (test purposes)
                         *
                         * @private
                         * @type {string}
                         * @memberof Filelink
                         */
                        rotate: {
                            type: string;
                            minimum: number;
                            maximum: number;
                        };
                        color: {
                            $ref: string;
                            default: string;
                        };
                        background: {
                            $ref: string;
                        };
                    };
                    additionalProperties: boolean;
                })[];
            };
            torn_edges: {
                oneOf: ({
                    type: string;
                    properties?: undefined;
                    additionalProperties?: undefined;
                } | {
                    type: string;
                    properties: {
                        spread: {
                            type: string;
                            additionalItems: boolean;
                            minItems: number;
                            items: {
                                type: string;
                                minimum: number;
                                maximum: number;
                                default: number;
                            }[];
                        };
                        background: {
                            $ref: string;
                        };
                    };
                    additionalProperties: boolean;
                })[];
            };
            shadow: {
                oneOf: ({
                    type: string;
                    properties?: undefined;
                    additionalProperties?: undefined;
                } | {
                    type: string;
                    properties: {
                        blur: {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                        };
                        opacity: {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                        };
                        vector: {
                            type: string;
                            additionalItems: boolean;
                            minItems: number;
                            items: {
                                type: string;
                                minimum: number;
                                maximum: number;
                                default: number;
                            }[];
                        };
                        color: {
                            $ref: string;
                        };
                        background: {
                            $ref: string;
                        };
                    };
                    additionalProperties: boolean;
                })[];
            };
            circle: {
                oneOf: ({
                    type: string;
                    properties?: undefined;
                    additionalProperties?: undefined;
                } | {
                    type: string;
                    properties: {
                        background: {
                            $ref: string;
                        };
                    };
                    additionalProperties: boolean;
                })[];
            };
            border: {
                oneOf: ({
                    type: string;
                    properties?: undefined;
                    additionalProperties?: undefined;
                } | {
                    type: string;
                    properties: {
                        color: {
                            $ref: string;
                        };
                        background: {
                            $ref: string;
                        };
                        width: {
                            type: string;
                            minimum: number;
                            maximum: number;
                        };
                    };
                    additionalProperties: boolean;
                })[];
            };
            sharpen: {
                oneOf: ({
                    type: string;
                    properties?: undefined;
                    additionalProperties?: undefined;
                } | {
                    type: string;
                    properties: {
                        amount: {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                        };
                    };
                    additionalProperties: boolean;
                })[];
            };
            blur: {
                oneOf: ({
                    type: string;
                    properties?: undefined;
                    additionalProperties?: undefined;
                } | {
                    type: string;
                    properties: {
                        amount: {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                        };
                    };
                    additionalProperties: boolean;
                })[];
            };
            blackwhite: {
                oneOf: ({
                    type: string;
                    properties?: undefined;
                    additionalProperties?: undefined;
                } | {
                    type: string;
                    properties: {
                        threshold: {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                        };
                    };
                    additionalProperties: boolean;
                })[];
            };
            sepia: {
                oneOf: ({
                    type: string;
                    properties?: undefined;
                    additionalProperties?: undefined;
                } | {
                    type: string;
                    properties: {
                        tone: {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                        };
                    };
                    additionalProperties: boolean;
                })[];
            };
            pixelate: {
                oneOf: ({
                    type: string;
                    properties?: undefined;
                    additionalProperties?: undefined;
                } | {
                    type: string;
                    properties: {
                        amount: {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                        };
                    };
                    additionalProperties: boolean;
                })[];
            };
            oil_paint: {
                oneOf: ({
                    type: string;
                    properties?: undefined;
                    additionalProperties?: undefined;
                } | {
                    type: string;
                    properties: {
                        amount: {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                        };
                    };
                    additionalProperties: boolean;
                })[];
            };
            modulate: {
                oneOf: ({
                    type: string;
                    properties?: undefined;
                    additionalProperties?: undefined;
                } | {
                    type: string;
                    properties: {
                        brightness: {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                        };
                        saturation: {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                        };
                        hue: {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                        };
                    };
                    additionalProperties: boolean;
                })[];
            };
            ascii: {
                oneOf: ({
                    type: string;
                    properties?: undefined;
                    additionalProperties?: undefined;
                } | {
                    type: string;
                    properties: {
                        foreground: {
                            $ref: string;
                            default: string;
                        };
                        /**
                         * Adds Progressive JPEG transformation
                         *
                         * @see https://www.filestack.com/docs/api/processing/#progressive-jpeg
                         * @returns this
                         * @memberof Filelink
                         */
                        background: {
                            $ref: string;
                            default: string;
                        };
                        colored: {
                            type: string;
                            default: boolean;
                        };
                        size: {
                            type: string;
                            minimum: number; /**
                             * Adds imagesize transformation
                             *
                             * @see https://www.filestack.com/docs/api/processing/#smart-crop
                             * @returns this
                             * @memberof Filelink
                             */
                            maximum: number;
                            default: number;
                        };
                        reverse: {
                            type: string;
                            default: boolean;
                        };
                    };
                    additionalProperties: boolean;
                })[];
            };
            collage: {
                type: string;
                properties: {
                    files: {
                        type: string;
                        minItems: number;
                        items: {
                            type: string;
                        }[];
                    };
                    margin: {
                        type: string;
                        minimum: number;
                        maximum: number;
                        default: number;
                    };
                    width: {
                        type: string;
                        minimum: number;
                        maximum: number;
                    };
                    height: {
                        type: string;
                        minimum: number;
                        maximum: number;
                    };
                    color: {
                        $ref: string;
                        default: string;
                    };
                    fit: {
                        type: string;
                        enum: string[];
                    };
                    autorotate: {
                        type: string;
                        default: boolean;
                    };
                };
                required: string[];
                additionalProperties: boolean;
            };
            urlscreenshot: {
                oneOf: ({
                    type: string;
                    properties?: undefined;
                    additionalProperties?: undefined;
                } | {
                    type: string;
                    properties: {
                        agent: {
                            type: string;
                            enum: string[];
                            default: string;
                        };
                        width: {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                        };
                        height: {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                        };
                        mode: {
                            type: string;
                            enum: string[];
                            default: string;
                        };
                        delay: {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                        };
                        orientation: {
                            type: string;
                            enum: string[];
                            default: string;
                        };
                        device: {
                            type: string;
                            default: string;
                        };
                    };
                    additionalProperties: boolean;
                })[];
            };
            upscale: {
                oneOf: ({
                    type: string;
                    properties?: undefined;
                    additionalProperties?: undefined;
                } | {
                    type: string;
                    properties: {
                        noise: {
                            type: string;
                            enum: string[];
                            default: string;
                        };
                        upscale: {
                            type: string;
                            default: boolean;
                        };
                        style: {
                            type: string;
                            enum: string[];
                            default: string;
                        };
                    };
                    additionalProperties: boolean;
                })[];
            };
            output: {
                type: string;
                additionalProperties: boolean;
                properties: {
                    format: {
                        type: string;
                        enum: string[];
                    };
                    page: {
                        type: string;
                        minimum: number;
                        maximum: number;
                    };
                    density: {
                        type: string;
                        minimum: number;
                        maximum: number;
                    };
                    compress: {
                        type: string;
                    };
                    quality: {
                        oneOf: ({
                            type: string;
                            enum: string[];
                            minimum?: undefined;
                            maximum?: undefined;
                            default?: undefined;
                        } | {
                            type: string;
                            minimum: number;
                            maximum: number;
                            default: number;
                            enum?: undefined;
                        })[];
                    };
                    secure: {
                        type: string;
                        default: boolean;
                    };
                    docinfo: {
                        type: string;
                        default: boolean;
                    };
                    strip: {
                        type: string;
                        default: boolean;
                    };
                    colorspace: {
                        type: string;
                        enum: string[];
                        default: string;
                    };
                    background: {
                        $ref: string;
                    };
                    pageformat: {
                        type: string;
                        enum: string[];
                    };
                    pageorientation: {
                        type: string;
                        enum: string[];
                    };
                };
            };
            pjpg: {
                oneOf: ({
                    type: string;
                    additionalProperties?: undefined;
                    properties?: undefined;
                } | {
                    type: string;
                    additionalProperties: boolean;
                    properties: {
                        quality: {
                            type: string;
                            minimum: number;
                            maximum: number;
                        };
                        metadata: {
                            type: string;
                            default: boolean;
                        };
                    };
                })[];
            };
            quality: {
                type: string;
                additionalProperties: boolean;
                properties: {
                    value: {
                        type: string;
                        minimum: number;
                        maximum: number;
                    };
                };
            };
            cache: {
                oneOf: ({
                    type: string;
                    properties?: undefined;
                } | {
                    type: string;
                    properties: {
                        expiry: {
                            type: string;
                        };
                    };
                })[];
            };
            video_convert: {
                type: string;
                additionalProperties: boolean;
                properties: {
                    width: {
                        type: string;
                        minimum: number;
                        maximum: number;
                    };
                    height: {
                        type: string;
                        minimum: number;
                        maximum: number;
                    };
                    preset: {
                        type: string;
                    };
                    force: {
                        type: string;
                    };
                    title: {
                        type: string;
                    };
                    extname: {
                        type: string;
                    };
                    upscale: {
                        type: string;
                    };
                    aspect_mode: {
                        type: string;
                        enum: string[];
                        default: string;
                    };
                    audio_sample_rate: {
                        type: string;
                        minimum: number;
                        maximum: number;
                    };
                    two_pass: {
                        type: string;
                    };
                    video_bitrate: {
                        type: string;
                        minimum: number;
                        maximum: number;
                    };
                    fps: {
                        type: string;
                        minimum: number;
                        maximum: number;
                    };
                    keyframe_interval: {
                        type: string;
                        minimum: number;
                        maximum: number;
                    };
                    audio_bitrate: {
                        type: string;
                        minimum: number;
                        maximum: number;
                    };
                    audio_codec: {
                        type: string;
                    };
                    audio_channels: {
                        type: string;
                        minimum: number;
                        maximum: number; /**
                         * Adds circle transformation
                         *
                         * @see https://www.filestack.com/docs/api/processing/#circle
                         * @param {(CircleParams | boolean)} params
                         * @returns this
                         * @memberof Filelink
                         */
                    };
                    clip_length: {
                        type: string;
                        pattern: string;
                    };
                    clip_offset: {
                        type: string;
                        pattern: string;
                    };
                    watermark_url: {
                        type: string;
                    };
                    watermark_top: {
                        type: string;
                        minimum: number;
                        maximum: number;
                    };
                    watermark_right: {
                        type: string;
                        minimum: number;
                        maximum: number;
                    };
                    watermark_bottom: {
                        type: string;
                        minimum: number;
                        maximum: number;
                    };
                    watermark_left: {
                        type: string;
                        minimum: number;
                        maximum: number;
                    };
                    frame_count: {
                        type: string;
                        minimum: number;
                        maximum: number; /**
                         * Adds blur transformation
                         *
                         * @see https://www.filestack.com/docs/api/processing/#blur
                         * @param {(BlurParams | boolean)} params
                         * @returns this
                         * @memberof Filelink
                         */
                        default: number;
                    };
                    filename: {
                        type: string;
                    };
                    location: {
                        $ref: string;
                    };
                    path: {
                        type: string;
                    };
                    container: {
                        type: string;
                    };
                    access: {
                        type: string;
                        enum: string[];
                        default: string;
                    };
                };
            };
            store: {
                oneOf: ({
                    type: string;
                    additionalProperties?: undefined;
                    properties?: undefined;
                } | {
                    type: string;
                    additionalProperties: boolean;
                    properties: {
                        filename: {
                            type: string;
                        };
                        location: {
                            $ref: string;
                        };
                        path: {
                            type: string;
                        };
                        container: {
                            type: string;
                        };
                        region: {
                            $ref: string;
                        };
                        access: {
                            type: string;
                            enum: string[];
                            default: string;
                        };
                        base64decode: {
                            type: string;
                        };
                        workflows: {
                            $ref: string;
                        };
                    };
                })[];
            };
            watermark: {
                type: string;
                properties: {
                    file: {
                        type: string;
                    };
                    size: {
                        type: string;
                        minimum: number;
                        maximum: number;
                    };
                    position: {
                        $ref: string;
                    };
                };
                required: string[];
                additionalProperties: boolean;
            };
            partial_blur: {
                type: string;
                properties: {
                    objects: {
                        $ref: string;
                    };
                    amount: {
                        type: string;
                        minimum: number;
                        maximum: number;
                    };
                    blur: {
                        type: string;
                        minimum: number;
                        maximum: number;
                    };
                    type: {
                        type: string;
                        enum: string[];
                    };
                };
                required: string[];
            };
            partial_pixelate: {
                type: string;
                properties: {
                    objects: {
                        $ref: string;
                    };
                    amount: {
                        type: string;
                        minimum: number;
                        maximum: number;
                    };
                    blur: {
                        type: string;
                        minimum: number;
                        maximum: number;
                    };
                    type: {
                        type: string;
                        enum: string[];
                    };
                };
                required: string[];
            };
            security: {
                type: string;
                additionalProperties: boolean;
                properties: {
                    policy: {
                        type: string;
                    };
                    signature: {
                        type: string;
                    };
                };
                required: string[]; /**
                 * Adds upscale transformation
                 *
                 * @see https://www.filestack.com/docs/api/processing/#upscale
                 * @param {(UpscaleParams | boolean)} params
                 * @returns this
                 * @memberof Filelink
                 */
            };
            pdfinfo: {
                oneOf: ({
                    type: string;
                    properties?: undefined;
                } | {
                    type: string;
                    properties: {
                        colorinfo: {
                            type: string;
                        };
                    };
                })[];
            };
            pdfconvert: {
                type: string;
                additionalProperties: boolean;
                properties: {
                    pageorientation: {
                        type: string;
                        enum: string[];
                    };
                    pageformat: {
                        $ref: string;
                    };
                    pages: {
                        $ref: string;
                    };
                };
                anyOf: {
                    required: string[];
                }[];
            };
            fallback: {
                type: string;
                additionalProperties: boolean;
                properties: {
                    handle: {
                        type: string;
                    };
                    cache: {
                        type: string;
                        minimum: number;
                        maximum: number;
                    };
                };
                required: string[];
            };
            zip: {
                type: string;
            };
            minify_css: {
                type: string;
                additionalProperties: boolean;
                properties: {
                    gzip: {
                        type: string;
                    };
                    level: {
                        type: string;
                        enum: number[];
                    };
                };
            };
            minify_js: {
                type: string;
                additionalProperties: boolean;
                properties: {
                    gzip: {
                        type: string;
                    };
                    use_babel_polyfill: {
                        type: string;
                    };
                    keep_fn_name: {
                        type: string;
                    };
                    keep_class_name: {
                        type: string;
                    };
                    mangle: {
                        type: string;
                    };
                    merge_vars: {
                        type: string;
                    };
                    remove_console: {
                        type: string;
                    };
                    remove_undefined: {
                        type: string;
                    };
                    targets: {
                        type: string;
                    };
                };
            };
        };
    };
    /**
     * Returns transformations in JSON format
     *
     * @returns
     * @memberof Filelink
     */
    getTransformations(): any[];
    /**
     * Returns transform url
     *
     * @returns
     * @memberof Filelink
     */
    toString(): string;
    /**
     * Add task and validate
     *
     * @param {string} name
     * @param {*} [params]
     * @returns
     * @memberof Filelink
     */
    addTask(name: string, params?: any): this;
    /**
     * Returns all tasks added for transformation
     *
     * @memberof Filelink
     */
    getTasks(): any[];
    /**
     * Cleanup transformations on filelink
     *
     * @returns
     * @memberof Filelink
     */
    reset(): this;
    /**
     * Transformations part
     */
    /**
     * Add autoimage transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#auto-image-conversion
     * @returns this
     * @memberof Filelink
     */
    autoImage(): this;
    /**
     * Adds flip transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#flip
     * @returns this
     * @memberof Filelink
     */
    flip(): this;
    /**
     * Adds flop transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#flop
     * @returns this
     * @memberof Filelink
     */
    flop(): this;
    /**
     * Adds imagesize transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#image-size
     * @returns this
     * @memberof Filelink
     */
    imagesize(): this;
    /**
     * Adds noMetadata transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#strip-metadata
     * @returns this
     * @memberof Filelink
     */
    noMetadata(): this;
    /**
     * Adds Progressive JPEG transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#progressive-jpeg
     * @returns this
     * @memberof Filelink
     */
    pjpg(params: ProgressiveJpgParams): this;
    /**
     * Adds imagesize transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#smart-crop
     * @returns this
     * @memberof Filelink
     */
    smartCrop(params: SmartCropParams): this;
    /**
     * Adds watermart transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#watermark
     * @returns this
     * @memberof Filelink
     */
    watermark(params: WatermarkParams): this;
    /**
     * Adds enhance transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#enhance
     * @returns this
     * @memberof Filelink
     */
    enhance(params?: EnhanceParams): this;
    /**
     * Add security to link
     *
     * @see https://www.filestack.com/docs/api/processing/#redeye
     * @returns
     * @memberof Filelink
     */
    redeye(): this;
    /**
     * Add monochrome transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#monochrome
     * @returns this
     * @memberof Filelink
     */
    monochrome(): this;
    /**
     * Add compress transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#compress
     * @returns this
     * @memberof Filelink
     */
    compress(params?: CompressParams): this;
    /**
     * Adds negative transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#negative
     * @returns this
     * @memberof Filelink
     */
    negative(): this;
    /**
     * Adds tags transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#tags
     * @returns this
     * @memberof Filelink
     */
    tags(): this;
    /**
     * Adds sfw transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#sfw
     * @returns this
     * @memberof Filelink
     */
    sfw(): this;
    /**
     * Add animate transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#animate-images-to-gif
     * @param params
     * @returns this
     * @memberof Filelink
     */
    animate(params: AnimationParams): this;
    /**
     * Adds store transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#store
     * @param {(StoreParams | boolean)} params
     * @returns this
     * @memberof Filelink
     */
    store(params?: StoreParams | boolean): this;
    /**
     * Adds cache transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#cache
     * @param {(CacheParams | boolean)} params
     * @returns this
     * @memberof Filelink
     */
    cache(params: CacheParams | boolean): this;
    /**
     * Adds resize transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#resize
     * @param {ResizeParams} params
     * @returns this
     * @memberof Filelink
     */
    resize(params: ResizeParams): this;
    /**
     * Adds crop transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#crop
     * @param {CropParams} params
     * @returns this
     * @memberof Filelink
     */
    crop(params: CropParams): this;
    /**
     * Adds rotate transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#rotate
     * @param {RotateParams} params
     * @returns this
     * @memberof Filelink
     */
    rotate(params: RotateParams): this;
    /**
     * Adds detect_faces transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#facial-detection
     * @param {(DetectFacesParams | boolean)} params
     * @returns this
     * @memberof Filelink
     */
    detectFaces(params?: DetectFacesParams | boolean): this;
    /**
     * Adds crop faces transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#crop-faces
     * @param {CropFacesParams} params
     * @returns this
     * @memberof Filelink
     */
    cropFaces(params: CropFacesParams): this;
    /**
     * Adds pixelate faces transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#pixelate-faces
     * @param {PixelateFacesParams} params
     * @returns this
     * @memberof Filelink
     */
    pixelateFaces(params: PixelateFacesParams): this;
    /**
     * Adds blur faces transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#blur-faces
     * @param {BlurFacesParams} params
     * @returns this
     * @memberof Filelink
     */
    blurFaces(params: BlurFacesParams): this;
    /**
     * Adds rounded corners transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#rounded-corners
     * @param {(RoundedCornersParams | boolean)} params
     * @returns this
     * @memberof Filelink
     */
    roundedCorners(params?: RoundedCornersParams | boolean): this;
    /**
     * Adds polaroid transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#polaroid
     * @param {(PolaroidParams | boolean)} params
     * @returns this
     * @memberof Filelink
     */
    polaroid(params?: PolaroidParams | boolean): this;
    /**
     * Adds vignette transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#vignette
     * @param {(VignetteParams | boolean)} params
     * @returns this
     * @memberof Filelink
     */
    vignette(params?: VignetteParams | boolean): this;
    /**
     * Adds torn edges transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#torn-edges
     * @param {(TornEdgesParams | boolean)} params
     * @returns this
     * @memberof Filelink
     */
    tornEdges(params?: TornEdgesParams | boolean): this;
    /**
     * Adds shadow transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#shadow
     * @param {(ShadowParams | boolean)} params
     * @returns this
     * @memberof Filelink
     */
    shadow(params?: ShadowParams | boolean): this;
    /**
     * Adds circle transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#circle
     * @param {(CircleParams | boolean)} params
     * @returns this
     * @memberof Filelink
     */
    circle(params?: CircleParams | boolean): this;
    /**
     * Adds border transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#border
     * @param {(BorderParams | boolean)} params
     * @returns this
     * @memberof Filelink
     */
    border(params?: BorderParams | boolean): this;
    /**
     * Adds sharpen transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#sharpen
     * @param {(SharpenParams | boolean)} params
     * @returns this
     * @memberof Filelink
     */
    sharpen(params?: SharpenParams | boolean): this;
    /**
     * Adds blur transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#blur
     * @param {(BlurParams | boolean)} params
     * @returns this
     * @memberof Filelink
     */
    blur(params?: BlurParams | boolean): this;
    /**
     * Adds blackwhite transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#blackwhite
     * @param {(BlackwhiteParams | boolean)} params
     * @returns this
     * @memberof Filelink
     */
    blackwhite(params?: BlackwhiteParams | boolean): this;
    /**
     * Adds sepia transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#sepia
     * @param {(SepiaParams | boolean)} params
     * @returns this
     * @memberof Filelink
     */
    sepia(params?: SepiaParams | boolean): this;
    /**
     * Adds pixelate transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#pixelate
     * @param {(PixelateParams | boolean)} params
     * @returns this
     * @memberof Filelink
     */
    pixelate(params?: PixelateParams | boolean): this;
    /**
     * Adds oilpaint transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#oil-paint
     * @param {(OilPaintParams | boolean)} params
     * @returns this
     * @memberof Filelink
     */
    oilPaint(params?: OilPaintParams | boolean): this;
    /**
     * Adds modulate transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#modulate
     * @param {(ModulateParams | boolean)} params
     * @returns this
     * @memberof Filelink
     */
    modulate(params?: ModulateParams | boolean): this;
    /**
     * Adds partial pixelate transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#partial-pixelate
     * @param {PartialPixelateParams} params
     * @returns this
     * @memberof Filelink
     */
    partialPixelate(params: PartialPixelateParams): this;
    /**
     * Adds partial blur transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#partial-blur
     * @param {PartialBlurParams} params
     * @returns this
     * @memberof Filelink
     */
    partialBlur(params: PartialBlurParams): this;
    /**
     * Adds collage transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#collage
     * @param {CollageParams} params
     * @returns this
     * @memberof Filelink
     */
    collage(params: CollageParams): this;
    /**
     * Adds upscale transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#upscale
     * @param {(UpscaleParams | boolean)} params
     * @returns this
     * @memberof Filelink
     */
    upscale(params?: UpscaleParams | boolean): this;
    /**
     * Adds ascii transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#ascii
     * @param {(AsciiParams | boolean)} params
     * @returns this
     * @memberof Filelink
     */
    ascii(params?: AsciiParams | boolean): this;
    /**
     * Adds quality transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#quality
     * @param {QualityParams} params
     * @returns this
     * @memberof Filelink
     */
    quality(params: QualityParams): this;
    /**
     * Adds security transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#security
     * @param {SecurityParams} params
     * @returns this
     * @memberof Filelink
     */
    security(params: SecurityParams): this;
    /**
     * Adds output transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#output
     * @param {OutputParams} params
     * @returns this
     * @memberof Filelink
     */
    output(params: OutputParams): this;
    /**
     * Adds video convert transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#video-convert
     * @param {VideoConvertParams} params
     * @returns this
     * @memberof Filelink
     */
    videoConvert(params: VideoConvertParams): this;
    /**
     * Adds URLScreenshot transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#urlscreenshot
     * @param {(URLScreenshotParams | boolean)} params
     * @returns this
     * @memberof Filelink
     */
    URLScreenshot(params?: URLScreenshotParams | boolean): this;
    /**
     * Adds pdfinfo transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#pdfinfo
     * @param {(PdfInfoParams | boolean)} params
     * @returns this
     * @memberof Filelink
     */
    PDFInfo(params?: PdfInfoParams | boolean): this;
    /**
     * Adds pdfconvert transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#pdfconvert
     * @param {(PdfConvertParams | boolean)} params
     * @returns this
     * @memberof Filelink
     */
    PDFConvert(params?: PdfConvertParams | boolean): this;
    /**
     * Adds fallback transformation
     *
     * @see https://www.filestack.com/docs/api/processing/#fallback
     * @param {(FallbackParams)} params
     * @returns this
     * @memberof Filelink
     */
    fallback(params: FallbackParams): this;
    /**
     * Add zip transformation which create a zip package on files
     * used on actual context
     *
     * @see https://www.filestack.com/docs/api/processing/#zip
     * @returns this
     * @memberof Filelink
     */
    zip(): this;
    /**
     * Add task which minify a css file
     *
     * @returns this
     * @memberof Filelink
     */
    minifyCss(params: MinifyCssParams): this;
    /**
     * Add task which minify a javascript file.
     * For better handling of 'targets' param, use with b64 flag enabled.
     *
     * @returns this
     * @memberof Filelink
     */
    minifyJs(params: MinifyJsParams): this;
    /**
     * Checks if source is external
     *
     * @private
     * @returns {boolean}
     * @memberof Filelink
     */
    private isSourceExternal;
    /**
     * Validate every task against schema
     *
     * @private
     * @param {object[]} transformations - object which contain all transformations
     * @returns {void}
     * @memberof Filelink
     */
    private validateTasks;
    /**
     * Returns correct cdn url with cname support
     *
     * @private
     * @returns {string}
     * @memberof Filelink
     */
    private getCdnHost;
    /**
     * Returns applied transformations as string
     *
     * @private
     * @returns {string}
     * @memberof Filelink
     */
    private generateTransformString;
    /**
     * Flatten transformation option to string
     *
     * @private
     * @example {resize:{width: 100,height: 200}} => resize=width:100,height:200
     * @param key - option key
     * @param values - option params
     */
    private optionToString;
    /**
     * Escape params values
     *
     * @private
     * @param {string} value
     * @returns {string}
     * @memberof Filelink
     */
    private escapeValue;
    /**
     * Converts nested arrays to string
     *
     * @private
     * @example [1,2, [2,3]] => "[1,2, [2,3]]"
     * @param arr - any array
     */
    private arrayToString;
    /**
     * Converts array of objects to object
     *
     * @private
     * @example [{name: 'resize', params: {height: 125}}] => {resize: {height: 125}}
     * @param arr - any array
     */
    private arrayToObject;
}