@depup/nestjs__common 11.1.16-depup.1

package/module-utils/configurable-module.builder.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigurableModuleBuilder = void 0;
+const logger_service_1 = require("../services/logger.service");
+const random_string_generator_util_1 = require("../utils/random-string-generator.util");
+const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+/**
+ * Factory that lets you create configurable modules and
+ * provides a way to reduce the majority of dynamic module boilerplate.
+ *
+ * @publicApi
+ */
+class ConfigurableModuleBuilder {
+    constructor(options = {}, parentBuilder) {
+        this.options = options;
+        this.logger = new logger_service_1.Logger(ConfigurableModuleBuilder.name);
+        if (parentBuilder) {
+            this.staticMethodKey = parentBuilder.staticMethodKey;
+            this.factoryClassMethodKey =
+                parentBuilder.factoryClassMethodKey;
+            this.transformModuleDefinition =
+                parentBuilder.transformModuleDefinition;
+            this.extras = parentBuilder.extras;
+        }
+    }
+    /**
+     * Registers the "extras" object (a set of extra options that can be used to modify the dynamic module definition).
+     * Values you specify within the "extras" object will be used as default values (that can be overridden by module consumers).
+     *
+     * This method also applies the so-called "module definition transform function" that takes the auto-generated
+     * dynamic module object ("DynamicModule") and the actual consumer "extras" object as input parameters.
+     * The "extras" object consists of values explicitly specified by module consumers and default values.
+     *
+     * @example
+     * ```typescript
+     * .setExtras<{ isGlobal?: boolean }>({ isGlobal: false }, (definition, extras) =>
+     *    ({ ...definition, global: extras.isGlobal })
+     * )
+     * ```
+     */
+    setExtras(extras, transformDefinition = def => def) {
+        const builder = new ConfigurableModuleBuilder(this.options, this);
+        builder.extras = extras;
+        builder.transformModuleDefinition = transformDefinition;
+        return builder;
+    }
+    /**
+     * Dynamic modules must expose public static methods that let you pass in
+     * configuration parameters (control the module's behavior from the outside).
+     * Some frequently used names that you may have seen in other modules are:
+     * "forRoot", "forFeature", "register", "configure".
+     *
+     * This method "setClassMethodName" lets you specify the name of the
+     * method that will be auto-generated.
+     *
+     * @param key name of the method
+     */
+    setClassMethodName(key) {
+        const builder = new ConfigurableModuleBuilder(this.options, this);
+        builder.staticMethodKey = key;
+        return builder;
+    }
+    /**
+     * Asynchronously configured modules (that rely on other modules, i.e. "ConfigModule")
+     * let you pass the configuration factory class that will be registered and instantiated as a provider.
+     * This provider then will be used to retrieve the module's configuration. To provide the configuration,
+     * the corresponding factory method must be implemented.
+     *
+     * This method ("setFactoryMethodName") lets you control what method name will have to be
+     * implemented by the config factory (default is "create").
+     *
+     * @param key name of the method
+     */
+    setFactoryMethodName(key) {
+        const builder = new ConfigurableModuleBuilder(this.options, this);
+        builder.factoryClassMethodKey = key;
+        return builder;
+    }
+    /**
+     * Returns an object consisting of multiple properties that lets you
+     * easily construct dynamic configurable modules. See "ConfigurableModuleHost" interface for more details.
+     */
+    build() {
+        this.staticMethodKey ??= constants_1.DEFAULT_METHOD_KEY;
+        this.factoryClassMethodKey ??=
+            constants_1.DEFAULT_FACTORY_CLASS_METHOD_KEY;
+        this.options.optionsInjectionToken ??= this.options.moduleName
+            ? this.constructInjectionTokenString()
+            : (0, utils_1.generateOptionsInjectionToken)();
+        this.transformModuleDefinition ??= definition => definition;
+        return {
+            ConfigurableModuleClass: this.createConfigurableModuleCls(),
+            MODULE_OPTIONS_TOKEN: this.options.optionsInjectionToken,
+            ASYNC_OPTIONS_TYPE: this.createTypeProxy('ASYNC_OPTIONS_TYPE'),
+            OPTIONS_TYPE: this.createTypeProxy('OPTIONS_TYPE'),
+        };
+    }
+    constructInjectionTokenString() {
+        const moduleNameInSnakeCase = this.options
+            .moduleName.trim()
+            .split(/(?=[A-Z])/)
+            .join('_')
+            .toUpperCase();
+        return `${moduleNameInSnakeCase}_MODULE_OPTIONS`;
+    }
+    createConfigurableModuleCls() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        const asyncMethodKey = this.staticMethodKey + constants_1.ASYNC_METHOD_SUFFIX;
+        class InternalModuleClass {
+            static [self.staticMethodKey](options) {
+                const providers = [
+                    {
+                        provide: self.options.optionsInjectionToken,
+                        useValue: this.omitExtras(options, self.extras),
+                    },
+                ];
+                if (self.options.alwaysTransient) {
+                    providers.push({
+                        provide: constants_1.CONFIGURABLE_MODULE_ID,
+                        useValue: (0, random_string_generator_util_1.randomStringGenerator)(),
+                    });
+                }
+                return self.transformModuleDefinition({
+                    module: this,
+                    providers,
+                }, {
+                    ...self.extras,
+                    ...options,
+                });
+            }
+            static [asyncMethodKey](options) {
+                const providers = this.createAsyncProviders(options);
+                if (self.options.alwaysTransient) {
+                    providers.push({
+                        provide: constants_1.CONFIGURABLE_MODULE_ID,
+                        useValue: (0, random_string_generator_util_1.randomStringGenerator)(),
+                    });
+                }
+                return self.transformModuleDefinition({
+                    module: this,
+                    imports: options.imports || [],
+                    providers,
+                }, {
+                    ...self.extras,
+                    ...this.extractExtrasFromAsyncOptions(options, self.extras),
+                });
+            }
+            static omitExtras(input, extras) {
+                if (!extras) {
+                    return input;
+                }
+                const moduleOptions = {};
+                const extrasKeys = Object.keys(extras);
+                Object.keys(input)
+                    .filter(key => !extrasKeys.includes(key))
+                    .forEach(key => {
+                    moduleOptions[key] = input[key];
+                });
+                return moduleOptions;
+            }
+            static extractExtrasFromAsyncOptions(input, extras) {
+                if (!extras) {
+                    return {};
+                }
+                const extrasOptions = {};
+                Object.keys(input)
+                    .filter(key => !constants_1.ASYNC_OPTIONS_METADATA_KEYS.includes(key))
+                    .forEach(key => {
+                    extrasOptions[key] = input[key];
+                });
+                return extrasOptions;
+            }
+            static createAsyncProviders(options) {
+                if (options.useExisting || options.useFactory) {
+                    if (options.inject && options.provideInjectionTokensFrom) {
+                        return [
+                            this.createAsyncOptionsProvider(options),
+                            ...(0, utils_1.getInjectionProviders)(options.provideInjectionTokensFrom, options.inject),
+                        ];
+                    }
+                    return [this.createAsyncOptionsProvider(options)];
+                }
+                return [
+                    this.createAsyncOptionsProvider(options),
+                    {
+                        provide: options.useClass,
+                        useClass: options.useClass,
+                    },
+                ];
+            }
+            static createAsyncOptionsProvider(options) {
+                if (options.useFactory) {
+                    return {
+                        provide: self.options.optionsInjectionToken,
+                        useFactory: options.useFactory,
+                        inject: options.inject || [],
+                    };
+                }
+                return {
+                    provide: self.options.optionsInjectionToken,
+                    useFactory: async (optionsFactory) => await optionsFactory[self.factoryClassMethodKey](),
+                    inject: [options.useExisting || options.useClass],
+                };
+            }
+        }
+        return InternalModuleClass;
+    }
+    createTypeProxy(typeName) {
+        const proxy = new Proxy({}, {
+            get: () => {
+                throw new Error(`"${typeName}" is not supposed to be used as a value.`);
+            },
+        });
+        return proxy;
+    }
+}
+exports.ConfigurableModuleBuilder = ConfigurableModuleBuilder;

