@depup/nestjs__common 11.1.16-depup.1

package/file-stream/streamable-file.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamableFile = void 0;
+const stream_1 = require("stream");
+const util_1 = require("util");
+const enums_1 = require("../enums");
+const services_1 = require("../services");
+const shared_utils_1 = require("../utils/shared.utils");
+/**
+ * @see [Streaming files](https://docs.nestjs.com/techniques/streaming-files)
+ *
+ * @publicApi
+ */
+class StreamableFile {
+    constructor(bufferOrReadStream, options = {}) {
+        this.options = options;
+        this.logger = new services_1.Logger('StreamableFile');
+        this.handleError = (err, res) => {
+            if (res.destroyed) {
+                return;
+            }
+            if (res.headersSent) {
+                res.end();
+                return;
+            }
+            res.statusCode = enums_1.HttpStatus.BAD_REQUEST;
+            res.send(err.message);
+        };
+        this.logError = (err) => {
+            this.logger.error(err);
+        };
+        if (util_1.types.isUint8Array(bufferOrReadStream)) {
+            this.stream = new stream_1.Readable();
+            this.stream.push(bufferOrReadStream);
+            this.stream.push(null);
+            this.options.length ??= bufferOrReadStream.length;
+        }
+        else if (bufferOrReadStream.pipe && (0, shared_utils_1.isFunction)(bufferOrReadStream.pipe)) {
+            this.stream = bufferOrReadStream;
+        }
+    }
+    getStream() {
+        return this.stream;
+    }
+    getHeaders() {
+        const { type = 'application/octet-stream', disposition = undefined, length = undefined, } = this.options;
+        return {
+            type,
+            disposition,
+            length,
+        };
+    }
+    get errorHandler() {
+        return this.handleError;
+    }
+    setErrorHandler(handler) {
+        this.handleError = handler;
+        return this;
+    }
+    get errorLogger() {
+        return this.logError;
+    }
+    setErrorLogger(handler) {
+        this.logError = handler;
+        return this;
+    }
+}
+exports.StreamableFile = StreamableFile;

package/index.d.ts

@@ -0,0 +1,11 @@
+import 'reflect-metadata';
+export * from './decorators';
+export * from './enums';
+export * from './exceptions';
+export * from './file-stream';
+export { Abstract, ArgumentMetadata, ArgumentsHost, BeforeApplicationShutdown, CallHandler, CanActivate, ClassProvider, ContextType, DynamicModule, ExceptionFilter, ExecutionContext, ExistingProvider, FactoryProvider, ForwardReference, HttpServer, HttpExceptionBody, HttpExceptionBodyMessage, HttpRedirectResponse, INestApplication, INestApplicationContext, INestMicroservice, InjectionToken, IntrospectionResult, MessageEvent, MiddlewareConsumer, ModuleMetadata, NestApplicationOptions, NestHybridApplicationOptions, NestInterceptor, NestMiddleware, NestModule, OnApplicationBootstrap, OnApplicationShutdown, OnModuleDestroy, OnModuleInit, OptionalFactoryDependency, Paramtype, PipeTransform, Provider, RawBodyRequest, RpcExceptionFilter, Scope, ScopeOptions, Type, ValidationError, ValueProvider, VersioningOptions, VERSION_NEUTRAL, WebSocketAdapter, WsExceptionFilter, WsMessageHandler, } from './interfaces';
+export * from './module-utils';
+export * from './pipes';
+export * from './serializer';
+export * from './services';
+export * from './utils';

