copy-webpack-plugin

type AdditionalOptions = {
    concurrency?: number | undefined;
};

type Asset = import('webpack').Asset;

type CacheFacade = ReturnType<Compilation['getCache']>;

type Compilation = import('webpack').Compilation;

type Compiler = import('webpack').Compiler;

type Context = string;

type CopiedResult = {
    sourceFilename: string;
    absoluteFilename: string;
    filename: string;
    source: Asset['source'];
    force: Force | undefined;
    info: Record<string, any>;
};

type Etag = ReturnType<ReturnType<Compilation['getCache']>['getLazyHashedEtag']>;

type Filter = (filepath: string) => boolean | Promise<boolean>;

type Force = boolean;

type From = string;

type GlobbyOptions = import('globby').Options;

type GlobEntry = import('globby').GlobEntry;

type Info =
    | Record<string, any>
    | ((item: {
          absoluteFilename: string;
          sourceFilename: string;
          filename: string;
          toType: ToType;
      }) => Record<string, any>);

type NoErrorOnMissing = boolean;

type ObjectPattern = {
    from: From;
    globOptions?: import('globby').Options | undefined;
    context?: string | undefined;
    to?: To | undefined;
    toType?: ToType | undefined;
    info?: Info | undefined;
    filter?: Filter | undefined;
    transform?: Transform | undefined;
    transformAll?: TransformAllFunction | undefined;
    force?: boolean | undefined;
    priority?: number | undefined;
    noErrorOnMissing?: boolean | undefined;
};

type Pattern = StringPattern | ObjectPattern;

type PluginOptions = {
    patterns: Pattern[];
    options?: AdditionalOptions | undefined;
};

type Schema = import('schema-utils/declarations/validate').Schema;

type Snapshot = ReturnType<Compilation['fileSystemInfo']['mergeSnapshots']>;

type StringPattern = string;

type To = string | ToFunction;

type ToFunction = (pathData: {
    context: string;
    absoluteFilename?: string;
}) => string | Promise<string>;

type ToType = 'dir' | 'file' | 'template';

type Transform = TransformerFunction | TransformerObject;

type TransformAllFunction = (
    data: {
        data: Buffer;
        sourceFilename: string;
        absoluteFilename: string;
    }[]
) => string | Buffer | Promise<string> | Promise<Buffer>;

type TransformerCacheObject =
    | {
          keys: {
              [key: string]: any;
          };
      }
    | {
          keys: (
              defaultCacheKeys: {
                  [key: string]: any;
              },
              absoluteFilename: string
          ) => Promise<{
              [key: string]: any;
          }>;
      };

type TransformerFunction = (
    input: Buffer,
    absoluteFilename: string
) => string | Buffer | Promise<string> | Promise<Buffer>;

type TransformerObject = {
    transformer: TransformerFunction;
    cache?: boolean | TransformerCacheObject | undefined;
};

type WebpackError = import('webpack').WebpackError;

type WebpackLogger = ReturnType<Compilation['getLogger']>;