@nestjs/common 10.4.11 → 11.0.0-next.2

package/exceptions/precondition-failed.exception.d.ts

@@ -31,5 +31,5 @@ export declare class PreconditionFailedException extends HttpException {
      * @param objectOrError string or object describing the error condition.
      * @param descriptionOrOptions either a short description of the HTTP error or an options object used to provide an underlying error cause
      */
-    constructor(objectOrError?: string | object | any, descriptionOrOptions?: string | HttpExceptionOptions);
+    constructor(objectOrError?: any, descriptionOrOptions?: string | HttpExceptionOptions);
 }

package/exceptions/request-timeout.exception.d.ts

@@ -31,5 +31,5 @@ export declare class RequestTimeoutException extends HttpException {
      * @param objectOrError string or object describing the error condition.
      * @param descriptionOrOptions either a short description of the HTTP error or an options object used to provide an underlying error cause
      */
-    constructor(objectOrError?: string | object | any, descriptionOrOptions?: string | HttpExceptionOptions);
+    constructor(objectOrError?: any, descriptionOrOptions?: string | HttpExceptionOptions);
 }

package/exceptions/service-unavailable.exception.d.ts

@@ -31,5 +31,5 @@ export declare class ServiceUnavailableException extends HttpException {
      * @param objectOrError string or object describing the error condition.
      * @param descriptionOrOptions either a short description of the HTTP error or an options object used to provide an underlying error cause
      */
-    constructor(objectOrError?: string | object | any, descriptionOrOptions?: string | HttpExceptionOptions);
+    constructor(objectOrError?: any, descriptionOrOptions?: string | HttpExceptionOptions);
 }

package/exceptions/unauthorized.exception.d.ts

@@ -31,5 +31,5 @@ export declare class UnauthorizedException extends HttpException {
      * @param objectOrError string or object describing the error condition.
      * @param descriptionOrOptions either a short description of the HTTP error or an options object used to provide an underlying error cause
      */
-    constructor(objectOrError?: string | object | any, descriptionOrOptions?: string | HttpExceptionOptions);
+    constructor(objectOrError?: any, descriptionOrOptions?: string | HttpExceptionOptions);
 }

package/exceptions/unprocessable-entity.exception.d.ts

@@ -31,5 +31,5 @@ export declare class UnprocessableEntityException extends HttpException {
      * @param objectOrError string or object describing the error condition.
      * @param descriptionOrOptions either a short description of the HTTP error or an options object used to provide an underlying error cause
      */
-    constructor(objectOrError?: string | object | any, descriptionOrOptions?: string | HttpExceptionOptions);
+    constructor(objectOrError?: any, descriptionOrOptions?: string | HttpExceptionOptions);
 }

package/exceptions/unsupported-media-type.exception.d.ts

@@ -31,5 +31,5 @@ export declare class UnsupportedMediaTypeException extends HttpException {
      * @param objectOrError string or object describing the error condition.
      * @param descriptionOrOptions either a short description of the HTTP error or an options object used to provide an underlying error cause
      */
-    constructor(objectOrError?: string | object | any, descriptionOrOptions?: string | HttpExceptionOptions);
+    constructor(objectOrError?: any, descriptionOrOptions?: string | HttpExceptionOptions);
 }

package/file-stream/streamable-file.d.ts

@@ -1,6 +1,6 @@
 import { Readable } from 'stream';
-import { StreamableFileOptions, StreamableHandlerResponse } from './interfaces';
 import { Logger } from '../services';
+import { StreamableFileOptions, StreamableHandlerResponse } from './interfaces';
 /**
  * @see [Streaming files](https://docs.nestjs.com/techniques/streaming-files)
  *
@@ -17,8 +17,8 @@ export declare class StreamableFile {
     getStream(): Readable;
     getHeaders(): {
         type: string;
-        disposition: string;
-        length: number;
+        disposition: string | undefined;
+        length: number | undefined;
     };
     get errorHandler(): (err: Error, response: StreamableHandlerResponse) => void;
     setErrorHandler(handler: (err: Error, response: StreamableHandlerResponse) => void): this;

package/file-stream/streamable-file.js

@@ -4,8 +4,8 @@ exports.StreamableFile = void 0;
 const stream_1 = require("stream");
 const util_1 = require("util");
 const enums_1 = require("../enums");
-const shared_utils_1 = require("../utils/shared.utils");
 const services_1 = require("../services");
+const shared_utils_1 = require("../utils/shared.utils");
 /**
  * @see [Streaming files](https://docs.nestjs.com/techniques/streaming-files)
  *
@@ -27,7 +27,7 @@ class StreamableFile {
             res.send(err.message);
         };
         this.logError = (err) => {
-            this.logger.error(err.message, err.stack);
+            this.logger.error(err);
         };
         if (util_1.types.isUint8Array(bufferOrReadStream)) {
             this.stream = new stream_1.Readable();

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

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

package/interfaces/features/custom-route-param-factory.interface.d.ts

@@ -1,4 +1,5 @@
+import { ExecutionContext } from './execution-context.interface';
 /**
  * @publicApi
  */