package/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION_NEUTRAL = exports.Scope = void 0;
+const tslib_1 = require("tslib");
+/*
+ * Nest @common
+ * Copyright(c) 2017 - 2025 Kamil Mysliwiec
+ * https://nestjs.com
+ * MIT Licensed
+ */
+require("reflect-metadata");
+tslib_1.__exportStar(require("./decorators"), exports);
+tslib_1.__exportStar(require("./enums"), exports);
+tslib_1.__exportStar(require("./exceptions"), exports);
+tslib_1.__exportStar(require("./file-stream"), exports);
+var interfaces_1 = require("./interfaces");
+Object.defineProperty(exports, "Scope", { enumerable: true, get: function () { return interfaces_1.Scope; } });
+Object.defineProperty(exports, "VERSION_NEUTRAL", { enumerable: true, get: function () { return interfaces_1.VERSION_NEUTRAL; } });
+tslib_1.__exportStar(require("./module-utils"), exports);
+tslib_1.__exportStar(require("./pipes"), exports);
+tslib_1.__exportStar(require("./serializer"), exports);
+tslib_1.__exportStar(require("./services"), exports);
+tslib_1.__exportStar(require("./utils"), exports);

package/interfaces/abstract.interface.d.ts

@@ -0,0 +1,3 @@
+export interface Abstract<T> extends Function {
+    prototype: T;
+}

package/interfaces/abstract.interface.js

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

package/interfaces/controllers/controller-metadata.interface.d.ts

@@ -0,0 +1,3 @@
+export interface ControllerMetadata {
+    path?: string;
+}

package/interfaces/controllers/controller-metadata.interface.js

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

package/interfaces/controllers/controller.interface.d.ts

@@ -0,0 +1 @@
+export type Controller = object;

package/interfaces/controllers/controller.interface.js

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

package/interfaces/controllers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './controller-metadata.interface';
+export * from './controller.interface';

package/interfaces/controllers/index.js

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

package/interfaces/exceptions/exception-filter-metadata.interface.d.ts

@@ -0,0 +1,6 @@
+import { ExceptionFilter } from './exception-filter.interface';
+import { Type } from '../type.interface';
+export interface ExceptionFilterMetadata {
+    func: ExceptionFilter['catch'];
+    exceptionMetatypes: Type<any>[];
+}

package/interfaces/exceptions/exception-filter-metadata.interface.js

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

package/interfaces/exceptions/exception-filter.interface.d.ts

@@ -0,0 +1,18 @@
+import { ArgumentsHost } from '../features/arguments-host.interface';
+/**
+ * Interface describing implementation of an exception filter.
+ *
+ * @see [Exception Filters](https://docs.nestjs.com/exception-filters)
+ *
+ * @publicApi
+ */
+export interface ExceptionFilter<T = any> {
+    /**
+     * Method to implement a custom exception filter.
+     *
+     * @param exception the class of the exception being handled
+     * @param host used to access an array of arguments for
+     * the in-flight request
+     */
+    catch(exception: T, host: ArgumentsHost): any;
+}

package/interfaces/exceptions/exception-filter.interface.js

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

package/interfaces/exceptions/index.d.ts

@@ -0,0 +1,5 @@
+export * from './exception-filter-metadata.interface';
+export * from './exception-filter.interface';
+export * from './rpc-exception-filter-metadata.interface';
+export * from './rpc-exception-filter.interface';
+export * from './ws-exception-filter.interface';

package/interfaces/exceptions/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./exception-filter-metadata.interface"), exports);
+tslib_1.__exportStar(require("./exception-filter.interface"), exports);
+tslib_1.__exportStar(require("./rpc-exception-filter-metadata.interface"), exports);
+tslib_1.__exportStar(require("./rpc-exception-filter.interface"), exports);
+tslib_1.__exportStar(require("./ws-exception-filter.interface"), exports);

package/interfaces/exceptions/rpc-exception-filter-metadata.interface.d.ts

@@ -0,0 +1,6 @@
+import { RpcExceptionFilter } from './rpc-exception-filter.interface';
+import { Type } from '../type.interface';
+export interface RpcExceptionFilterMetadata {
+    func: RpcExceptionFilter['catch'];
+    exceptionMetatypes: Type<any>[];
+}

package/interfaces/exceptions/rpc-exception-filter-metadata.interface.js

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

package/interfaces/exceptions/rpc-exception-filter.interface.d.ts