package/module-utils/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const DEFAULT_METHOD_KEY = "register";
+export declare const DEFAULT_FACTORY_CLASS_METHOD_KEY = "create";
+export declare const ASYNC_METHOD_SUFFIX = "Async";
+export declare const CONFIGURABLE_MODULE_ID = "CONFIGURABLE_MODULE_ID";
+/**
+ * List of keys that are specific to ConfigurableModuleAsyncOptions
+ * and should be excluded when extracting user-defined extras.
+ */
+export declare const ASYNC_OPTIONS_METADATA_KEYS: readonly ["useFactory", "useClass", "useExisting", "inject", "imports", "provideInjectionTokensFrom"];

package/module-utils/constants.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ASYNC_OPTIONS_METADATA_KEYS = exports.CONFIGURABLE_MODULE_ID = exports.ASYNC_METHOD_SUFFIX = exports.DEFAULT_FACTORY_CLASS_METHOD_KEY = exports.DEFAULT_METHOD_KEY = void 0;
+exports.DEFAULT_METHOD_KEY = 'register';
+exports.DEFAULT_FACTORY_CLASS_METHOD_KEY = 'create';
+exports.ASYNC_METHOD_SUFFIX = 'Async';
+exports.CONFIGURABLE_MODULE_ID = 'CONFIGURABLE_MODULE_ID';
+/**
+ * List of keys that are specific to ConfigurableModuleAsyncOptions
+ * and should be excluded when extracting user-defined extras.
+ */
+exports.ASYNC_OPTIONS_METADATA_KEYS = [
+    'useFactory',
+    'useClass',
+    'useExisting',
+    'inject',
+    'imports',
+    'provideInjectionTokensFrom',
+];

