/// <reference types="node" />
/// <reference types="node" />
/// <reference types="node" />
import type { File as FormidableFile } from 'formidable';
import { yup } from '@strapi/utils';
import { z } from 'zod';
export declare const SUPPORTED_FORMATS: readonly ["jpeg", "webp", "avif", "png"];
export type SupportedFormat = (typeof SUPPORTED_FORMATS)[number];
export declare const breakpointsSchema: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
    breakpoint: z.ZodNumber;
    formats: z.ZodArray<z.ZodEnum<["jpeg", "webp", "avif", "png"]>, "many">;
}, "strip", z.ZodTypeAny, {
    breakpoint?: number;
    formats?: ("jpeg" | "webp" | "avif" | "png")[];
}, {
    breakpoint?: number;
    formats?: ("jpeg" | "webp" | "avif" | "png")[];
}>, z.ZodNumber]>>;
export type Breakpoints = z.infer<typeof breakpointsSchema>;
export type Dimensions = {
    width: number | null;
    height: number | null;
};
export type InputFile = FormidableFile & {
    path?: string;
    tmpWorkingDirectory?: string;
};
export interface File {
    id: number;
    name: string;
    alternativeText?: string | null;
    caption?: string | null;
    width?: number;
    height?: number;
    formats?: Record<string, unknown>;
    hash: string;
    ext?: string;
    mime?: string;
    size?: number;
    sizeInBytes?: number;
    url?: string;
    previewUrl?: string;
    path?: string | null;
    provider?: string;
    provider_metadata?: Record<string, unknown>;
    isUrlSigned?: boolean;
    folder?: number;
    folderPath?: string;
    related?: {
        id: string | number;
        __type: string;
        __pivot: {
            field: string;
        };
    }[];
    createdAt?: string;
    updatedAt?: string;
    createdBy?: number;
    updatedBy?: number;
}
export interface Folder {
    id: number;
    name: string;
    pathId: number;
    /**
     * parent id
     */
    parent?: number;
    /**
     * children ids
     */
    children?: number[];
    path: string;
    files?: File[];
}
export interface Config {
    provider: string;
    sizeLimit?: number;
    providerOptions: Record<string, unknown>;
    actionOptions: Record<string, unknown>;
}
export interface UploadableFile extends Omit<File, 'id'> {
    filepath?: string;
    getStream: () => NodeJS.ReadableStream;
    stream?: NodeJS.ReadableStream;
    buffer?: Buffer;
    tmpWorkingDirectory?: string;
}
export type FileInfo = {
    name?: string | null;
    alternativeText?: string | null;
    caption?: string | null;
    folder?: number;
};
export declare const settingsSchema: import("yup/lib/object").OptionalObjectSchema<{
    sizeOptimization: import("yup/lib/boolean").RequiredBooleanSchema<boolean, Record<string, any>>;
    responsiveDimensions: import("yup/lib/boolean").RequiredBooleanSchema<boolean, Record<string, any>>;
    autoOrientation: yup.BooleanSchema<boolean, Record<string, any>, boolean>;
}, Record<string, any>, import("yup/lib/object").TypeOfShape<{
    sizeOptimization: import("yup/lib/boolean").RequiredBooleanSchema<boolean, Record<string, any>>;
    responsiveDimensions: import("yup/lib/boolean").RequiredBooleanSchema<boolean, Record<string, any>>;
    autoOrientation: yup.BooleanSchema<boolean, Record<string, any>, boolean>;
}>>;
export type Settings = yup.InferType<typeof settingsSchema>;
export declare const jpegOptionsSchema: z.ZodObject<{
    /** Force format output, otherwise attempt to use input format (optional, default true) */
    force: z.ZodOptional<z.ZodBoolean>;
} & {
    /** Quality, integer 1-100 (optional, default 80) */
    quality: z.ZodOptional<z.ZodNumber>;
    /** Use progressive (interlace) scan (optional, default false) */
    progressive: z.ZodOptional<z.ZodBoolean>;
    /** Set to '4:4:4' to prevent chroma subsampling when quality <= 90 (optional, default '4:2:0') */
    chromaSubsampling: z.ZodOptional<z.ZodString>;
    /** Apply trellis quantisation (optional, default false) */
    trellisQuantisation: z.ZodOptional<z.ZodBoolean>;
    /** Apply overshoot deringing (optional, default false) */
    overshootDeringing: z.ZodOptional<z.ZodBoolean>;
    /** Optimise progressive scans, forces progressive (optional, default false) */
    optimiseScans: z.ZodOptional<z.ZodBoolean>;
    /** Alternative spelling of optimiseScans (optional, default false) */
    optimizeScans: z.ZodOptional<z.ZodBoolean>;
    /** Optimise Huffman coding tables (optional, default true) */
    optimiseCoding: z.ZodOptional<z.ZodBoolean>;
    /** Alternative spelling of optimiseCoding (optional, default true) */
    optimizeCoding: z.ZodOptional<z.ZodBoolean>;
    /** Quantization table to use, integer 0-8 (optional, default 0) */
    quantisationTable: z.ZodOptional<z.ZodNumber>;
    /** Alternative spelling of quantisationTable (optional, default 0) */
    quantizationTable: z.ZodOptional<z.ZodNumber>;
    /** Use mozjpeg defaults (optional, default false) */
    mozjpeg: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    force?: boolean;
    quality?: number;
    progressive?: boolean;
    chromaSubsampling?: string;
    trellisQuantisation?: boolean;
    overshootDeringing?: boolean;
    optimiseScans?: boolean;
    optimizeScans?: boolean;
    optimiseCoding?: boolean;
    optimizeCoding?: boolean;
    quantisationTable?: number;
    quantizationTable?: number;
    mozjpeg?: boolean;
}, {
    force?: boolean;
    quality?: number;
    progressive?: boolean;
    chromaSubsampling?: string;
    trellisQuantisation?: boolean;
    overshootDeringing?: boolean;
    optimiseScans?: boolean;
    optimizeScans?: boolean;
    optimiseCoding?: boolean;
    optimizeCoding?: boolean;
    quantisationTable?: number;
    quantizationTable?: number;
    mozjpeg?: boolean;
}>;
export declare const jp2OptionsSchema: z.ZodObject<{
    /** Force format output, otherwise attempt to use input format (optional, default true) */
    force: z.ZodOptional<z.ZodBoolean>;
} & {
    /** Quality, integer 1-100 (optional, default 80) */
    quality: z.ZodOptional<z.ZodNumber>;
    /** Use lossless compression mode (optional, default false) */
    lossless: z.ZodOptional<z.ZodBoolean>;
    /** Horizontal tile size (optional, default 512) */
    tileWidth: z.ZodOptional<z.ZodNumber>;
    /** Vertical tile size (optional, default 512) */
    tileHeight: z.ZodOptional<z.ZodNumber>;
    /** Set to '4:2:0' to enable chroma subsampling (optional, default '4:4:4') */
    chromaSubsampling: z.ZodOptional<z.ZodEnum<["4:4:4", "4:2:0"]>>;
}, "strip", z.ZodTypeAny, {
    force?: boolean;
    quality?: number;
    chromaSubsampling?: "4:4:4" | "4:2:0";
    lossless?: boolean;
    tileWidth?: number;
    tileHeight?: number;
}, {
    force?: boolean;
    quality?: number;
    chromaSubsampling?: "4:4:4" | "4:2:0";
    lossless?: boolean;
    tileWidth?: number;
    tileHeight?: number;
}>;
export declare const jxlOptionsSchema: z.ZodObject<{
    /** Force format output, otherwise attempt to use input format (optional, default true) */
    force: z.ZodOptional<z.ZodBoolean>;
} & {
    /** Maximum encoding error, between 0 (highest quality) and 15 (lowest quality) (optional, default 1.0) */
    distance: z.ZodOptional<z.ZodNumber>;
    /** Calculate distance based on JPEG-like quality, between 1 and 100, overrides distance if specified */
    quality: z.ZodOptional<z.ZodNumber>;
    /** Target decode speed tier, between 0 (highest quality) and 4 (lowest quality) (optional, default 0) */
    decodingTier: z.ZodOptional<z.ZodNumber>;
    /** Use lossless compression (optional, default false) */
    lossless: z.ZodOptional<z.ZodBoolean>;
    /** CPU effort, between 3 (fastest) and 9 (slowest) (optional, default 7) */
    effort: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    force?: boolean;
    quality?: number;
    lossless?: boolean;
    distance?: number;
    decodingTier?: number;
    effort?: number;
}, {
    force?: boolean;
    quality?: number;
    lossless?: boolean;
    distance?: number;
    decodingTier?: number;
    effort?: number;
}>;
export declare const webpOptionsSchema: z.ZodObject<{
    /** Force format output, otherwise attempt to use input format (optional, default true) */
    force: z.ZodOptional<z.ZodBoolean>;
} & {
    /** Number of animation iterations, use 0 for infinite animation (optional, default 0) */
    loop: z.ZodOptional<z.ZodNumber>;
    /** Delay between animation frames in milliseconds (optional, default 100) */
    delay: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
} & {
    /** Quality, integer 1-100 (optional, default 80) */
    quality: z.ZodOptional<z.ZodNumber>;
    /** Quality of alpha layer, number from 0-100 (optional, default 100) */
    alphaQuality: z.ZodOptional<z.ZodNumber>;
    /** Use lossless compression mode (optional, default false) */
    lossless: z.ZodOptional<z.ZodBoolean>;
    /** Use near_lossless compression mode (optional, default false) */
    nearLossless: z.ZodOptional<z.ZodBoolean>;
    /** Use high quality chroma subsampling (optional, default false) */
    smartSubsample: z.ZodOptional<z.ZodBoolean>;
    /** Auto-adjust the deblocking filter, slow but can improve low contrast edges (optional, default false) */
    smartDeblock: z.ZodOptional<z.ZodBoolean>;
    /** Level of CPU effort to reduce file size, integer 0-6 (optional, default 4) */
    effort: z.ZodOptional<z.ZodNumber>;
    /** Prevent use of animation key frames to minimise file size (slow) (optional, default false) */
    minSize: z.ZodOptional<z.ZodBoolean>;
    /** Allow mixture of lossy and lossless animation frames (slow) (optional, default false) */
    mixed: z.ZodOptional<z.ZodBoolean>;
    /** Preset options: one of default, photo, picture, drawing, icon, text (optional, default 'default') */
    preset: z.ZodOptional<z.ZodEnum<["default", "photo", "picture", "drawing", "icon", "text"]>>;
}, "strip", z.ZodTypeAny, {
    force?: boolean;
    loop?: number;
    delay?: number | number[];
    quality?: number;
    lossless?: boolean;
    effort?: number;
    alphaQuality?: number;
    nearLossless?: boolean;
    smartSubsample?: boolean;
    smartDeblock?: boolean;
    minSize?: boolean;
    mixed?: boolean;
    preset?: "default" | "photo" | "picture" | "drawing" | "icon" | "text";
}, {
    force?: boolean;
    loop?: number;
    delay?: number | number[];
    quality?: number;
    lossless?: boolean;
    effort?: number;
    alphaQuality?: number;
    nearLossless?: boolean;
    smartSubsample?: boolean;
    smartDeblock?: boolean;
    minSize?: boolean;
    mixed?: boolean;
    preset?: "default" | "photo" | "picture" | "drawing" | "icon" | "text";
}>;
export declare const avifOptionsSchema: z.ZodObject<{
    /** Force format output, otherwise attempt to use input format (optional, default true) */
    force: z.ZodOptional<z.ZodBoolean>;
} & {
    /** Quality, integer 1-100 (optional, default 50) */
    quality: z.ZodOptional<z.ZodNumber>;
    /** Use lossless compression (optional, default false) */
    lossless: z.ZodOptional<z.ZodBoolean>;
    /** Level of CPU effort to reduce file size, between 0 (fastest) and 9 (slowest) (optional, default 4) */
    effort: z.ZodOptional<z.ZodNumber>;
    /** Set to '4:2:0' to use chroma subsampling, requires libvips v8.11.0 (optional, default '4:4:4') */
    chromaSubsampling: z.ZodOptional<z.ZodString>;
    /** Set bitdepth to 8, 10 or 12 bit (optional, default 8) */
    bitdepth: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<8>, z.ZodLiteral<10>, z.ZodLiteral<12>]>>;
}, "strip", z.ZodTypeAny, {
    force?: boolean;
    quality?: number;
    chromaSubsampling?: string;
    lossless?: boolean;
    effort?: number;
    bitdepth?: 8 | 10 | 12;
}, {
    force?: boolean;
    quality?: number;
    chromaSubsampling?: string;
    lossless?: boolean;
    effort?: number;
    bitdepth?: 8 | 10 | 12;
}>;
export declare const heifOptionsSchema: z.ZodObject<{
    /** Force format output, otherwise attempt to use input format (optional, default true) */
    force: z.ZodOptional<z.ZodBoolean>;
} & {
    /** Quality, integer 1-100 (optional, default 50) */
    quality: z.ZodOptional<z.ZodNumber>;
    /** Compression format: av1, hevc (optional, default 'av1') */
    compression: z.ZodOptional<z.ZodEnum<["av1", "hevc"]>>;
    /** Use lossless compression (optional, default false) */
    lossless: z.ZodOptional<z.ZodBoolean>;
    /** Level of CPU effort to reduce file size, between 0 (fastest) and 9 (slowest) (optional, default 4) */
    effort: z.ZodOptional<z.ZodNumber>;
    /** Set to '4:2:0' to use chroma subsampling (optional, default '4:4:4') */
    chromaSubsampling: z.ZodOptional<z.ZodString>;
    /** Set bitdepth to 8, 10 or 12 bit (optional, default 8) */
    bitdepth: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<8>, z.ZodLiteral<10>, z.ZodLiteral<12>]>>;
}, "strip", z.ZodTypeAny, {
    force?: boolean;
    quality?: number;
    chromaSubsampling?: string;
    lossless?: boolean;
    effort?: number;
    bitdepth?: 8 | 10 | 12;
    compression?: "av1" | "hevc";
}, {
    force?: boolean;
    quality?: number;
    chromaSubsampling?: string;
    lossless?: boolean;
    effort?: number;
    bitdepth?: 8 | 10 | 12;
    compression?: "av1" | "hevc";
}>;
export declare const gifOptionsSchema: z.ZodObject<{
    /** Force format output, otherwise attempt to use input format (optional, default true) */
    force: z.ZodOptional<z.ZodBoolean>;
} & {
    /** Number of animation iterations, use 0 for infinite animation (optional, default 0) */
    loop: z.ZodOptional<z.ZodNumber>;
    /** Delay between animation frames in milliseconds (optional, default 100) */
    delay: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
} & {
    /** Re-use existing palette, otherwise generate new (slow) */
    reuse: z.ZodOptional<z.ZodBoolean>;
    /** Use progressive (interlace) scan */
    progressive: z.ZodOptional<z.ZodBoolean>;
    /** Maximum number of palette entries, including transparency, between 2 and 256 (optional, default 256) */
    colours: z.ZodOptional<z.ZodNumber>;
    /** Alternative spelling of "colours". Maximum number of palette entries, including transparency, between 2 and 256 (optional, default 256) */
    colors: z.ZodOptional<z.ZodNumber>;
    /** Level of CPU effort to reduce file size, between 1 (fastest) and 10 (slowest) (optional, default 7) */
    effort: z.ZodOptional<z.ZodNumber>;
    /** Level of Floyd-Steinberg error diffusion, between 0 (least) and 1 (most) (optional, default 1.0) */
    dither: z.ZodOptional<z.ZodNumber>;
    /** Maximum inter-frame error for transparency, between 0 (lossless) and 32 (optional, default 0) */
    interFrameMaxError: z.ZodOptional<z.ZodNumber>;
    /** Maximum inter-palette error for palette reuse, between 0 and 256 (optional, default 3) */
    interPaletteMaxError: z.ZodOptional<z.ZodNumber>;
    /** Keep duplicate frames in the output instead of combining them (optional, default false) */
    keepDuplicateFrames: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    force?: boolean;
    loop?: number;
    delay?: number | number[];
    progressive?: boolean;
    effort?: number;
    reuse?: boolean;
    colours?: number;
    colors?: number;
    dither?: number;
    interFrameMaxError?: number;
    interPaletteMaxError?: number;
    keepDuplicateFrames?: boolean;
}, {
    force?: boolean;
    loop?: number;
    delay?: number | number[];
    progressive?: boolean;
    effort?: number;
    reuse?: boolean;
    colours?: number;
    colors?: number;
    dither?: number;
    interFrameMaxError?: number;
    interPaletteMaxError?: number;
    keepDuplicateFrames?: boolean;
}>;
export declare const tiffOptionsSchema: z.ZodObject<{
    /** Force format output, otherwise attempt to use input format (optional, default true) */
    force: z.ZodOptional<z.ZodBoolean>;
} & {
    /** Quality, integer 1-100 (optional, default 80) */
    quality: z.ZodOptional<z.ZodNumber>;
    /** Compression options: none, jpeg, deflate, packbits, ccittfax4, lzw, webp, zstd, jp2k (optional, default 'jpeg') */
    compression: z.ZodOptional<z.ZodEnum<["none", "jpeg", "deflate", "packbits", "ccittfax4", "lzw", "webp", "zstd", "jp2k"]>>;
    /** Use BigTIFF variant (has no effect when compression is none) (optional, default false) */
    bigtiff: z.ZodOptional<z.ZodBoolean>;
    /** Compression predictor options: none, horizontal, float (optional, default 'horizontal') */
    predictor: z.ZodOptional<z.ZodEnum<["none", "horizontal", "float"]>>;
    /** Write an image pyramid (optional, default false) */
    pyramid: z.ZodOptional<z.ZodBoolean>;
    /** Write a tiled tiff (optional, default false) */
    tile: z.ZodOptional<z.ZodBoolean>;
    /** Horizontal tile size (optional, default 256) */
    tileWidth: z.ZodOptional<z.ZodNumber>;
    /** Vertical tile size (optional, default 256) */
    tileHeight: z.ZodOptional<z.ZodNumber>;
    /** Horizontal resolution in pixels/mm (optional, default 1.0) */
    xres: z.ZodOptional<z.ZodNumber>;
    /** Vertical resolution in pixels/mm (optional, default 1.0) */
    yres: z.ZodOptional<z.ZodNumber>;
    /** Reduce bitdepth to 1, 2 or 4 bit (optional, default 8) */
    bitdepth: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<4>, z.ZodLiteral<8>]>>;
    /** Write 1-bit images as miniswhite (optional, default false) */
    miniswhite: z.ZodOptional<z.ZodBoolean>;
    /** Resolution unit options: inch, cm (optional, default 'inch') */
    resolutionUnit: z.ZodOptional<z.ZodEnum<["inch", "cm"]>>;
}, "strip", z.ZodTypeAny, {
    force?: boolean;
    quality?: number;
    tileWidth?: number;
    tileHeight?: number;
    bitdepth?: 4 | 1 | 2 | 8;
    compression?: "jpeg" | "webp" | "none" | "deflate" | "packbits" | "ccittfax4" | "lzw" | "zstd" | "jp2k";
    bigtiff?: boolean;
    predictor?: "float" | "none" | "horizontal";
    pyramid?: boolean;
    tile?: boolean;
    xres?: number;
    yres?: number;
    miniswhite?: boolean;
    resolutionUnit?: "inch" | "cm";
}, {
    force?: boolean;
    quality?: number;
    tileWidth?: number;
    tileHeight?: number;
    bitdepth?: 4 | 1 | 2 | 8;
    compression?: "jpeg" | "webp" | "none" | "deflate" | "packbits" | "ccittfax4" | "lzw" | "zstd" | "jp2k";
    bigtiff?: boolean;
    predictor?: "float" | "none" | "horizontal";
    pyramid?: boolean;
    tile?: boolean;
    xres?: number;
    yres?: number;
    miniswhite?: boolean;
    resolutionUnit?: "inch" | "cm";
}>;
export declare const pngOptionsSchema: z.ZodObject<{
    /** Force format output, otherwise attempt to use input format (optional, default true) */
    force: z.ZodOptional<z.ZodBoolean>;
} & {
    /** Use progressive (interlace) scan (optional, default false) */
    progressive: z.ZodOptional<z.ZodBoolean>;
    /** zlib compression level, 0-9 (optional, default 6) */
    compressionLevel: z.ZodOptional<z.ZodNumber>;
    /** Use adaptive row filtering (optional, default false) */
    adaptiveFiltering: z.ZodOptional<z.ZodBoolean>;
    /** Use the lowest number of colours needed to achieve given quality (optional, default 100) */
    quality: z.ZodOptional<z.ZodNumber>;
    /** Level of CPU effort to reduce file size, between 1 (fastest) and 10 (slowest), sets palette to true (optional, default 7) */
    effort: z.ZodOptional<z.ZodNumber>;
    /** Quantise to a palette-based image with alpha transparency support (optional, default false) */
    palette: z.ZodOptional<z.ZodBoolean>;
    /** Maximum number of palette entries (optional, default 256) */
    colours: z.ZodOptional<z.ZodNumber>;
    /** Alternative Spelling of "colours". Maximum number of palette entries (optional, default 256) */
    colors: z.ZodOptional<z.ZodNumber>;
    /** Level of Floyd-Steinberg error diffusion (optional, default 1.0) */
    dither: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    force?: boolean;
    quality?: number;
    progressive?: boolean;
    effort?: number;
    colours?: number;
    colors?: number;
    dither?: number;
    compressionLevel?: number;
    adaptiveFiltering?: boolean;
    palette?: boolean;
}, {
    force?: boolean;
    quality?: number;
    progressive?: boolean;
    effort?: number;
    colours?: number;
    colors?: number;
    dither?: number;
    compressionLevel?: number;
    adaptiveFiltering?: boolean;
    palette?: boolean;
}>;
export declare const formatOptionsSchema: z.ZodObject<{
    jpeg: z.ZodOptional<z.ZodObject<{
        /** Force format output, otherwise attempt to use input format (optional, default true) */
        force: z.ZodOptional<z.ZodBoolean>;
    } & {
        /** Quality, integer 1-100 (optional, default 80) */
        quality: z.ZodOptional<z.ZodNumber>;
        /** Use progressive (interlace) scan (optional, default false) */
        progressive: z.ZodOptional<z.ZodBoolean>;
        /** Set to '4:4:4' to prevent chroma subsampling when quality <= 90 (optional, default '4:2:0') */
        chromaSubsampling: z.ZodOptional<z.ZodString>;
        /** Apply trellis quantisation (optional, default false) */
        trellisQuantisation: z.ZodOptional<z.ZodBoolean>;
        /** Apply overshoot deringing (optional, default false) */
        overshootDeringing: z.ZodOptional<z.ZodBoolean>;
        /** Optimise progressive scans, forces progressive (optional, default false) */
        optimiseScans: z.ZodOptional<z.ZodBoolean>;
        /** Alternative spelling of optimiseScans (optional, default false) */
        optimizeScans: z.ZodOptional<z.ZodBoolean>;
        /** Optimise Huffman coding tables (optional, default true) */
        optimiseCoding: z.ZodOptional<z.ZodBoolean>;
        /** Alternative spelling of optimiseCoding (optional, default true) */
        optimizeCoding: z.ZodOptional<z.ZodBoolean>;
        /** Quantization table to use, integer 0-8 (optional, default 0) */
        quantisationTable: z.ZodOptional<z.ZodNumber>;
        /** Alternative spelling of quantisationTable (optional, default 0) */
        quantizationTable: z.ZodOptional<z.ZodNumber>;
        /** Use mozjpeg defaults (optional, default false) */
        mozjpeg: z.ZodOptional<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        force?: boolean;
        quality?: number;
        progressive?: boolean;
        chromaSubsampling?: string;
        trellisQuantisation?: boolean;
        overshootDeringing?: boolean;
        optimiseScans?: boolean;
        optimizeScans?: boolean;
        optimiseCoding?: boolean;
        optimizeCoding?: boolean;
        quantisationTable?: number;
        quantizationTable?: number;
        mozjpeg?: boolean;
    }, {
        force?: boolean;
        quality?: number;
        progressive?: boolean;
        chromaSubsampling?: string;
        trellisQuantisation?: boolean;
        overshootDeringing?: boolean;
        optimiseScans?: boolean;
        optimizeScans?: boolean;
        optimiseCoding?: boolean;
        optimizeCoding?: boolean;
        quantisationTable?: number;
        quantizationTable?: number;
        mozjpeg?: boolean;
    }>>;
    jp2: z.ZodOptional<z.ZodObject<{
        /** Force format output, otherwise attempt to use input format (optional, default true) */
        force: z.ZodOptional<z.ZodBoolean>;
    } & {
        /** Quality, integer 1-100 (optional, default 80) */
        quality: z.ZodOptional<z.ZodNumber>;
        /** Use lossless compression mode (optional, default false) */
        lossless: z.ZodOptional<z.ZodBoolean>;
        /** Horizontal tile size (optional, default 512) */
        tileWidth: z.ZodOptional<z.ZodNumber>;
        /** Vertical tile size (optional, default 512) */
        tileHeight: z.ZodOptional<z.ZodNumber>;
        /** Set to '4:2:0' to enable chroma subsampling (optional, default '4:4:4') */
        chromaSubsampling: z.ZodOptional<z.ZodEnum<["4:4:4", "4:2:0"]>>;
    }, "strip", z.ZodTypeAny, {
        force?: boolean;
        quality?: number;
        chromaSubsampling?: "4:4:4" | "4:2:0";
        lossless?: boolean;
        tileWidth?: number;
        tileHeight?: number;
    }, {
        force?: boolean;
        quality?: number;
        chromaSubsampling?: "4:4:4" | "4:2:0";
        lossless?: boolean;
        tileWidth?: number;
        tileHeight?: number;
    }>>;
    jxl: z.ZodOptional<z.ZodObject<{
        /** Force format output, otherwise attempt to use input format (optional, default true) */
        force: z.ZodOptional<z.ZodBoolean>;
    } & {
        /** Maximum encoding error, between 0 (highest quality) and 15 (lowest quality) (optional, default 1.0) */
        distance: z.ZodOptional<z.ZodNumber>;
        /** Calculate distance based on JPEG-like quality, between 1 and 100, overrides distance if specified */
        quality: z.ZodOptional<z.ZodNumber>;
        /** Target decode speed tier, between 0 (highest quality) and 4 (lowest quality) (optional, default 0) */
        decodingTier: z.ZodOptional<z.ZodNumber>;
        /** Use lossless compression (optional, default false) */
        lossless: z.ZodOptional<z.ZodBoolean>;
        /** CPU effort, between 3 (fastest) and 9 (slowest) (optional, default 7) */
        effort: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        force?: boolean;
        quality?: number;
        lossless?: boolean;
        distance?: number;
        decodingTier?: number;
        effort?: number;
    }, {
        force?: boolean;
        quality?: number;
        lossless?: boolean;
        distance?: number;
        decodingTier?: number;
        effort?: number;
    }>>;
    webp: z.ZodOptional<z.ZodObject<{
        /** Force format output, otherwise attempt to use input format (optional, default true) */
        force: z.ZodOptional<z.ZodBoolean>;
    } & {
        /** Number of animation iterations, use 0 for infinite animation (optional, default 0) */
        loop: z.ZodOptional<z.ZodNumber>;
        /** Delay between animation frames in milliseconds (optional, default 100) */
        delay: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
    } & {
        /** Quality, integer 1-100 (optional, default 80) */
        quality: z.ZodOptional<z.ZodNumber>;
        /** Quality of alpha layer, number from 0-100 (optional, default 100) */
        alphaQuality: z.ZodOptional<z.ZodNumber>;
        /** Use lossless compression mode (optional, default false) */
        lossless: z.ZodOptional<z.ZodBoolean>;
        /** Use near_lossless compression mode (optional, default false) */
        nearLossless: z.ZodOptional<z.ZodBoolean>;
        /** Use high quality chroma subsampling (optional, default false) */
        smartSubsample: z.ZodOptional<z.ZodBoolean>;
        /** Auto-adjust the deblocking filter, slow but can improve low contrast edges (optional, default false) */
        smartDeblock: z.ZodOptional<z.ZodBoolean>;
        /** Level of CPU effort to reduce file size, integer 0-6 (optional, default 4) */
        effort: z.ZodOptional<z.ZodNumber>;
        /** Prevent use of animation key frames to minimise file size (slow) (optional, default false) */
        minSize: z.ZodOptional<z.ZodBoolean>;
        /** Allow mixture of lossy and lossless animation frames (slow) (optional, default false) */
        mixed: z.ZodOptional<z.ZodBoolean>;
        /** Preset options: one of default, photo, picture, drawing, icon, text (optional, default 'default') */
        preset: z.ZodOptional<z.ZodEnum<["default", "photo", "picture", "drawing", "icon", "text"]>>;
    }, "strip", z.ZodTypeAny, {
        force?: boolean;
        loop?: number;
        delay?: number | number[];
        quality?: number;
        lossless?: boolean;
        effort?: number;
        alphaQuality?: number;
        nearLossless?: boolean;
        smartSubsample?: boolean;
        smartDeblock?: boolean;
        minSize?: boolean;
        mixed?: boolean;
        preset?: "default" | "photo" | "picture" | "drawing" | "icon" | "text";
    }, {
        force?: boolean;
        loop?: number;
        delay?: number | number[];
        quality?: number;
        lossless?: boolean;
        effort?: number;
        alphaQuality?: number;
        nearLossless?: boolean;
        smartSubsample?: boolean;
        smartDeblock?: boolean;
        minSize?: boolean;
        mixed?: boolean;
        preset?: "default" | "photo" | "picture" | "drawing" | "icon" | "text";
    }>>;
    avif: z.ZodOptional<z.ZodObject<{
        /** Force format output, otherwise attempt to use input format (optional, default true) */
        force: z.ZodOptional<z.ZodBoolean>;
    } & {
        /** Quality, integer 1-100 (optional, default 50) */
        quality: z.ZodOptional<z.ZodNumber>;
        /** Use lossless compression (optional, default false) */
        lossless: z.ZodOptional<z.ZodBoolean>;
        /** Level of CPU effort to reduce file size, between 0 (fastest) and 9 (slowest) (optional, default 4) */
        effort: z.ZodOptional<z.ZodNumber>;
        /** Set to '4:2:0' to use chroma subsampling, requires libvips v8.11.0 (optional, default '4:4:4') */
        chromaSubsampling: z.ZodOptional<z.ZodString>;
        /** Set bitdepth to 8, 10 or 12 bit (optional, default 8) */
        bitdepth: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<8>, z.ZodLiteral<10>, z.ZodLiteral<12>]>>;
    }, "strip", z.ZodTypeAny, {
        force?: boolean;
        quality?: number;
        chromaSubsampling?: string;
        lossless?: boolean;
        effort?: number;
        bitdepth?: 8 | 10 | 12;
    }, {
        force?: boolean;
        quality?: number;
        chromaSubsampling?: string;
        lossless?: boolean;
        effort?: number;
        bitdepth?: 8 | 10 | 12;
    }>>;
    heif: z.ZodOptional<z.ZodObject<{
        /** Force format output, otherwise attempt to use input format (optional, default true) */
        force: z.ZodOptional<z.ZodBoolean>;
    } & {
        /** Quality, integer 1-100 (optional, default 50) */
        quality: z.ZodOptional<z.ZodNumber>;
        /** Compression format: av1, hevc (optional, default 'av1') */
        compression: z.ZodOptional<z.ZodEnum<["av1", "hevc"]>>;
        /** Use lossless compression (optional, default false) */
        lossless: z.ZodOptional<z.ZodBoolean>;
        /** Level of CPU effort to reduce file size, between 0 (fastest) and 9 (slowest) (optional, default 4) */
        effort: z.ZodOptional<z.ZodNumber>;
        /** Set to '4:2:0' to use chroma subsampling (optional, default '4:4:4') */
        chromaSubsampling: z.ZodOptional<z.ZodString>;
        /** Set bitdepth to 8, 10 or 12 bit (optional, default 8) */
        bitdepth: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<8>, z.ZodLiteral<10>, z.ZodLiteral<12>]>>;
    }, "strip", z.ZodTypeAny, {
        force?: boolean;
        quality?: number;
        chromaSubsampling?: string;
        lossless?: boolean;
        effort?: number;
        bitdepth?: 8 | 10 | 12;
        compression?: "av1" | "hevc";
    }, {
        force?: boolean;
        quality?: number;
        chromaSubsampling?: string;
        lossless?: boolean;
        effort?: number;
        bitdepth?: 8 | 10 | 12;
        compression?: "av1" | "hevc";
    }>>;
    gif: z.ZodOptional<z.ZodObject<{
        /** Force format output, otherwise attempt to use input format (optional, default true) */
        force: z.ZodOptional<z.ZodBoolean>;
    } & {
        /** Number of animation iterations, use 0 for infinite animation (optional, default 0) */
        loop: z.ZodOptional<z.ZodNumber>;
        /** Delay between animation frames in milliseconds (optional, default 100) */
        delay: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
    } & {
        /** Re-use existing palette, otherwise generate new (slow) */
        reuse: z.ZodOptional<z.ZodBoolean>;
        /** Use progressive (interlace) scan */
        progressive: z.ZodOptional<z.ZodBoolean>;
        /** Maximum number of palette entries, including transparency, between 2 and 256 (optional, default 256) */
        colours: z.ZodOptional<z.ZodNumber>;
        /** Alternative spelling of "colours". Maximum number of palette entries, including transparency, between 2 and 256 (optional, default 256) */
        colors: z.ZodOptional<z.ZodNumber>;
        /** Level of CPU effort to reduce file size, between 1 (fastest) and 10 (slowest) (optional, default 7) */
        effort: z.ZodOptional<z.ZodNumber>;
        /** Level of Floyd-Steinberg error diffusion, between 0 (least) and 1 (most) (optional, default 1.0) */
        dither: z.ZodOptional<z.ZodNumber>;
        /** Maximum inter-frame error for transparency, between 0 (lossless) and 32 (optional, default 0) */
        interFrameMaxError: z.ZodOptional<z.ZodNumber>;
        /** Maximum inter-palette error for palette reuse, between 0 and 256 (optional, default 3) */
        interPaletteMaxError: z.ZodOptional<z.ZodNumber>;
        /** Keep duplicate frames in the output instead of combining them (optional, default false) */
        keepDuplicateFrames: z.ZodOptional<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        force?: boolean;
        loop?: number;
        delay?: number | number[];
        progressive?: boolean;
        effort?: number;
        reuse?: boolean;
        colours?: number;
        colors?: number;
        dither?: number;
        interFrameMaxError?: number;
        interPaletteMaxError?: number;
        keepDuplicateFrames?: boolean;
    }, {
        force?: boolean;
        loop?: number;
        delay?: number | number[];
        progressive?: boolean;
        effort?: number;
        reuse?: boolean;
        colours?: number;
        colors?: number;
        dither?: number;
        interFrameMaxError?: number;
        interPaletteMaxError?: number;
        keepDuplicateFrames?: boolean;
    }>>;
    tiff: z.ZodOptional<z.ZodObject<{
        /** Force format output, otherwise attempt to use input format (optional, default true) */
        force: z.ZodOptional<z.ZodBoolean>;
    } & {
        /** Quality, integer 1-100 (optional, default 80) */
        quality: z.ZodOptional<z.ZodNumber>;
        /** Compression options: none, jpeg, deflate, packbits, ccittfax4, lzw, webp, zstd, jp2k (optional, default 'jpeg') */
        compression: z.ZodOptional<z.ZodEnum<["none", "jpeg", "deflate", "packbits", "ccittfax4", "lzw", "webp", "zstd", "jp2k"]>>;
        /** Use BigTIFF variant (has no effect when compression is none) (optional, default false) */
        bigtiff: z.ZodOptional<z.ZodBoolean>;
        /** Compression predictor options: none, horizontal, float (optional, default 'horizontal') */
        predictor: z.ZodOptional<z.ZodEnum<["none", "horizontal", "float"]>>;
        /** Write an image pyramid (optional, default false) */
        pyramid: z.ZodOptional<z.ZodBoolean>;
        /** Write a tiled tiff (optional, default false) */
        tile: z.ZodOptional<z.ZodBoolean>;
        /** Horizontal tile size (optional, default 256) */
        tileWidth: z.ZodOptional<z.ZodNumber>;
        /** Vertical tile size (optional, default 256) */
        tileHeight: z.ZodOptional<z.ZodNumber>;
        /** Horizontal resolution in pixels/mm (optional, default 1.0) */
        xres: z.ZodOptional<z.ZodNumber>;
        /** Vertical resolution in pixels/mm (optional, default 1.0) */
        yres: z.ZodOptional<z.ZodNumber>;
        /** Reduce bitdepth to 1, 2 or 4 bit (optional, default 8) */
        bitdepth: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<4>, z.ZodLiteral<8>]>>;
        /** Write 1-bit images as miniswhite (optional, default false) */
        miniswhite: z.ZodOptional<z.ZodBoolean>;
        /** Resolution unit options: inch, cm (optional, default 'inch') */
        resolutionUnit: z.ZodOptional<z.ZodEnum<["inch", "cm"]>>;
    }, "strip", z.ZodTypeAny, {
        force?: boolean;
        quality?: number;
        tileWidth?: number;
        tileHeight?: number;
        bitdepth?: 4 | 1 | 2 | 8;
        compression?: "jpeg" | "webp" | "none" | "deflate" | "packbits" | "ccittfax4" | "lzw" | "zstd" | "jp2k";
        bigtiff?: boolean;
        predictor?: "float" | "none" | "horizontal";
        pyramid?: boolean;
        tile?: boolean;
        xres?: number;
        yres?: number;
        miniswhite?: boolean;
        resolutionUnit?: "inch" | "cm";
    }, {
        force?: boolean;
        quality?: number;
        tileWidth?: number;
        tileHeight?: number;
        bitdepth?: 4 | 1 | 2 | 8;
        compression?: "jpeg" | "webp" | "none" | "deflate" | "packbits" | "ccittfax4" | "lzw" | "zstd" | "jp2k";
        bigtiff?: boolean;
        predictor?: "float" | "none" | "horizontal";
        pyramid?: boolean;
        tile?: boolean;
        xres?: number;
        yres?: number;
        miniswhite?: boolean;
        resolutionUnit?: "inch" | "cm";
    }>>;
    png: z.ZodOptional<z.ZodObject<{
        /** Force format output, otherwise attempt to use input format (optional, default true) */
        force: z.ZodOptional<z.ZodBoolean>;
    } & {
        /** Use progressive (interlace) scan (optional, default false) */
        progressive: z.ZodOptional<z.ZodBoolean>;
        /** zlib compression level, 0-9 (optional, default 6) */
        compressionLevel: z.ZodOptional<z.ZodNumber>;
        /** Use adaptive row filtering (optional, default false) */
        adaptiveFiltering: z.ZodOptional<z.ZodBoolean>;
        /** Use the lowest number of colours needed to achieve given quality (optional, default 100) */
        quality: z.ZodOptional<z.ZodNumber>;
        /** Level of CPU effort to reduce file size, between 1 (fastest) and 10 (slowest), sets palette to true (optional, default 7) */
        effort: z.ZodOptional<z.ZodNumber>;
        /** Quantise to a palette-based image with alpha transparency support (optional, default false) */
        palette: z.ZodOptional<z.ZodBoolean>;
        /** Maximum number of palette entries (optional, default 256) */
        colours: z.ZodOptional<z.ZodNumber>;
        /** Alternative Spelling of "colours". Maximum number of palette entries (optional, default 256) */
        colors: z.ZodOptional<z.ZodNumber>;
        /** Level of Floyd-Steinberg error diffusion (optional, default 1.0) */
        dither: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        force?: boolean;
        quality?: number;
        progressive?: boolean;
        effort?: number;
        colours?: number;
        colors?: number;
        dither?: number;
        compressionLevel?: number;
        adaptiveFiltering?: boolean;
        palette?: boolean;
    }, {
        force?: boolean;
        quality?: number;
        progressive?: boolean;
        effort?: number;
        colours?: number;
        colors?: number;
        dither?: number;
        compressionLevel?: number;
        adaptiveFiltering?: boolean;
        palette?: boolean;
    }>>;
}, "strip", z.ZodTypeAny, {
    jpeg?: {
        force?: boolean;
        quality?: number;
        progressive?: boolean;
        chromaSubsampling?: string;
        trellisQuantisation?: boolean;
        overshootDeringing?: boolean;
        optimiseScans?: boolean;
        optimizeScans?: boolean;
        optimiseCoding?: boolean;
        optimizeCoding?: boolean;
        quantisationTable?: number;
        quantizationTable?: number;
        mozjpeg?: boolean;
    };
    webp?: {
        force?: boolean;
        loop?: number;
        delay?: number | number[];
        quality?: number;
        lossless?: boolean;
        effort?: number;
        alphaQuality?: number;
        nearLossless?: boolean;
        smartSubsample?: boolean;
        smartDeblock?: boolean;
        minSize?: boolean;
        mixed?: boolean;
        preset?: "default" | "photo" | "picture" | "drawing" | "icon" | "text";
    };
    avif?: {
        force?: boolean;
        quality?: number;
        chromaSubsampling?: string;
        lossless?: boolean;
        effort?: number;
        bitdepth?: 8 | 10 | 12;
    };
    png?: {
        force?: boolean;
        quality?: number;
        progressive?: boolean;
        effort?: number;
        colours?: number;
        colors?: number;
        dither?: number;
        compressionLevel?: number;
        adaptiveFiltering?: boolean;
        palette?: boolean;
    };
    jp2?: {
        force?: boolean;
        quality?: number;
        chromaSubsampling?: "4:4:4" | "4:2:0";
        lossless?: boolean;
        tileWidth?: number;
        tileHeight?: number;
    };
    jxl?: {
        force?: boolean;
        quality?: number;
        lossless?: boolean;
        distance?: number;
        decodingTier?: number;
        effort?: number;
    };
    heif?: {
        force?: boolean;
        quality?: number;
        chromaSubsampling?: string;
        lossless?: boolean;
        effort?: number;
        bitdepth?: 8 | 10 | 12;
        compression?: "av1" | "hevc";
    };
    gif?: {
        force?: boolean;
        loop?: number;
        delay?: number | number[];
        progressive?: boolean;
        effort?: number;
        reuse?: boolean;
        colours?: number;
        colors?: number;
        dither?: number;
        interFrameMaxError?: number;
        interPaletteMaxError?: number;
        keepDuplicateFrames?: boolean;
    };
    tiff?: {
        force?: boolean;
        quality?: number;
        tileWidth?: number;
        tileHeight?: number;
        bitdepth?: 4 | 1 | 2 | 8;
        compression?: "jpeg" | "webp" | "none" | "deflate" | "packbits" | "ccittfax4" | "lzw" | "zstd" | "jp2k";
        bigtiff?: boolean;
        predictor?: "float" | "none" | "horizontal";
        pyramid?: boolean;
        tile?: boolean;
        xres?: number;
        yres?: number;
        miniswhite?: boolean;
        resolutionUnit?: "inch" | "cm";
    };
}, {
    jpeg?: {
        force?: boolean;
        quality?: number;
        progressive?: boolean;
        chromaSubsampling?: string;
        trellisQuantisation?: boolean;
        overshootDeringing?: boolean;
        optimiseScans?: boolean;
        optimizeScans?: boolean;
        optimiseCoding?: boolean;
        optimizeCoding?: boolean;
        quantisationTable?: number;
        quantizationTable?: number;
        mozjpeg?: boolean;
    };
    webp?: {
        force?: boolean;
        loop?: number;
        delay?: number | number[];
        quality?: number;
        lossless?: boolean;
        effort?: number;
        alphaQuality?: number;
        nearLossless?: boolean;
        smartSubsample?: boolean;
        smartDeblock?: boolean;
        minSize?: boolean;
        mixed?: boolean;
        preset?: "default" | "photo" | "picture" | "drawing" | "icon" | "text";
    };
    avif?: {
        force?: boolean;
        quality?: number;
        chromaSubsampling?: string;
        lossless?: boolean;
        effort?: number;
        bitdepth?: 8 | 10 | 12;
    };
    png?: {
        force?: boolean;
        quality?: number;
        progressive?: boolean;
        effort?: number;
        colours?: number;
        colors?: number;
        dither?: number;
        compressionLevel?: number;
        adaptiveFiltering?: boolean;
        palette?: boolean;
    };
    jp2?: {
        force?: boolean;
        quality?: number;
        chromaSubsampling?: "4:4:4" | "4:2:0";
        lossless?: boolean;
        tileWidth?: number;
        tileHeight?: number;
    };
    jxl?: {
        force?: boolean;
        quality?: number;
        lossless?: boolean;
        distance?: number;
        decodingTier?: number;
        effort?: number;
    };
    heif?: {
        force?: boolean;
        quality?: number;
        chromaSubsampling?: string;
        lossless?: boolean;
        effort?: number;
        bitdepth?: 8 | 10 | 12;
        compression?: "av1" | "hevc";
    };
    gif?: {
        force?: boolean;
        loop?: number;
        delay?: number | number[];
        progressive?: boolean;
        effort?: number;
        reuse?: boolean;
        colours?: number;
        colors?: number;
        dither?: number;
        interFrameMaxError?: number;
        interPaletteMaxError?: number;
        keepDuplicateFrames?: boolean;
    };
    tiff?: {
        force?: boolean;
        quality?: number;
        tileWidth?: number;
        tileHeight?: number;
        bitdepth?: 4 | 1 | 2 | 8;
        compression?: "jpeg" | "webp" | "none" | "deflate" | "packbits" | "ccittfax4" | "lzw" | "zstd" | "jp2k";
        bigtiff?: boolean;
        predictor?: "float" | "none" | "horizontal";
        pyramid?: boolean;
        tile?: boolean;
        xres?: number;
        yres?: number;
        miniswhite?: boolean;
        resolutionUnit?: "inch" | "cm";
    };
}>;
export type JpegOptions = z.infer<typeof jpegOptionsSchema>;
export type Jp2Options = z.infer<typeof jp2OptionsSchema>;
export type JxlOptions = z.infer<typeof jxlOptionsSchema>;
export type WebpOptions = z.infer<typeof webpOptionsSchema>;
export type AvifOptions = z.infer<typeof avifOptionsSchema>;
export type HeifOptions = z.infer<typeof heifOptionsSchema>;
export type GifOptions = z.infer<typeof gifOptionsSchema>;
export type TiffOptions = z.infer<typeof tiffOptionsSchema>;
export type PngOptions = z.infer<typeof pngOptionsSchema>;
export type FormatOptions = z.infer<typeof formatOptionsSchema>;
export type ImageFormatOptions = JpegOptions | Jp2Options | JxlOptions | WebpOptions | AvifOptions | HeifOptions | GifOptions | TiffOptions | PngOptions;