@@ -0,0 +1,19 @@
+import { Observable } from 'rxjs';
+import { ArgumentsHost } from '../features/arguments-host.interface';
+/**
+ * Interface describing implementation of an RPC exception filter.
+ *
+ * @see [Exception Filters](https://docs.nestjs.com/microservices/exception-filters)
+ *
+ * @publicApi
+ */
+export interface RpcExceptionFilter<T = any, R = any> {
+    /**
+     * Method to implement a custom (microservice) exception filter.
+     *
+     * @param exception the type (class) of the exception being handled
+     * @param host used to access an array of arguments for
+     * the in-flight message
+     */
+    catch(exception: T, host: ArgumentsHost): Observable<R>;
+}

package/interfaces/exceptions/rpc-exception-filter.interface.js

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

package/interfaces/exceptions/ws-exception-filter.interface.d.ts

@@ -0,0 +1,18 @@
+import { ArgumentsHost } from '../features/arguments-host.interface';
+/**
+ * Interface describing implementation of a Web Sockets exception filter.
+ *
+ * @see [Exception Filters](https://docs.nestjs.com/websockets/exception-filters)
+ *
+ * @publicApi
+ */
+export interface WsExceptionFilter<T = any> {
+    /**
+     * Method to implement a custom (web sockets) exception filter.
+     *
+     * @param exception the type (class) of the exception being handled
+     * @param host used to access an array of arguments for
+     * the in-flight message  catch(exception: T, host: ArgumentsHost): any;
+     */
+    catch(exception: T, host: ArgumentsHost): any;
+}

package/interfaces/exceptions/ws-exception-filter.interface.js

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

package/interfaces/external/class-transform-options.interface.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Options to be passed during transformation.
+ *
+ * @see https://github.com/typestack/class-transformer
+ *
+ * @publicApi
+ */
+export interface ClassTransformOptions {
+    /**
+     * Exclusion strategy. By default exposeAll is used, which means that it will expose all properties that
+     * are transformed by default.
+     */
+    strategy?: 'excludeAll' | 'exposeAll';
+    /**
+     * Only properties with given groups will be transformed.
+     */
+    groups?: string[];
+    /**
+     * Only properties with "since" > version < "until" will be transformed.
+     */
+    version?: number;
+    /**
+     * Excludes properties with the given prefixes. For example, if you mark your private properties with "_" and "__"
+     * you can set this option's value to ["_", "__"] and all private properties will be skipped.
+     * This works only for "exposeAll" strategy.
+     */
+    excludePrefixes?: string[];
+    /**
+     * If set to true then class transformer will ignore all @Expose and @Exclude decorators and what's inside them.
+     * This option is useful if you want to "clone" your object but not apply decorators affects.
+     */
+    ignoreDecorators?: boolean;
+    /**
+     * Target maps allows to set a Types of the transforming object without using @Type decorator.
+     * This is useful when you are transforming external classes, or if you already have type metadata for
+     * objects and you don't want to set it up again.
+     */
+    targetMaps?: any[];
+    /**
+     * If set to true then class transformer will perform a circular check. (Circular check is turned off by default)
+     * This option is useful when you know for sure that your types might have a circular dependency.
+     */
+    enableCircularCheck?: boolean;
+    /**
+     * If set to true class-transformer will attempt conversion based on TS reflected type
+     */
+    enableImplicitConversion?: boolean;
+    /**
+     * If set to true class-transformer will exclude properties which are not part of the original class
+     * and exposing all class properties (with undefined, if nothing else is given)
+     */
+    excludeExtraneousValues?: boolean;
+    /**
+     * If set to true then class transformer will take default values for unprovided fields.
+     * This is useful when you convert a plain object to a class and have an optional field with a default value.
+     */
+    exposeDefaultValues?: boolean;
+    /**
+     * When set to true, fields with `undefined` as value will be included in class to plain transformation. Otherwise
+     * those fields will be omitted from the result.
+     *
+     * DEFAULT: `true`
+     */
+    exposeUnsetFields?: boolean;
+}