package/module-utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './configurable-module.builder';
+export * from './interfaces';

package/module-utils/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./configurable-module.builder"), exports);
+tslib_1.__exportStar(require("./interfaces"), exports);

package/module-utils/interfaces/configurable-module-async-options.interface.d.ts

@@ -0,0 +1,42 @@
+import { FactoryProvider, ModuleMetadata, Provider, Type } from '../../interfaces';
+import { DEFAULT_FACTORY_CLASS_METHOD_KEY } from '../constants';
+/**
+ * Interface that must be implemented by the module options factory class.
+ * Method key varies depending on the "FactoryClassMethodKey" type argument.
+ *
+ * @publicApi
+ */
+export type ConfigurableModuleOptionsFactory<ModuleOptions, FactoryClassMethodKey extends string> = Record<`${FactoryClassMethodKey}`, () => Promise<ModuleOptions> | ModuleOptions>;
+/**
+ * Interface that represents the module async options object
+ * Factory method name varies depending on the "FactoryClassMethodKey" type argument.
+ *
+ * @publicApi
+ */
+export interface ConfigurableModuleAsyncOptions<ModuleOptions, FactoryClassMethodKey extends string = typeof DEFAULT_FACTORY_CLASS_METHOD_KEY> extends Pick<ModuleMetadata, 'imports'> {
+    /**
+     * Injection token resolving to an existing provider. The provider must implement
+     * the corresponding interface.
+     */
+    useExisting?: Type<ConfigurableModuleOptionsFactory<ModuleOptions, FactoryClassMethodKey>>;
+    /**
+     * Injection token resolving to a class that will be instantiated as a provider.
+     * The class must implement the corresponding interface.
+     */
+    useClass?: Type<ConfigurableModuleOptionsFactory<ModuleOptions, FactoryClassMethodKey>>;
+    /**
+     * Function returning options (or a Promise resolving to options) to configure the
+     * module.
+     */
+    useFactory?: (...args: any[]) => Promise<ModuleOptions> | ModuleOptions;
+    /**
+     * Dependencies that a Factory may inject.
+     */
+    inject?: FactoryProvider['inject'];
+    /**
+     * List of parent module's providers that will be filtered to only provide necessary
+     * providers for the 'inject' array
+     * useful to pass options to nested async modules
+     */
+    provideInjectionTokensFrom?: Provider[];
+}

package/module-utils/interfaces/configurable-module-async-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/module-utils/interfaces/configurable-module-cls.interface.d.ts