-export type CustomParamFactory<TData = any, TInput = any, TOutput = any> = (data: TData, input: TInput) => TOutput;
+export type CustomParamFactory<TData = any, TOutput = any> = (data: TData, context: ExecutionContext) => TOutput;

package/interfaces/http/http-exception-body.interface.d.ts

@@ -1,4 +1,4 @@
-export type HttpExceptionBodyMessage = string | string[];
+export type HttpExceptionBodyMessage = string | string[] | number;
 export interface HttpExceptionBody {
     message: HttpExceptionBodyMessage;
     error?: string;

package/interfaces/http/http-server.interface.d.ts

@@ -20,6 +20,20 @@ export interface HttpServer<TRequest = any, TResponse = any, ServerInstance = an
     put(path: string, handler: RequestHandler<TRequest, TResponse>): any;
     patch(handler: RequestHandler<TRequest, TResponse>): any;
     patch(path: string, handler: RequestHandler<TRequest, TResponse>): any;
+    propfind?(handler: RequestHandler<TRequest, TResponse>): any;
+    propfind?(path: string, handler: RequestHandler<TRequest, TResponse>): any;
+    proppatch?(handler: RequestHandler<TRequest, TResponse>): any;
+    proppatch?(path: string, handler: RequestHandler<TRequest, TResponse>): any;
+    mkcol?(handler: RequestHandler<TRequest, TResponse>): any;
+    mkcol?(path: string, handler: RequestHandler<TRequest, TResponse>): any;
+    copy?(handler: RequestHandler<TRequest, TResponse>): any;
+    copy?(path: string, handler: RequestHandler<TRequest, TResponse>): any;
+    move?(handler: RequestHandler<TRequest, TResponse>): any;
+    move?(path: string, handler: RequestHandler<TRequest, TResponse>): any;
+    lock?(handler: RequestHandler<TRequest, TResponse>): any;
+    lock?(path: string, handler: RequestHandler<TRequest, TResponse>): any;
+    unlock?(handler: RequestHandler<TRequest, TResponse>): any;
+    unlock?(path: string, handler: RequestHandler<TRequest, TResponse>): any;
     all(path: string, handler: RequestHandler<TRequest, TResponse>): any;
     all(handler: RequestHandler<TRequest, TResponse>): any;
     options(handler: RequestHandler<TRequest, TResponse>): any;
@@ -53,4 +67,5 @@ export interface HttpServer<TRequest = any, TResponse = any, ServerInstance = an
     getType(): string;
     init?(): Promise<void>;
     applyVersionFilter(handler: Function, version: VersionValue, versioningOptions: VersioningOptions): (req: TRequest, res: TResponse, next: () => void) => Function;
+    normalizePath?(path: string): string;
 }

package/interfaces/middleware/nest-middleware.interface.d.ts

@@ -4,5 +4,5 @@
  * @publicApi
  */
 export interface NestMiddleware<TRequest = any, TResponse = any> {
-    use(req: TRequest, res: TResponse, next: (error?: Error | any) => void): any;
+    use(req: TRequest, res: TResponse, next: (error?: any) => void): any;
 }

package/interfaces/modules/module-metadata.interface.d.ts

@@ -30,5 +30,5 @@ export interface ModuleMetadata {
      * Optional list of the subset of providers that are provided by this module
      * and should be available in other modules which import this module.
      */
-    exports?: Array<DynamicModule | Promise<DynamicModule> | string | symbol | Provider | ForwardReference | Abstract<any> | Function>;
+    exports?: Array<DynamicModule | string | symbol | Provider | ForwardReference | Abstract<any> | Function>;
 }