package/interfaces/external/class-transform-options.interface.js

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

package/interfaces/external/cors-options.interface.d.ts

@@ -0,0 +1,58 @@
+type StaticOrigin = boolean | string | RegExp | (string | RegExp)[];
+/**
+ * Set origin to a function implementing some custom logic. The function takes the
+ * request origin as the first parameter and a callback (which expects the signature
+ * err [object], allow [bool]) as the second.
+ *
+ * @see https://github.com/expressjs/cors
+ *
+ * @publicApi
+ */
+export type CustomOrigin = (requestOrigin: string | undefined, callback: (err: Error | null, origin?: StaticOrigin) => void) => void;
+/**
+ * Interface describing CORS options that can be set.
+ *
+ * @see https://github.com/expressjs/cors
+ * @publicApi
+ */
+export interface CorsOptions {
+    /**
+     * Configures the `Access-Control-Allow-Origins` CORS header.  See [here for more detail.](https://github.com/expressjs/cors#configuration-options)
+     */
+    origin?: StaticOrigin | CustomOrigin;
+    /**
+     * Configures the Access-Control-Allow-Methods CORS header.
+     */
+    methods?: string | string[];
+    /**
+     * Configures the Access-Control-Allow-Headers CORS header.
+     */
+    allowedHeaders?: string | string[];
+    /**
+     * Configures the Access-Control-Expose-Headers CORS header.
+     */
+    exposedHeaders?: string | string[];
+    /**
+     * Configures the Access-Control-Allow-Credentials CORS header.
+     */
+    credentials?: boolean;
+    /**
+     * Configures the Access-Control-Max-Age CORS header.
+     */
+    maxAge?: number;
+    /**
+     * Whether to pass the CORS preflight response to the next handler.
+     */
+    preflightContinue?: boolean;
+    /**
+     * Provides a status code to use for successful OPTIONS requests.
+     */
+    optionsSuccessStatus?: number;
+}
+export interface CorsOptionsCallback {
+    (error: Error | null, options: CorsOptions): void;
+}
+export interface CorsOptionsDelegate<T> {
+    (req: T, cb: CorsOptionsCallback): void;
+}
+export {};

package/interfaces/external/cors-options.interface.js

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