@@ -0,0 +1,13 @@
+import { DynamicModule } from '../../interfaces';
+import { DEFAULT_FACTORY_CLASS_METHOD_KEY, DEFAULT_METHOD_KEY } from '../constants';
+import { ConfigurableModuleAsyncOptions } from './configurable-module-async-options.interface';
+/**
+ * Class that represents a blueprint/prototype for a configurable Nest module.
+ * This class provides static methods for constructing dynamic modules. Their names
+ * can be controlled through the "MethodKey" type argument.
+ *
+ * @publicApi
+ */
+export type ConfigurableModuleCls<ModuleOptions, MethodKey extends string = typeof DEFAULT_METHOD_KEY, FactoryClassMethodKey extends string = typeof DEFAULT_FACTORY_CLASS_METHOD_KEY, ExtraModuleDefinitionOptions = {}> = {
+    new (): any;
+} & Record<`${MethodKey}`, (options: ModuleOptions & Partial<ExtraModuleDefinitionOptions>) => DynamicModule> & Record<`${MethodKey}Async`, (options: ConfigurableModuleAsyncOptions<ModuleOptions, FactoryClassMethodKey> & Partial<ExtraModuleDefinitionOptions>) => DynamicModule>;

package/module-utils/interfaces/configurable-module-cls.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/module-utils/interfaces/configurable-module-host.interface.d.ts

@@ -0,0 +1,62 @@
+import { ConfigurableModuleAsyncOptions } from './configurable-module-async-options.interface';
+import { ConfigurableModuleCls } from './configurable-module-cls.interface';
+/**
+ * Configurable module host. See properties for more details
+ *
+ * @publicApi
+ */
+export interface ConfigurableModuleHost<ModuleOptions = Record<string, unknown>, MethodKey extends string = string, FactoryClassMethodKey extends string = string, ExtraModuleDefinitionOptions = {}> {
+    /**
+     * Class that represents a blueprint/prototype for a configurable Nest module.
+     * This class provides static methods for constructing dynamic modules. Their names
+     * can be controlled through the "MethodKey" type argument.
+     *
+     * Your module class should inherit from this class to make the static methods available.
+     *
+     * @example
+     * ```typescript
+     * @Module({})
+     * class IntegrationModule extends ConfigurableModuleCls {
+     *  // ...
+     * }
+     * ```
+     */
+    ConfigurableModuleClass: ConfigurableModuleCls<ModuleOptions, MethodKey, FactoryClassMethodKey, ExtraModuleDefinitionOptions>;
+    /**
+     * Module options provider token. Can be used to inject the "options object" to
+     * providers registered within the host module.
+     */
+    MODULE_OPTIONS_TOKEN: string | symbol;
+    /**
+     * Can be used to auto-infer the compound "async module options" type.
+     * Note: this property is not supposed to be used as a value.
+     *
+     * @example
+     * ```typescript
+     * @Module({})
+     * class IntegrationModule extends ConfigurableModuleCls {
+     *  static module = initializer(IntegrationModule);
+     *
+     * static registerAsync(options: typeof ASYNC_OPTIONS_TYPE): DynamicModule {
+     *  return super.registerAsync(options);
+     * }
+     * ```
+     */
+    ASYNC_OPTIONS_TYPE: ConfigurableModuleAsyncOptions<ModuleOptions, FactoryClassMethodKey> & Partial<ExtraModuleDefinitionOptions>;
+    /**
+     * Can be used to auto-infer the compound "module options" type (options interface + extra module definition options).
+     * Note: this property is not supposed to be used as a value.
+     *
+     * @example
+     * ```typescript
+     * @Module({})
+     * class IntegrationModule extends ConfigurableModuleCls {
+     *  static module = initializer(IntegrationModule);
+     *
+     * static register(options: typeof OPTIONS_TYPE): DynamicModule {
+     *  return super.register(options);
+     * }
+     * ```
+     */
+    OPTIONS_TYPE: ModuleOptions & Partial<ExtraModuleDefinitionOptions>;
+}

package/module-utils/interfaces/configurable-module-host.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/module-utils/interfaces/index.d.ts

@@ -0,0 +1,3 @@
+export * from './configurable-module-async-options.interface';
+export * from './configurable-module-cls.interface';
+export * from './configurable-module-host.interface';

package/module-utils/interfaces/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./configurable-module-async-options.interface"), exports);
+tslib_1.__exportStar(require("./configurable-module-cls.interface"), exports);
+tslib_1.__exportStar(require("./configurable-module-host.interface"), exports);

package/module-utils/utils/generate-options-injection-token.util.d.ts