package/interfaces/nest-application-context-options.interface.d.ts

@@ -38,4 +38,12 @@ export declare class NestApplicationContextOptions {
      * @default false
      */
     snapshot?: boolean;
+    /**
+     * Determines what algorithm use to generate module ids.
+     * When set to `deep-hash`, the module id is generated based on the serialized module definition.
+     * When set to `reference`, each module obtains a unique id based on its reference.
+     *
+     * @default 'reference'
+     */
+    moduleIdGeneratorAlgorithm?: 'deep-hash' | 'reference';
 }

package/interfaces/nest-application-context.interface.d.ts

@@ -1,7 +1,9 @@
 import { ShutdownSignal } from '../enums/shutdown-signal.enum';
 import { LoggerService, LogLevel } from '../services/logger.service';
 import { DynamicModule } from './modules';
+import { NestApplicationContextOptions } from './nest-application-context-options.interface';
 import { Type } from './type.interface';
+export type SelectOptions = Pick<NestApplicationContextOptions, 'abortOnError'>;
 export interface GetOrResolveOptions {
     /**
      * If enabled, lookup will only be performed in the host module.
@@ -25,7 +27,7 @@ export interface INestApplicationContext {
      * Allows navigating through the modules tree, for example, to pull out a specific instance from the selected module.
      * @returns {INestApplicationContext}
      */
-    select<T>(module: Type<T> | DynamicModule): INestApplicationContext;
+    select<T>(module: Type<T> | DynamicModule, options?: SelectOptions): INestApplicationContext;
     /**
      * Retrieves an instance of either injectable or controller, otherwise, throws exception.
      * @returns {TResult}

package/interfaces/nest-microservice.interface.d.ts

@@ -1,3 +1,4 @@
+import { Observable } from 'rxjs';
 import { ExceptionFilter } from './exceptions/exception-filter.interface';
 import { CanActivate } from './features/can-activate.interface';
 import { NestInterceptor } from './features/nest-interceptor.interface';
@@ -17,41 +18,58 @@ export interface INestMicroservice extends INestApplicationContext {
      */
     listen(): Promise<any>;
     /**
-     * Register Ws Adapter which will be used inside Gateways.
-     * Use when you want to override default `socket.io` library.
+     * Registers a web socket adapter that will be used for Gateways.
+     * Use to override the default `socket.io` library.
      *
      * @param {WebSocketAdapter} adapter
      * @returns {this}
      */
     useWebSocketAdapter(adapter: WebSocketAdapter): this;
     /**
-     * Registers exception filters as global filters (will be used within every message pattern handler)
+     * Registers global exception filters (will be used for every pattern handler).
      *
      * @param {...ExceptionFilter} filters
      */
     useGlobalFilters(...filters: ExceptionFilter[]): this;
     /**
-     * Registers pipes as global pipes (will be used within every message pattern handler)
+     * Registers global pipes (will be used for every pattern handler).
      *
      * @param {...PipeTransform} pipes
      */
     useGlobalPipes(...pipes: PipeTransform<any>[]): this;
     /**
-     * Registers interceptors as global interceptors (will be used within every message pattern handler)
+     * Registers global interceptors (will be used for every pattern handler).
      *
      * @param {...NestInterceptor} interceptors
      */
     useGlobalInterceptors(...interceptors: NestInterceptor[]): this;
     /**
-     * Registers guards as global guards (will be used within every message pattern handler)
+     * Registers global guards (will be used for every pattern handler).
      *
      * @param {...CanActivate} guards
      */
     useGlobalGuards(...guards: CanActivate[]): this;
     /**
-     * Terminates the application
+     * Terminates the application.
      *
      * @returns {Promise<void>}
      */
     close(): Promise<void>;
+    /**
+     * Returns an observable that emits status changes.
+     *
+     * @returns {Observable<string>}
+     */
+    status: Observable<string>;
+    /**
+     * Registers an event listener for the given event.
+     * @param event Event name
+     * @param callback Callback to be executed when the event is emitted
+     */
+    on<EventsMap extends Record<string, Function> = Record<string, Function>, EventKey extends keyof EventsMap = keyof EventsMap, EventCallback extends EventsMap[EventKey] = EventsMap[EventKey]>(event: EventKey, callback: EventCallback): void;
+    /**
+     * Returns an instance of the underlying server/broker instance,
+     * or a group of servers if there are more than one.
+     */
+    unwrap<T>(): T;
 }

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

