@depup/nestjs__common 11.1.16-depup.1

package/pipes/parse-uuid.pipe.d.ts

@@ -0,0 +1,49 @@
+import { ArgumentMetadata, PipeTransform } from '../interfaces/features/pipe-transform.interface';
+import { ErrorHttpStatusCode } from '../utils/http-error-by-code.util';
+/**
+ * @publicApi
+ */
+export interface ParseUUIDPipeOptions {
+    /**
+     * UUID version to validate
+     */
+    version?: '3' | '4' | '5' | '7';
+    /**
+     * The HTTP status code to be used in the response when the validation fails.
+     */
+    errorHttpStatusCode?: ErrorHttpStatusCode;
+    /**
+     * A factory function that returns an exception object to be thrown
+     * if validation fails.
+     * @param error Error message
+     * @returns The exception object
+     */
+    exceptionFactory?: (errors: string) => any;
+    /**
+     * If true, the pipe will return null or undefined if the value is not provided
+     * @default false
+     */
+    optional?: boolean;
+}
+/**
+ * Defines the built-in ParseUUID Pipe
+ *
+ * @see [Built-in Pipes](https://docs.nestjs.com/pipes#built-in-pipes)
+ *
+ * @publicApi
+ */
+export declare class ParseUUIDPipe implements PipeTransform<string> {
+    protected readonly options?: ParseUUIDPipeOptions | undefined;
+    protected static uuidRegExps: {
+        3: RegExp;
+        4: RegExp;
+        5: RegExp;
+        7: RegExp;
+        all: RegExp;
+    };
+    private readonly version;
+    protected exceptionFactory: (errors: string) => any;
+    constructor(options?: ParseUUIDPipeOptions | undefined);
+    transform(value: string, metadata: ArgumentMetadata): Promise<string>;
+    protected isUUID(str: unknown, version?: string): any;
+}

package/pipes/parse-uuid.pipe.js