@@ -0,0 +1 @@
+export declare function generateOptionsInjectionToken(): string;

package/module-utils/utils/generate-options-injection-token.util.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateOptionsInjectionToken = generateOptionsInjectionToken;
+const random_string_generator_util_1 = require("../../utils/random-string-generator.util");
+function generateOptionsInjectionToken() {
+    const hash = (0, random_string_generator_util_1.randomStringGenerator)();
+    return `CONFIGURABLE_MODULE_OPTIONS[${hash}]`;
+}

package/module-utils/utils/get-injection-providers.util.d.ts

@@ -0,0 +1,8 @@
+import { FactoryProvider, Provider } from '../../interfaces';
+/**
+ *
+ * @param providers List of a module's providers
+ * @param tokens Injection tokens needed for a useFactory function (usually the module's options' token)
+ * @returns All the providers needed for the tokens' injection (searched recursively)
+ */
+export declare function getInjectionProviders(providers: Provider[], tokens: FactoryProvider['inject']): Provider[];

package/module-utils/utils/get-injection-providers.util.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInjectionProviders = getInjectionProviders;
+const shared_utils_1 = require("../../utils/shared.utils");
+/**
+ * @param value
+ * @returns `true` if value is `OptionalFactoryDependency`
+ */
+function isOptionalFactoryDependency(value) {
+    return (!(0, shared_utils_1.isUndefined)(value.token) &&
+        !(0, shared_utils_1.isUndefined)(value.optional) &&
+        !value.prototype);
+}
+const mapInjectToTokens = (t) => isOptionalFactoryDependency(t) ? t.token : t;
+/**
+ *
+ * @param providers List of a module's providers
+ * @param tokens Injection tokens needed for a useFactory function (usually the module's options' token)
+ * @returns All the providers needed for the tokens' injection (searched recursively)
+ */
+function getInjectionProviders(providers, tokens) {
+    const result = [];
+    let search = tokens.map(mapInjectToTokens);
+    while (search.length > 0) {
+        const match = (providers ?? []).filter(p => !result.includes(p) && // this prevents circular loops and duplication
+            (search.includes(p) || search.includes(p?.provide)));
+        result.push(...match);
+        // get injection tokens of the matched providers, if any
+        search = match
+            .filter(p => p?.inject)
+            .flatMap(p => p.inject)
+            .map(mapInjectToTokens);
+    }
+    return result;
+}

package/module-utils/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './generate-options-injection-token.util';
+export * from './get-injection-providers.util';

package/module-utils/utils/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./generate-options-injection-token.util"), exports);
+tslib_1.__exportStar(require("./get-injection-providers.util"), exports);

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@depup/nestjs__common",
+  "version": "11.1.16-depup.1",
+  "description": "[DepUp] Nest - modern, fast, powerful node.js web framework (@common)",
+  "author": "Kamil Mysliwiec",
+  "homepage": "https://nestjs.com",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/nest"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nestjs/nest.git",
+    "directory": "packages/common"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "file-type": "^21.3.1",
+    "iterare": "1.2.1",
+    "load-esm": "1.0.3",
+    "tslib": "2.8.1",
+    "uid": "2.0.2"
+  },
+  "peerDependencies": {
+    "class-transformer": ">=0.4.1",
+    "class-validator": ">=0.13.2",
+    "reflect-metadata": "^0.1.12 || ^0.2.0",
+    "rxjs": "^7.1.0"
+  },
+  "peerDependenciesMeta": {
+    "class-validator": {
+      "optional": true
+    },
+    "class-transformer": {
+      "optional": true
+    }
+  },
+  "gitHead": "315e698096208868b43dda25f2db9ac9d7c1d822",
+  "keywords": [
+    "depup",
+    "dependency-bumped",
+    "updated-deps",
+    "@nestjs/common"
+  ],
+  "depup": {
+    "changes": {
+      "file-type": {
+        "from": "21.3.0",
+        "to": "^21.3.1"
+      }
+    },
+    "depsUpdated": 1,
+    "originalPackage": "@nestjs/common",
+    "originalVersion": "11.1.16",
+    "processedAt": "2026-03-09T21:01:51.396Z",
+    "smokeTest": "passed"
+  }
+}