package/interfaces/external/https-options.interface.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Interface describing Https Options that can be set.
+ *
+ * @see https://nodejs.org/api/tls.html
+ *
+ * @publicApi
+ */
+export interface HttpsOptions {
+    /**
+     * PFX or PKCS12 encoded private key and certificate chain. pfx is an alternative
+     * to providing key and cert individually. PFX is usually encrypted, if it is,
+     * passphrase will be used to decrypt it. Multiple PFX can be provided either
+     * as an array of unencrypted PFX buffers, or an array of objects in the form
+     * {buf: <string|buffer>[, passphrase: <string>]}. The object form can only
+     * occur in an array. object.passphrase is optional. Encrypted PFX will be decrypted
+     * with object.passphrase if provided, or options.passphrase if it is not.
+     */
+    pfx?: any;
+    /**
+     * Private keys in PEM format. PEM allows the option of private keys being encrypted.
+     * Encrypted keys will be decrypted with options.passphrase. Multiple keys using
+     * different algorithms can be provided either as an array of unencrypted key
+     * strings or buffers, or an array of objects in the form {pem: <string|buffer>[, passphrase: <string>]}.
+     * The object form can only occur in an array. object.passphrase is optional.
+     * Encrypted keys will be decrypted with object.passphrase if provided, or options.passphrase
+     * if it is not
+     */
+    key?: any;
+    /**
+     * Shared passphrase used for a single private key and/or a PFX.
+     */
+    passphrase?: string;
+    /**
+     * Cert chains in PEM format. One cert chain should be provided per private key.
+     * Each cert chain should consist of the PEM formatted certificate for a provided
+     * private key, followed by the PEM formatted intermediate certificates (if any),
+     * in order, and not including the root CA (the root CA must be pre-known to the
+     * peer, see ca). When providing multiple cert chains, they do not have to be
+     * in the same order as their private keys in key. If the intermediate certificates
+     * are not provided, the peer will not be able to validate the certificate, and
+     * the handshake will fail.
+     */
+    cert?: any;
+    /**
+     * Optionally override the trusted CA certificates. Default is to trust the well-known
+     * CAs curated by Mozilla. Mozilla's CAs are completely replaced when CAs are
+     * explicitly specified using this option. The value can be a string or Buffer,
+     * or an Array of strings and/or Buffers. Any string or Buffer can contain multiple
+     * PEM CAs concatenated together. The peer's certificate must be chainable to
+     * a CA trusted by the server for the connection to be authenticated. When using
+     * certificates that are not chainable to a well-known CA, the certificate's CA
+     * must be explicitly specified as a trusted or the connection will fail to authenticate.
+     * If the peer uses a certificate that doesn't match or chain to one of the default
+     * CAs, use the ca option to provide a CA certificate that the peer's certificate
+     * can match or chain to. For self-signed certificates, the certificate is its
+     * own CA, and must be provided. For PEM encoded certificates, supported types
+     * are "TRUSTED CERTIFICATE", "X509 CERTIFICATE", and "CERTIFICATE". See also tls.rootCertificates.
+     */
+    ca?: any;
+    /**
+     * PEM formatted CRLs (Certificate Revocation Lists).
+     */
+    crl?: any;
+    /**
+     * Cipher suite specification, replacing the default. For more information, see
+     * modifying the default cipher suite. Permitted ciphers can be obtained via tls.getCiphers().
+     * Cipher names must be uppercased in order for OpenSSL to accept them.
+     */
+    ciphers?: string;
+    /**
+     * Attempt to use the server's cipher suite preferences instead of the client's.
+     * When true, causes SSL_OP_CIPHER_SERVER_PREFERENCE to be set in secureOptions,
+     * see OpenSSL Options for more information.
+     */
+    honorCipherOrder?: boolean;
+    /**
+     * If true the server will request a certificate from clients that connect and
+     * attempt to verify that certificate. Default: false.
+     */
+    requestCert?: boolean;
+    /**
+     * If not false the server will reject any connection which is not authorized
+     * with the list of supplied CAs. This option only has an effect if requestCert is true. Default: true
+     */
+    rejectUnauthorized?: boolean;
+    /**
+     * An array or Buffer of possible NPN protocols. (Protocols should be ordered
+     * by their priority).
+     */
+    NPNProtocols?: any;
+    /**
+     * A function that will be called if the client supports SNI TLS extension. Two
+     * arguments will be passed when called: servername and cb. SNICallback should
+     * invoke cb(null, ctx), where ctx is a SecureContext instance. (tls.createSecureContext(...)
+     * can be used to get a proper SecureContext.) If SNICallback wasn't provided
+     * the default callback with high-level API will be used.
+     */
+    SNICallback?: (servername: string, cb: (err: Error, ctx: any) => any) => any;
+    /**
+     * Optionally affect the OpenSSL protocol behavior, which is not usually necessary.
+     * This should be used carefully if at all! Value is a numeric bitmask of the SSL_OP_* options
+     * from OpenSSL Options.
+     */
+    secureOptions?: number;
+}

package/interfaces/external/https-options.interface.js

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

package/interfaces/external/transformer-package.interface.d.ts

@@ -0,0 +1,6 @@
+import { Type } from '../type.interface';
+import { ClassTransformOptions } from './class-transform-options.interface';
+export interface TransformerPackage {
+    plainToInstance<T>(cls: Type<T>, plain: unknown, options?: ClassTransformOptions): T | T[];
+    classToPlain(object: unknown, options?: ClassTransformOptions): Record<string, any> | Record<string, any>[];
+}