@@ -19,7 +19,8 @@ class ConfigurableModuleBuilder {
             this.staticMethodKey = parentBuilder.staticMethodKey;
             this.factoryClassMethodKey =
                 parentBuilder.factoryClassMethodKey;
-            this.transformModuleDefinition = parentBuilder.transformModuleDefinition;
+            this.transformModuleDefinition =
+                parentBuilder.transformModuleDefinition;
             this.extras = parentBuilder.extras;
         }
     }
@@ -96,8 +97,8 @@ class ConfigurableModuleBuilder {
         };
     }
     constructInjectionTokenString() {
-        const moduleNameInSnakeCase = this.options.moduleName
-            .trim()
+        const moduleNameInSnakeCase = this.options
+            .moduleName.trim()
             .split(/(?=[A-Z])/)
             .join('_')
             .toUpperCase();

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

@@ -1,4 +1,4 @@
-import { Provider, FactoryProvider } from '../../interfaces';
+import { FactoryProvider, Provider } from '../../interfaces';
 /**
  *
  * @param providers List of a module's providers

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/common",
-  "version": "10.4.11",
+  "version": "11.0.0-next.2",
   "description": "Nest - modern, fast, powerful node.js web framework (@common)",
   "author": "Kamil Mysliwiec",
   "homepage": "https://nestjs.com",

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

@@ -15,6 +15,6 @@ export type FileTypeValidatorOptions = {
  * @publicApi
  */
 export declare class FileTypeValidator extends FileValidator<FileTypeValidatorOptions, IFile> {
-    buildErrorMessage(): string;
+    buildErrorMessage(file?: IFile): string;
     isValid(file?: IFile): boolean;
 }

package/pipes/file/file-type.validator.js

@@ -14,7 +14,10 @@ const file_validator_interface_1 = require("./file-validator.interface");
  * @publicApi
  */
 class FileTypeValidator extends file_validator_interface_1.FileValidator {
-    buildErrorMessage() {
+    buildErrorMessage(file) {
+        if (file?.mimetype) {
+            return `Validation failed (current file type is ${file.mimetype}, expected type is ${this.validationOptions.fileType})`;
+        }
         return `Validation failed (expected type is ${this.validationOptions.fileType})`;
     }
     isValid(file) {

package/pipes/file/max-file-size.validator.d.ts

@@ -12,6 +12,6 @@ export type MaxFileSizeValidatorOptions = {
  * @publicApi
  */
 export declare class MaxFileSizeValidator extends FileValidator<MaxFileSizeValidatorOptions, IFile> {
-    buildErrorMessage(): string;
+    buildErrorMessage(file?: IFile): string;
     isValid(file?: IFile): boolean;
 }

package/pipes/file/max-file-size.validator.js

@@ -10,13 +10,16 @@ const file_validator_interface_1 = require("./file-validator.interface");
  * @publicApi
  */
 class MaxFileSizeValidator extends file_validator_interface_1.FileValidator {
-    buildErrorMessage() {
+    buildErrorMessage(file) {
         if ('message' in this.validationOptions) {
             if (typeof this.validationOptions.message === 'function') {
                 return this.validationOptions.message(this.validationOptions.maxSize);
             }
             return this.validationOptions.message;
         }
+        if (file?.size) {
+            return `Validation failed (current file size is ${file.size}, expected size is less than ${this.validationOptions.maxSize})`;
+        }
         return `Validation failed (expected size is less than ${this.validationOptions.maxSize})`;
     }
     isValid(file) {

package/pipes/index.d.ts

@@ -1,9 +1,10 @@
 export * from './default-value.pipe';
+export * from './file';
 export * from './parse-array.pipe';
 export * from './parse-bool.pipe';
-export * from './parse-int.pipe';
-export * from './parse-float.pipe';
+export * from './parse-date.pipe';
 export * from './parse-enum.pipe';
+export * from './parse-float.pipe';
+export * from './parse-int.pipe';
 export * from './parse-uuid.pipe';
 export * from './validation.pipe';
-export * from './file';

package/pipes/index.js

@@ -2,11 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./default-value.pipe"), exports);
+tslib_1.__exportStar(require("./file"), exports);
 tslib_1.__exportStar(require("./parse-array.pipe"), exports);
 tslib_1.__exportStar(require("./parse-bool.pipe"), exports);
-tslib_1.__exportStar(require("./parse-int.pipe"), exports);
-tslib_1.__exportStar(require("./parse-float.pipe"), exports);
+tslib_1.__exportStar(require("./parse-date.pipe"), exports);
 tslib_1.__exportStar(require("./parse-enum.pipe"), exports);
+tslib_1.__exportStar(require("./parse-float.pipe"), exports);
+tslib_1.__exportStar(require("./parse-int.pipe"), exports);
 tslib_1.__exportStar(require("./parse-uuid.pipe"), exports);
 tslib_1.__exportStar(require("./validation.pipe"), exports);
-tslib_1.__exportStar(require("./file"), exports);

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

@@ -5,9 +5,26 @@ import { ValidationPipe, ValidationPipeOptions } from './validation.pipe';
  * @publicApi
  */
 export interface ParseArrayOptions extends Omit<ValidationPipeOptions, 'transform' | 'validateCustomDecorators' | 'exceptionFactory'> {
+    /**
+     * Type for items to be converted into
+     */
     items?: Type<unknown>;
+    /**
+     * Items separator to split string by
+     * @default ','
+     */
     separator?: string;
+    /**
+     * If true, the pipe will return null or undefined if the value is not provided
+     * @default false
+     */
     optional?: boolean;
+    /**
+     * A factory function that returns an exception object to be thrown
+     * if validation fails.
+     * @param error Error message or object
+     * @returns The exception object
+     */
     exceptionFactory?: (error: any) => any;
 }
 /**

package/pipes/parse-array.pipe.js

@@ -70,7 +70,9 @@ let ParseArrayPipe = class ParseArrayPipe {
                     try {
                         item = JSON.parse(item);
                     }
-                    catch { }
+                    catch {
+                        // Do nothing
+                    }
                 }
                 if (isExpectedTypePrimitive) {
                     return this.validatePrimitive(item, index);

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

@@ -4,8 +4,21 @@ import { ErrorHttpStatusCode } from '../utils/http-error-by-code.util';
  * @publicApi
  */
 export interface ParseBoolPipeOptions {
+    /**
+     * 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?: (error: string) => any;
+    /**
+     * If true, the pipe will return null or undefined if the value is not provided
+     * @default false
+     */
     optional?: boolean;
 }
 /**
@@ -16,9 +29,9 @@ export interface ParseBoolPipeOptions {
  * @publicApi
  */
 export declare class ParseBoolPipe implements PipeTransform<string | boolean, Promise<boolean>> {
-    protected readonly options?: ParseBoolPipeOptions;
+    protected readonly options?: ParseBoolPipeOptions | undefined;
     protected exceptionFactory: (error: string) => any;
-    constructor(options?: ParseBoolPipeOptions);
+    constructor(options?: ParseBoolPipeOptions | undefined);
     /**
      * Method that accesses and performs optional transformation on argument for
      * in-flight requests.

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

@@ -0,0 +1,37 @@
+import { PipeTransform } from '../interfaces/features/pipe-transform.interface';
+import { ErrorHttpStatusCode } from '../utils/http-error-by-code.util';
+export interface ParseDatePipeOptions {
+    /**
+     * If true, the pipe will return null or undefined if the value is not provided
+     * @default false
+     */
+    optional?: boolean;
+    /**
+     * Default value for the date
+     */
+    default?: () => Date;
+    /**
+     * 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?: (error: string) => any;
+}
+export declare class ParseDatePipe implements PipeTransform<string | number | undefined | null> {
+    private readonly options;
+    protected exceptionFactory: (error: string) => any;
+    constructor(options?: ParseDatePipeOptions);
+    /**
+     * Method that accesses and performs optional transformation on argument for
+     * in-flight requests.
+     *
+     * @param value currently processed route argument
+     * @param metadata contains metadata about the currently processed route argument
+     */
+    transform(value: string | number | undefined | null): Date | null | undefined;
+}

package/pipes/parse-date.pipe.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseDatePipe = void 0;
+const tslib_1 = require("tslib");
+const injectable_decorator_1 = require("../decorators/core/injectable.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");
+let ParseDatePipe = class ParseDatePipe {
+    constructor(options = {}) {
+        this.options = options;
+        const { exceptionFactory, errorHttpStatusCode = http_status_enum_1.HttpStatus.BAD_REQUEST } = options;
+        this.exceptionFactory =
+            exceptionFactory ||
+                (error => new http_error_by_code_util_1.HttpErrorByCode[errorHttpStatusCode](error));
+    }
+    /**
+     * Method that accesses and performs optional transformation on argument for
+     * in-flight requests.
+     *
+     * @param value currently processed route argument
+     * @param metadata contains metadata about the currently processed route argument
+     */
+    transform(value) {
+        if (this.options.optional && (0, shared_utils_1.isNil)(value)) {
+            return this.options.default ? this.options.default() : value;
+        }
+        if (!value) {
+            throw this.exceptionFactory('Validation failed (no Date provided)');
+        }
+        const transformedValue = new Date(value);
+        if (isNaN(transformedValue.getTime())) {
+            throw this.exceptionFactory('Validation failed (invalid date format)');
+        }
+        return transformedValue;
+    }
+};
+exports.ParseDatePipe = ParseDatePipe;
+exports.ParseDatePipe = ParseDatePipe = tslib_1.__decorate([
+    (0, injectable_decorator_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], ParseDatePipe);

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

@@ -5,8 +5,21 @@ import { ErrorHttpStatusCode } from '../utils/http-error-by-code.util';
  * @publicApi
  */
 export interface ParseEnumPipeOptions {
+    /**
+     * If true, the pipe will return null or undefined if the value is not provided
+     * @default false
+     */
     optional?: boolean;
+    /**
+     * 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?: (error: string) => any;
 }
 /**
@@ -18,9 +31,9 @@ export interface ParseEnumPipeOptions {
  */
 export declare class ParseEnumPipe<T = any> implements PipeTransform<T> {
     protected readonly enumType: T;
-    protected readonly options?: ParseEnumPipeOptions;
+    protected readonly options?: ParseEnumPipeOptions | undefined;
     protected exceptionFactory: (error: string) => any;
-    constructor(enumType: T, options?: ParseEnumPipeOptions);
+    constructor(enumType: T, options?: ParseEnumPipeOptions | undefined);
     /**
      * Method that accesses and performs optional transformation on argument for
      * in-flight requests.

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

@@ -5,8 +5,21 @@ import { ErrorHttpStatusCode } from '../utils/http-error-by-code.util';
  * @publicApi
  */
 export interface ParseFloatPipeOptions {
+    /**
+     * 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?: (error: string) => any;
+    /**
+     * If true, the pipe will return null or undefined if the value is not provided
+     * @default false
+     */
     optional?: boolean;
 }
 /**
@@ -17,9 +30,9 @@ export interface ParseFloatPipeOptions {
  * @publicApi
  */
 export declare class ParseFloatPipe implements PipeTransform<string> {
-    protected readonly options?: ParseFloatPipeOptions;
+    protected readonly options?: ParseFloatPipeOptions | undefined;
     protected exceptionFactory: (error: string) => any;
-    constructor(options?: ParseFloatPipeOptions);
+    constructor(options?: ParseFloatPipeOptions | undefined);
     /**
      * Method that accesses and performs optional transformation on argument for
      * in-flight requests.

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

@@ -4,8 +4,21 @@ import { ErrorHttpStatusCode } from '../utils/http-error-by-code.util';
  * @publicApi
  */
 export interface ParseIntPipeOptions {
+    /**
+     * 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?: (error: string) => any;
+    /**
+     * If true, the pipe will return null or undefined if the value is not provided
+     * @default false
+     */
     optional?: boolean;
 }
 /**
@@ -16,9 +29,9 @@ export interface ParseIntPipeOptions {
  * @publicApi
  */
 export declare class ParseIntPipe implements PipeTransform<string> {
-    protected readonly options?: ParseIntPipeOptions;
+    protected readonly options?: ParseIntPipeOptions | undefined;
     protected exceptionFactory: (error: string) => any;
-    constructor(options?: ParseIntPipeOptions);
+    constructor(options?: ParseIntPipeOptions | undefined);
     /**
      * Method that accesses and performs optional transformation on argument for
      * in-flight requests.