package/pipes/default-value.pipe.d.ts

@@ -0,0 +1,13 @@
+import { ArgumentMetadata, PipeTransform } from '../interfaces/features/pipe-transform.interface';
+/**
+ * Defines the built-in DefaultValue Pipe
+ *
+ * @see [Built-in Pipes](https://docs.nestjs.com/pipes#built-in-pipes)
+ *
+ * @publicApi
+ */
+export declare class DefaultValuePipe<T = any, R = any> implements PipeTransform<T, T | R> {
+    protected readonly defaultValue: R;
+    constructor(defaultValue: R);
+    transform(value?: T, _metadata?: ArgumentMetadata): T | R;
+}

package/pipes/default-value.pipe.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultValuePipe = void 0;
+const tslib_1 = require("tslib");
+const injectable_decorator_1 = require("../decorators/core/injectable.decorator");
+const shared_utils_1 = require("../utils/shared.utils");
+/**
+ * Defines the built-in DefaultValue Pipe
+ *
+ * @see [Built-in Pipes](https://docs.nestjs.com/pipes#built-in-pipes)
+ *
+ * @publicApi
+ */
+let DefaultValuePipe = class DefaultValuePipe {
+    constructor(defaultValue) {
+        this.defaultValue = defaultValue;
+    }
+    transform(value, _metadata) {
+        if ((0, shared_utils_1.isNil)(value) ||
+            ((0, shared_utils_1.isNumber)(value) && isNaN(value))) {
+            return this.defaultValue;
+        }
+        return value;
+    }
+};
+exports.DefaultValuePipe = DefaultValuePipe;
+exports.DefaultValuePipe = DefaultValuePipe = tslib_1.__decorate([
+    (0, injectable_decorator_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], DefaultValuePipe);

package/pipes/file/file-type.validator.d.ts

@@ -0,0 +1,62 @@
+import { FileValidatorContext } from './file-validator-context.interface';
+import { FileValidator } from './file-validator.interface';
+import { IFile } from './interfaces';
+type FileTypeValidatorContext = FileValidatorContext<Omit<FileTypeValidatorOptions, 'errorMessage'>>;
+export type FileTypeValidatorOptions = {
+    /**
+     * Expected file type(s) for validation. Can be a string (MIME type)
+     * or a regular expression to match multiple types.
+     *
+     * @example
+     * // Match a single MIME type
+     * fileType: 'image/png'
+     *
+     * @example
+     * // Match multiple types using RegExp
+     * fileType: /^image\/(png|jpeg)$/
+     */
+    fileType: string | RegExp;
+    /**
+     * Custom error message displayed when file type validation fails
+     * Can be provided as a static string, or as a factory function
+     * that receives the validation context (file and validator configuration)
+     * and returns a dynamic error message.
+     *
+     * @example
+     * // Static message
+     * new FileTypeValidator({ fileType: 'image/png', errorMessage: 'Only PNG allowed' })
+     *
+     * @example
+     * // Dynamic message based on file object and validator configuration
+     * new FileTypeValidator({
+     *   fileType: 'image/png',
+     *   errorMessage: ctx => `Received file type '${ctx.file?.mimetype}', but expected '${ctx.config.fileType}'`
+     * })
+     */
+    errorMessage?: string | ((ctx: FileTypeValidatorContext) => string);
+    /**
+     * If `true`, the validator will skip the magic numbers validation.
+     * This can be useful when you can't identify some files as there are no common magic numbers available for some file types.
+     * @default false
+     */
+    skipMagicNumbersValidation?: boolean;
+    /**
+     * If `true`, and magic number check fails, fallback to mimetype comparison.
+     * @default false
+     */
+    fallbackToMimetype?: boolean;
+};
+/**
+ * Defines the built-in FileTypeValidator. It validates incoming files by examining
+ * their magic numbers using the file-type package, providing more reliable file type validation
+ * than just checking the mimetype string.
+ *
+ * @see [File Validators](https://docs.nestjs.com/techniques/file-upload#validators)
+ *
+ * @publicApi
+ */
+export declare class FileTypeValidator extends FileValidator<FileTypeValidatorOptions, IFile> {
+    buildErrorMessage(file?: IFile): string;
+    isValid(file?: IFile): Promise<boolean>;
+}
+export {};