import { Plugin } from 'vite';
import { InputType, ZlibOptions, BrotliOptions } from 'zlib';
import { FilterPattern } from '@rollup/pluginutils';

type Algorithm = 'gzip' | 'brotliCompress' | 'deflate' | 'deflateRaw';
interface UserCompressionOptions {
    [key: string]: any;
}
type InferDefault<T> = T extends infer K ? K : UserCompressionOptions;
type CompressionOptions<T> = InferDefault<T>;
type Pretty<T> = {
    [key in keyof T]: T[key];
} & NonNullable<unknown>;
interface BaseCompressionPluginOptions {
    include?: FilterPattern;
    exclude?: FilterPattern;
    threshold?: number;
    filename?: string | ((id: string) => string);
    deleteOriginalAssets?: boolean;
    skipIfLargerOrEqual?: boolean;
}
interface AlgorithmToZlib {
    gzip: ZlibOptions;
    brotliCompress: BrotliOptions;
    deflate: ZlibOptions;
    deflateRaw: ZlibOptions;
}
type AlgorithmFunction<T extends UserCompressionOptions> = (buf: InputType, options: T) => Promise<Buffer>;
type InternalCompressionPluginOptionsFunction<T, A extends AlgorithmFunction<T>> = {
    algorithm?: A;
    compressionOptions: T;
};
type InternalWithoutCompressionPluginOptionsFunction = {
    algorithm?: AlgorithmFunction<undefined>;
};
type InternalCompressionPluginOptionsAlgorithm<A extends Algorithm> = {
    algorithm?: A;
    compressionOptions?: Pretty<AlgorithmToZlib[A]>;
};
type ViteCompressionPluginConfigFunction<T extends UserCompressionOptions, A extends AlgorithmFunction<T>> = BaseCompressionPluginOptions & InternalCompressionPluginOptionsFunction<T, A>;
type ViteWithoutCompressionPluginConfigFunction = Pretty<BaseCompressionPluginOptions & InternalWithoutCompressionPluginOptionsFunction>;
type ViteCompressionPluginConfigAlgorithm<A extends Algorithm> = BaseCompressionPluginOptions & InternalCompressionPluginOptionsAlgorithm<A>;
type ViteCompressionPluginConfig<T, A extends Algorithm> = ViteCompressionPluginConfigFunction<T, AlgorithmFunction<T>> | ViteCompressionPluginConfigAlgorithm<A>;
type ViteCompressionPluginOption<A extends Algorithm | UserCompressionOptions | undefined = undefined> = A extends undefined ? Pretty<ViteWithoutCompressionPluginConfigFunction> : A extends Algorithm ? Pretty<ViteCompressionPluginConfigAlgorithm<A>> : A extends UserCompressionOptions ? Pretty<ViteCompressionPluginConfigFunction<A, AlgorithmFunction<A>>> : never;
interface ViteTarballPluginOptions {
    dest?: string;
    gz?: boolean;
}

interface CompressionPluginAPI {
    staticOutputs: Set<string>;
}
declare function tarball(opts?: ViteTarballPluginOptions): Plugin;
declare function compression(): Plugin;
declare function compression<T extends UserCompressionOptions | undefined, A extends Algorithm | AlgorithmFunction<T> | AlgorithmFunction<undefined>>(opts: A extends Algorithm ? Pretty<ViteCompressionPluginConfigAlgorithm<A>> : ViteCompressionPluginConfigFunction<T, AlgorithmFunction<T>>): Plugin;
declare function compression<T extends UserCompressionOptions>(opts: ViteCompressionPluginConfigFunction<T, AlgorithmFunction<T>>): Plugin;
declare function compression(opts: ViteWithoutCompressionPluginConfigFunction): Plugin;
declare namespace compression {
    var getPluginAPI: (plugins: readonly Plugin[]) => CompressionPluginAPI | undefined;
}
declare function defineCompressionOption<T = never, A extends Algorithm = never>(option: ViteCompressionPluginConfig<T, A>): ViteCompressionPluginConfig<T, A>;

export { type Algorithm, type CompressionOptions, type ViteCompressionPluginConfig, type ViteCompressionPluginOption, type ViteTarballPluginOptions, compression, compression as default, defineCompressionOption, tarball };