@@ -0,0 +1,57 @@
+"use strict";
+var ParseUUIDPipe_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseUUIDPipe = void 0;
+const tslib_1 = require("tslib");
+const injectable_decorator_1 = require("../decorators/core/injectable.decorator");
+const optional_decorator_1 = require("../decorators/core/optional.decorator");
+const http_status_enum_1 = require("../enums/http-status.enum");
+const http_error_by_code_util_1 = require("../utils/http-error-by-code.util");
+const shared_utils_1 = require("../utils/shared.utils");
+/**
+ * Defines the built-in ParseUUID Pipe
+ *
+ * @see [Built-in Pipes](https://docs.nestjs.com/pipes#built-in-pipes)
+ *
+ * @publicApi
+ */
+let ParseUUIDPipe = ParseUUIDPipe_1 = class ParseUUIDPipe {
+    constructor(options) {
+        this.options = options;
+        options = options || {};
+        const { exceptionFactory, errorHttpStatusCode = http_status_enum_1.HttpStatus.BAD_REQUEST, version, } = options;
+        this.version = version;
+        this.exceptionFactory =
+            exceptionFactory ||
+                (error => new http_error_by_code_util_1.HttpErrorByCode[errorHttpStatusCode](error));
+    }
+    async transform(value, metadata) {
+        if ((0, shared_utils_1.isNil)(value) && this.options?.optional) {
+            return value;
+        }
+        if (!this.isUUID(value, this.version)) {
+            throw this.exceptionFactory(`Validation failed (uuid${this.version ? ` v ${this.version}` : ''} is expected)`);
+        }
+        return value;
+    }
+    isUUID(str, version = 'all') {
+        if (!(0, shared_utils_1.isString)(str)) {
+            throw this.exceptionFactory('The value passed as UUID is not a string');
+        }
+        const pattern = ParseUUIDPipe_1.uuidRegExps[version];
+        return pattern?.test(str);
+    }
+};
+exports.ParseUUIDPipe = ParseUUIDPipe;
+ParseUUIDPipe.uuidRegExps = {
+    3: /^[0-9A-F]{8}-[0-9A-F]{4}-3[0-9A-F]{3}-[0-9A-F]{4}-[0-9A-F]{12}$/i,
+    4: /^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
+    5: /^[0-9A-F]{8}-[0-9A-F]{4}-5[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
+    7: /^[0-9A-F]{8}-[0-9A-F]{4}-7[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
+    all: /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i,
+};
+exports.ParseUUIDPipe = ParseUUIDPipe = ParseUUIDPipe_1 = tslib_1.__decorate([
+    (0, injectable_decorator_1.Injectable)(),
+    tslib_1.__param(0, (0, optional_decorator_1.Optional)()),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], ParseUUIDPipe);

package/pipes/validation.pipe.d.ts

@@ -0,0 +1,51 @@
+import { ClassTransformOptions } from '../interfaces/external/class-transform-options.interface';
+import { TransformerPackage } from '../interfaces/external/transformer-package.interface';
+import { ValidationError } from '../interfaces/external/validation-error.interface';
+import { ValidatorOptions } from '../interfaces/external/validator-options.interface';
+import { ValidatorPackage } from '../interfaces/external/validator-package.interface';
+import { ArgumentMetadata, PipeTransform } from '../interfaces/features/pipe-transform.interface';
+import { Type } from '../interfaces/type.interface';
+import { ErrorHttpStatusCode } from '../utils/http-error-by-code.util';
+/**
+ * @publicApi
+ */
+export interface ValidationPipeOptions extends ValidatorOptions {
+    transform?: boolean;
+    disableErrorMessages?: boolean;
+    transformOptions?: ClassTransformOptions;
+    errorHttpStatusCode?: ErrorHttpStatusCode;
+    exceptionFactory?: (errors: ValidationError[]) => any;
+    validateCustomDecorators?: boolean;
+    expectedType?: Type<any>;
+    validatorPackage?: ValidatorPackage;
+    transformerPackage?: TransformerPackage;
+}
+/**
+ * @see [Validation](https://docs.nestjs.com/techniques/validation)
+ *
+ * @publicApi
+ */
+export declare class ValidationPipe implements PipeTransform<any> {
+    protected isTransformEnabled: boolean;
+    protected isDetailedOutputDisabled?: boolean;
+    protected validatorOptions: ValidatorOptions;
+    protected transformOptions: ClassTransformOptions | undefined;
+    protected errorHttpStatusCode: ErrorHttpStatusCode;
+    protected expectedType: Type<any> | undefined;
+    protected exceptionFactory: (errors: ValidationError[]) => any;
+    protected validateCustomDecorators: boolean;
+    constructor(options?: ValidationPipeOptions);
+    protected loadValidator(validatorPackage?: ValidatorPackage): ValidatorPackage;
+    protected loadTransformer(transformerPackage?: TransformerPackage): TransformerPackage;
+    transform(value: any, metadata: ArgumentMetadata): Promise<any>;
+    createExceptionFactory(): (validationErrors?: ValidationError[]) => unknown;
+    protected toValidate(metadata: ArgumentMetadata): boolean;
+    protected transformPrimitive(value: any, metadata: ArgumentMetadata): any;
+    protected toEmptyIfNil<T = any, R = T>(value: T, metatype: Type<unknown> | object): R | object | string;
+    protected stripProtoKeys(value: any): void;
+    protected isPrimitive(value: unknown): boolean;
+    protected validate(object: object, validatorOptions?: ValidatorOptions): Promise<ValidationError[]> | ValidationError[];
+    protected flattenValidationErrors(validationErrors: ValidationError[]): string[];
+    protected mapChildrenToValidationErrors(error: ValidationError, parentPath?: string): ValidationError[];
+    protected prependConstraintsWithParentProp(parentPath: string, error: ValidationError): ValidationError;
+}

package/pipes/validation.pipe.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationPipe = void 0;
+const tslib_1 = require("tslib");
+const iterare_1 = require("iterare");
+const util_1 = require("util");
+const decorators_1 = require("../decorators");
+const core_1 = require("../decorators/core");
+const http_status_enum_1 = require("../enums/http-status.enum");
+const http_error_by_code_util_1 = require("../utils/http-error-by-code.util");
+const load_package_util_1 = require("../utils/load-package.util");
+const shared_utils_1 = require("../utils/shared.utils");
+let classValidator = {};
+let classTransformer = {};
+/**
+ * Built-in JavaScript types that should be excluded from prototype stripping
+ * to avoid conflicts with test frameworks like Jest's useFakeTimers
+ */
+const BUILT_IN_TYPES = [Date, RegExp, Error, Map, Set, WeakMap, WeakSet];
+/**
+ * @see [Validation](https://docs.nestjs.com/techniques/validation)
+ *
+ * @publicApi
+ */
+let ValidationPipe = class ValidationPipe {
+    constructor(options) {
+        options = options || {};
+        const { transform, disableErrorMessages, errorHttpStatusCode, expectedType, transformOptions, validateCustomDecorators, ...validatorOptions } = options;
+        // @see [https://github.com/nestjs/nest/issues/10683#issuecomment-1413690508](https://github.com/nestjs/nest/issues/10683#issuecomment-1413690508)
+        this.validatorOptions = { forbidUnknownValues: false, ...validatorOptions };
+        this.isTransformEnabled = !!transform;
+        this.transformOptions = transformOptions;
+        this.isDetailedOutputDisabled = disableErrorMessages;
+        this.validateCustomDecorators = validateCustomDecorators || false;
+        this.errorHttpStatusCode = errorHttpStatusCode || http_status_enum_1.HttpStatus.BAD_REQUEST;
+        this.expectedType = expectedType;
+        this.exceptionFactory =
+            options.exceptionFactory || this.createExceptionFactory();
+        classValidator = this.loadValidator(options.validatorPackage);
+        classTransformer = this.loadTransformer(options.transformerPackage);
+    }
+    loadValidator(validatorPackage) {
+        return (validatorPackage ??
+            (0, load_package_util_1.loadPackage)('class-validator', 'ValidationPipe', () => require('class-validator')));
+    }
+    loadTransformer(transformerPackage) {
+        return (transformerPackage ??
+            (0, load_package_util_1.loadPackage)('class-transformer', 'ValidationPipe', () => require('class-transformer')));
+    }
+    async transform(value, metadata) {
+        if (this.expectedType) {
+            metadata = { ...metadata, metatype: this.expectedType };
+        }
+        const metatype = metadata.metatype;
+        if (!metatype || !this.toValidate(metadata)) {
+            return this.isTransformEnabled
+                ? this.transformPrimitive(value, metadata)
+                : value;
+        }
+        const originalValue = value;
+        value = this.toEmptyIfNil(value, metatype);
+        const isNil = value !== originalValue;
+        const isPrimitive = this.isPrimitive(value);
+        this.stripProtoKeys(value);
+        let entity = classTransformer.plainToInstance(metatype, value, this.transformOptions);
+        const originalEntity = entity;
+        const isCtorNotEqual = entity.constructor !== metatype;
+        if (isCtorNotEqual && !isPrimitive) {
+            entity.constructor = metatype;
+        }
+        else if (isCtorNotEqual) {
+            // when "entity" is a primitive value, we have to temporarily
+            // replace the entity to perform the validation against the original
+            // metatype defined inside the handler
+            entity = { constructor: metatype };
+        }
+        const errors = await this.validate(entity, this.validatorOptions);
+        if (errors.length > 0) {
+            throw await this.exceptionFactory(errors);
+        }
+        if (originalValue === undefined && originalEntity === '') {
+            // Since SWC requires empty string for validation (to avoid an error),
+            // a fallback is needed to revert to the original value (when undefined).
+            // @see [https://github.com/nestjs/nest/issues/14430](https://github.com/nestjs/nest/issues/14430)
+            return originalValue;
+        }
+        if (isPrimitive) {
+            // if the value is a primitive value and the validation process has been successfully completed
+            // we have to revert the original value passed through the pipe
+            entity = originalEntity;
+        }
+        if (this.isTransformEnabled) {
+            return entity;
+        }
+        if (isNil) {
+            // if the value was originally undefined or null, revert it back
+            return originalValue;
+        }
+        // we check if the number of keys of the "validatorOptions" is higher than 1 (instead of 0)
+        // because the "forbidUnknownValues" now fallbacks to "false" (in case it wasn't explicitly specified)
+        const shouldTransformToPlain = Object.keys(this.validatorOptions).length > 1;
+        return shouldTransformToPlain
+            ? classTransformer.classToPlain(entity, this.transformOptions)
+            : value;
+    }
+    createExceptionFactory() {
+        return (validationErrors = []) => {
+            if (this.isDetailedOutputDisabled) {
+                return new http_error_by_code_util_1.HttpErrorByCode[this.errorHttpStatusCode]();
+            }
+            const errors = this.flattenValidationErrors(validationErrors);
+            return new http_error_by_code_util_1.HttpErrorByCode[this.errorHttpStatusCode](errors);
+        };
+    }
+    toValidate(metadata) {
+        const { metatype, type } = metadata;
+        if (type === 'custom' && !this.validateCustomDecorators) {
+            return false;
+        }
+        const types = [String, Boolean, Number, Array, Object, Buffer, Date];
+        return !types.some(t => metatype === t) && !(0, shared_utils_1.isNil)(metatype);
+    }
+    transformPrimitive(value, metadata) {
+        if (!metadata.data) {
+            // leave top-level query/param objects unmodified
+            return value;
+        }
+        const { type, metatype } = metadata;
+        if (type !== 'param' && type !== 'query') {
+            return value;
+        }
+        if (metatype === Boolean) {
+            if ((0, shared_utils_1.isUndefined)(value)) {
+                // This is an workaround to deal with optional boolean values since
+                // optional booleans shouldn't be parsed to a valid boolean when
+                // they were not defined
+                return undefined;
+            }
+            // Any fasly value but `undefined` will be parsed to `false`
+            return value === true || value === 'true';
+        }
+        if (metatype === Number) {
+            if ((0, shared_utils_1.isUndefined)(value)) {
+                // This is a workaround to deal with optional numeric values since
+                // optional numerics shouldn't be parsed to a valid number when
+                // they were not defined
+                return undefined;
+            }
+            return +value;
+        }
+        if (metatype === String && !(0, shared_utils_1.isUndefined)(value)) {
+            return String(value);
+        }
+        return value;
+    }
+    toEmptyIfNil(value, metatype) {
+        if (!(0, shared_utils_1.isNil)(value)) {
+            return value;
+        }
+        if (typeof metatype === 'function' ||
+            (metatype && 'prototype' in metatype && metatype.prototype?.constructor)) {
+            return {};
+        }
+        // SWC requires empty string to be returned instead of an empty object
+        // when the value is nil and the metatype is not a class instance, but a plain object (enum, for example).
+        // Otherwise, the error will be thrown.
+        // @see [https://github.com/nestjs/nest/issues/12680](https://github.com/nestjs/nest/issues/12680)
+        return '';
+    }
+    stripProtoKeys(value) {
+        if (value == null ||
+            typeof value !== 'object' ||
+            util_1.types.isTypedArray(value)) {
+            return;
+        }
+        // Skip built-in JavaScript primitives to avoid Jest useFakeTimers conflicts
+        if (BUILT_IN_TYPES.some(type => value instanceof type)) {
+            return;
+        }
+        if (Array.isArray(value)) {
+            for (const v of value) {
+                this.stripProtoKeys(v);
+            }
+            return;
+        }
+        // Delete dangerous prototype pollution keys
+        delete value.__proto__;
+        delete value.prototype;
+        // Only delete constructor if it's NOT a built-in type
+        const constructorType = value?.constructor;
+        if (constructorType && !BUILT_IN_TYPES.includes(constructorType)) {
+            delete value.constructor;
+        }
+        for (const key in value) {
+            this.stripProtoKeys(value[key]);
+        }
+    }
+    isPrimitive(value) {
+        return ['number', 'boolean', 'string'].includes(typeof value);
+    }
+    validate(object, validatorOptions) {
+        return classValidator.validate(object, validatorOptions);
+    }
+    flattenValidationErrors(validationErrors) {
+        return (0, iterare_1.iterate)(validationErrors)
+            .map(error => this.mapChildrenToValidationErrors(error))
+            .flatten()
+            .filter(item => !!item.constraints)
+            .map(item => Object.values(item.constraints))
+            .flatten()
+            .toArray();
+    }
+    mapChildrenToValidationErrors(error, parentPath) {
+        if (!(error.children && error.children.length)) {
+            return [error];
+        }
+        const validationErrors = [];
+        parentPath = parentPath
+            ? `${parentPath}.${error.property}`
+            : error.property;
+        for (const item of error.children) {
+            if (item.children && item.children.length) {
+                validationErrors.push(...this.mapChildrenToValidationErrors(item, parentPath));
+            }
+            validationErrors.push(this.prependConstraintsWithParentProp(parentPath, item));
+        }
+        return validationErrors;
+    }
+    prependConstraintsWithParentProp(parentPath, error) {
+        const constraints = {};
+        for (const key in error.constraints) {
+            constraints[key] = `${parentPath}.${error.constraints[key]}`;
+        }
+        return {
+            ...error,
+            constraints,
+        };
+    }
+};
+exports.ValidationPipe = ValidationPipe;
+exports.ValidationPipe = ValidationPipe = tslib_1.__decorate([
+    (0, core_1.Injectable)(),
+    tslib_1.__param(0, (0, decorators_1.Optional)()),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], ValidationPipe);

package/serializer/class-serializer.constants.d.ts

@@ -0,0 +1 @@
+export declare const CLASS_SERIALIZER_OPTIONS = "class_serializer:options";

package/serializer/class-serializer.constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLASS_SERIALIZER_OPTIONS = void 0;
+exports.CLASS_SERIALIZER_OPTIONS = 'class_serializer:options';

package/serializer/class-serializer.interceptor.d.ts

@@ -0,0 +1,29 @@
+import { ClassSerializerContextOptions } from './class-serializer.interfaces';
+import { Observable } from 'rxjs';
+import { CallHandler, ExecutionContext, NestInterceptor } from '../interfaces';
+import { ClassTransformOptions } from '../interfaces/external/class-transform-options.interface';
+import { TransformerPackage } from '../interfaces/external/transformer-package.interface';
+export interface PlainLiteralObject {
+    [key: string]: any;
+}
+/**
+ * @publicApi
+ */
+export interface ClassSerializerInterceptorOptions extends ClassTransformOptions {
+    transformerPackage?: TransformerPackage;
+}
+/**
+ * @publicApi
+ */
+export declare class ClassSerializerInterceptor implements NestInterceptor {
+    protected readonly reflector: any;
+    protected readonly defaultOptions: ClassSerializerInterceptorOptions;
+    constructor(reflector: any, defaultOptions?: ClassSerializerInterceptorOptions);
+    intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
+    /**
+     * Serializes responses that are non-null objects nor streamable files.
+     */
+    serialize(response: PlainLiteralObject | Array<PlainLiteralObject>, options: ClassSerializerContextOptions): PlainLiteralObject | Array<PlainLiteralObject>;
+    transformToPlain(plainOrClass: any, options: ClassSerializerContextOptions): PlainLiteralObject;
+    protected getContextOptions(context: ExecutionContext): ClassSerializerContextOptions | undefined;
+}

package/serializer/class-serializer.interceptor.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassSerializerInterceptor = void 0;
+const tslib_1 = require("tslib");
+const operators_1 = require("rxjs/operators");
+const core_1 = require("../decorators/core");
+const file_stream_1 = require("../file-stream");
+const load_package_util_1 = require("../utils/load-package.util");
+const shared_utils_1 = require("../utils/shared.utils");
+const class_serializer_constants_1 = require("./class-serializer.constants");
+let classTransformer = {};
+// NOTE (external)
+// We need to deduplicate them here due to the circular dependency
+// between core and common packages
+const REFLECTOR = 'Reflector';
+/**
+ * @publicApi
+ */
+let ClassSerializerInterceptor = class ClassSerializerInterceptor {
+    constructor(reflector, defaultOptions = {}) {
+        this.reflector = reflector;
+        this.defaultOptions = defaultOptions;
+        classTransformer =
+            defaultOptions?.transformerPackage ??
+                (0, load_package_util_1.loadPackage)('class-transformer', 'ClassSerializerInterceptor', () => require('class-transformer'));
+        if (!defaultOptions?.transformerPackage) {
+            require('class-transformer');
+        }
+    }
+    intercept(context, next) {
+        const contextOptions = this.getContextOptions(context);
+        const options = {
+            ...this.defaultOptions,
+            ...contextOptions,
+        };
+        return next
+            .handle()
+            .pipe((0, operators_1.map)((res) => this.serialize(res, options)));
+    }
+    /**
+     * Serializes responses that are non-null objects nor streamable files.
+     */
+    serialize(response, options) {
+        if (!(0, shared_utils_1.isObject)(response) || response instanceof file_stream_1.StreamableFile) {
+            return response;
+        }
+        return Array.isArray(response)
+            ? response.map(item => this.transformToPlain(item, options))
+            : this.transformToPlain(response, options);
+    }
+    transformToPlain(plainOrClass, options) {
+        if (!plainOrClass) {
+            return plainOrClass;
+        }
+        if (!options.type) {
+            return classTransformer.classToPlain(plainOrClass, options);
+        }
+        if (plainOrClass instanceof options.type) {
+            return classTransformer.classToPlain(plainOrClass, options);
+        }
+        const instance = classTransformer.plainToInstance(options.type, plainOrClass, options);
+        return classTransformer.classToPlain(instance, options);
+    }
+    getContextOptions(context) {
+        return this.reflector.getAllAndOverride(class_serializer_constants_1.CLASS_SERIALIZER_OPTIONS, [
+            context.getHandler(),
+            context.getClass(),
+        ]);
+    }
+};
+exports.ClassSerializerInterceptor = ClassSerializerInterceptor;
+exports.ClassSerializerInterceptor = ClassSerializerInterceptor = tslib_1.__decorate([
+    (0, core_1.Injectable)(),
+    tslib_1.__param(0, (0, core_1.Inject)(REFLECTOR)),
+    tslib_1.__param(1, (0, core_1.Optional)()),
+    tslib_1.__metadata("design:paramtypes", [Object, Object])
+], ClassSerializerInterceptor);

package/serializer/class-serializer.interfaces.d.ts

@@ -0,0 +1,8 @@
+import { ClassTransformOptions } from '../interfaces/external/class-transform-options.interface';
+import { Type } from '../interfaces';
+/**
+ * @publicApi
+ */
+export interface ClassSerializerContextOptions extends ClassTransformOptions {
+    type?: Type<any>;
+}

package/serializer/class-serializer.interfaces.js

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

package/serializer/decorators/index.d.ts

@@ -0,0 +1 @@
+export * from './serialize-options.decorator';

package/serializer/decorators/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./serialize-options.decorator"), exports);

package/serializer/decorators/serialize-options.decorator.d.ts

@@ -0,0 +1,5 @@
+import { ClassSerializerContextOptions } from '../class-serializer.interfaces';
+/**
+ * @publicApi
+ */
+export declare const SerializeOptions: (options: ClassSerializerContextOptions) => import("../../decorators").CustomDecorator<string>;

package/serializer/decorators/serialize-options.decorator.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeOptions = void 0;
+const decorators_1 = require("../../decorators");
+const class_serializer_constants_1 = require("../class-serializer.constants");
+/**
+ * @publicApi
+ */
+const SerializeOptions = (options) => (0, decorators_1.SetMetadata)(class_serializer_constants_1.CLASS_SERIALIZER_OPTIONS, options);
+exports.SerializeOptions = SerializeOptions;

package/serializer/index.d.ts

@@ -0,0 +1,3 @@
+export * from './class-serializer.interceptor';
+export * from './decorators';
+export * from './class-serializer.interfaces';

package/serializer/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./class-serializer.interceptor"), exports);
+tslib_1.__exportStar(require("./decorators"), exports);
+tslib_1.__exportStar(require("./class-serializer.interfaces"), exports);