package/interfaces/external/transformer-package.interface.js

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

package/interfaces/external/validation-error.interface.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Validation error description.
+ * @see https://github.com/typestack/class-validator
+ *
+ * class-validator@0.13.0
+ *
+ * @publicApi
+ */
+export interface ValidationError {
+    /**
+     * Object that was validated.
+     *
+     * OPTIONAL - configurable via the ValidatorOptions.validationError.target option
+     */
+    target?: Record<string, any>;
+    /**
+     * Object's property that hasn't passed validation.
+     */
+    property: string;
+    /**
+     * Value that haven't pass a validation.
+     *
+     * OPTIONAL - configurable via the ValidatorOptions.validationError.value option
+     */
+    value?: any;
+    /**
+     * Constraints that failed validation with error messages.
+     */
+    constraints?: {
+        [type: string]: string;
+    };
+    /**
+     * Contains all nested validation errors of the property.
+     */
+    children?: ValidationError[];
+    /**
+     * A transient set of data passed through to the validation result for response mapping
+     */
+    contexts?: {
+        [type: string]: any;
+    };
+}

package/interfaces/external/validation-error.interface.js

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

package/interfaces/external/validator-options.interface.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Options passed to validator during validation.
+ * @see https://github.com/typestack/class-validator
+ *
+ * class-validator@0.13.0
+ *
+ * @publicApi
+ */
+export interface ValidatorOptions {
+    /**
+     * If set to true then class-validator will print extra warning messages to the console when something is not right.
+     */
+    enableDebugMessages?: boolean;
+    /**
+     * If set to true then validator will skip validation of all properties that are undefined in the validating object.
+     */
+    skipUndefinedProperties?: boolean;
+    /**
+     * If set to true then validator will skip validation of all properties that are null in the validating object.
+     */
+    skipNullProperties?: boolean;
+    /**
+     * If set to true then validator will skip validation of all properties that are null or undefined in the validating object.
+     */
+    skipMissingProperties?: boolean;
+    /**
+     * If set to true validator will strip validated object of any properties that do not have any decorators.
+     *
+     * Tip: if no other decorator is suitable for your property use @Allow decorator.
+     */
+    whitelist?: boolean;
+    /**
+     * If set to true, instead of stripping non-whitelisted properties validator will throw an error
+     */
+    forbidNonWhitelisted?: boolean;
+    /**
+     * Groups to be used during validation of the object.
+     */
+    groups?: string[];
+    /**
+     * Set default for `always` option of decorators. Default can be overridden in decorator options.
+     */
+    always?: boolean;
+    /**
+     * If [groups]{@link ValidatorOptions#groups} is not given or is empty,
+     * ignore decorators with at least one group.
+     */
+    strictGroups?: boolean;
+    /**
+     * If set to true, the validation will not use default messages.
+     * Error message always will be undefined if its not explicitly set.
+     */
+    dismissDefaultMessages?: boolean;
+    /**
+     * ValidationError special options.
+     */
+    validationError?: {
+        /**
+         * Indicates if target should be exposed in ValidationError.
+         */
+        target?: boolean;
+        /**
+         * Indicates if validated value should be exposed in ValidationError.
+         */
+        value?: boolean;
+    };
+    /**
+     * Settings true will cause fail validation of unknown objects.
+     */
+    forbidUnknownValues?: boolean;
+    /**
+     * When set to true, validation of the given property will stop after encountering the first error.
+     * This is enabled by default.
+     */
+    stopAtFirstError?: boolean;
+}

package/interfaces/external/validator-options.interface.js

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

package/interfaces/external/validator-package.interface.d.ts

@@ -0,0 +1,5 @@
+import { ValidationError } from './validation-error.interface';
+import { ValidatorOptions } from './validator-options.interface';
+export interface ValidatorPackage {
+    validate(object: unknown, validatorOptions?: ValidatorOptions): ValidationError[] | Promise<ValidationError[]>;
+}

package/interfaces/external/validator-package.interface.js

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