@depup/nestjs__common 11.1.16-depup.1

package/decorators/core/inject.decorator.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Inject = Inject;
+const constants_1 = require("../../constants");
+const shared_utils_1 = require("../../utils/shared.utils");
+/**
+ * Decorator that marks a constructor parameter as a target for
+ * [Dependency Injection (DI)](https://docs.nestjs.com/providers#dependency-injection).
+ *
+ * Any injected provider must be visible within the module scope (loosely
+ * speaking, the containing module) of the class it is being injected into. This
+ * can be done by:
+ *
+ * - defining the provider in the same module scope
+ * - exporting the provider from one module scope and importing that module into the
+ *   module scope of the class being injected into
+ * - exporting the provider from a module that is marked as global using the
+ *   `@Global()` decorator
+ *
+ * #### Injection tokens
+ * Can be *types* (class names), *strings* or *symbols*. This depends on how the
+ * provider with which it is associated was defined. Providers defined with the
+ * `@Injectable()` decorator use the class name. Custom Providers may use strings
+ * or symbols as the injection token.
+ *
+ * @param token lookup key for the provider to be injected (assigned to the constructor
+ * parameter).
+ *
+ * @see [Providers](https://docs.nestjs.com/providers)
+ * @see [Custom Providers](https://docs.nestjs.com/fundamentals/custom-providers)
+ * @see [Injection Scopes](https://docs.nestjs.com/fundamentals/injection-scopes)
+ *
+ * @publicApi
+ */
+function Inject(token) {
+    const injectCallHasArguments = arguments.length > 0;
+    return (target, key, index) => {
+        let type = token || Reflect.getMetadata('design:type', target, key);
+        // Try to infer the token in a constructor-based injection
+        if (!type && !injectCallHasArguments) {
+            type = Reflect.getMetadata(constants_1.PARAMTYPES_METADATA, target, key)?.[index];
+        }
+        if (!(0, shared_utils_1.isUndefined)(index)) {
+            let dependencies = Reflect.getMetadata(constants_1.SELF_DECLARED_DEPS_METADATA, target) || [];
+            dependencies = [...dependencies, { index, param: type }];
+            Reflect.defineMetadata(constants_1.SELF_DECLARED_DEPS_METADATA, dependencies, target);
+            return;
+        }
+        let properties = Reflect.getMetadata(constants_1.PROPERTY_DEPS_METADATA, target.constructor) || [];
+        properties = [...properties, { key, type }];
+        Reflect.defineMetadata(constants_1.PROPERTY_DEPS_METADATA, properties, target.constructor);
+    };
+}

package/decorators/core/injectable.decorator.d.ts

@@ -0,0 +1,43 @@
+import { ScopeOptions } from '../../interfaces/scope-options.interface';
+import { Type } from '../../interfaces/type.interface';
+/**
+ * Defines the injection scope.
+ *
+ * @see [Injection Scopes](https://docs.nestjs.com/fundamentals/injection-scopes)
+ *
+ * @publicApi
+ */
+export type InjectableOptions = ScopeOptions;
+/**
+ * Decorator that marks a class as a [provider](https://docs.nestjs.com/providers).
+ * Providers can be injected into other classes via constructor parameter injection
+ * using Nest's built-in [Dependency Injection (DI)](https://docs.nestjs.com/providers#dependency-injection)
+ * system.
+ *
+ * When injecting a provider, it must be visible within the module scope (loosely
+ * speaking, the containing module) of the class it is being injected into. This
+ * can be done by:
+ *
+ * - defining the provider in the same module scope
+ * - exporting the provider from one module scope and importing that module into the
+ *   module scope of the class being injected into
+ * - exporting the provider from a module that is marked as global using the
+ *   `@Global()` decorator
+ *
+ * Providers can also be defined in a more explicit and imperative form using
+ * various [custom provider](https://docs.nestjs.com/fundamentals/custom-providers) techniques that expose
+ * more capabilities of the DI system.
+ *
+ * @param options options specifying scope of injectable
+ *
+ * @see [Providers](https://docs.nestjs.com/providers)
+ * @see [Custom Providers](https://docs.nestjs.com/fundamentals/custom-providers)
+ * @see [Injection Scopes](https://docs.nestjs.com/fundamentals/injection-scopes)
+ *
+ * @publicApi
+ */
+export declare function Injectable(options?: InjectableOptions): ClassDecorator;
+/**
+ * @publicApi
+ */
+export declare function mixin<T>(mixinClass: Type<T>): Type<T>;

package/decorators/core/injectable.decorator.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Injectable = Injectable;
+exports.mixin = mixin;
+const uid_1 = require("uid");
+const constants_1 = require("../../constants");
+/**
+ * Decorator that marks a class as a [provider](https://docs.nestjs.com/providers).
+ * Providers can be injected into other classes via constructor parameter injection
+ * using Nest's built-in [Dependency Injection (DI)](https://docs.nestjs.com/providers#dependency-injection)
+ * system.
+ *
+ * When injecting a provider, it must be visible within the module scope (loosely
+ * speaking, the containing module) of the class it is being injected into. This
+ * can be done by:
+ *
+ * - defining the provider in the same module scope
+ * - exporting the provider from one module scope and importing that module into the
+ *   module scope of the class being injected into
+ * - exporting the provider from a module that is marked as global using the
+ *   `@Global()` decorator
+ *
+ * Providers can also be defined in a more explicit and imperative form using
+ * various [custom provider](https://docs.nestjs.com/fundamentals/custom-providers) techniques that expose
+ * more capabilities of the DI system.
+ *
+ * @param options options specifying scope of injectable
+ *
+ * @see [Providers](https://docs.nestjs.com/providers)
+ * @see [Custom Providers](https://docs.nestjs.com/fundamentals/custom-providers)
+ * @see [Injection Scopes](https://docs.nestjs.com/fundamentals/injection-scopes)
+ *
+ * @publicApi
+ */
+function Injectable(options) {
+    return (target) => {
+        Reflect.defineMetadata(constants_1.INJECTABLE_WATERMARK, true, target);
+        Reflect.defineMetadata(constants_1.SCOPE_OPTIONS_METADATA, options, target);
+    };
+}
+/**
+ * @publicApi
+ */
+function mixin(mixinClass) {
+    Object.defineProperty(mixinClass, 'name', {
+        value: (0, uid_1.uid)(21),
+    });
+    Injectable()(mixinClass);
+    return mixinClass;
+}

package/decorators/core/optional.decorator.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Parameter decorator for an injected dependency marking the
+ * dependency as optional.
+ *
+ * For example:
+ * ```typescript
+ * constructor(@Optional() @Inject('HTTP_OPTIONS')private readonly httpClient: T) {}
+ * ```
+ *
+ * @see [Optional providers](https://docs.nestjs.com/providers#optional-providers)
+ *
+ * @publicApi
+ */
+export declare function Optional(): PropertyDecorator & ParameterDecorator;

package/decorators/core/optional.decorator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Optional = Optional;
+const constants_1 = require("../../constants");
+const shared_utils_1 = require("../../utils/shared.utils");
+/**
+ * Parameter decorator for an injected dependency marking the
+ * dependency as optional.
+ *
+ * For example:
+ * ```typescript
+ * constructor(@Optional() @Inject('HTTP_OPTIONS')private readonly httpClient: T) {}
+ * ```
+ *
+ * @see [Optional providers](https://docs.nestjs.com/providers#optional-providers)
+ *
+ * @publicApi
+ */
+function Optional() {
+    return (target, key, index) => {
+        if (!(0, shared_utils_1.isUndefined)(index)) {
+            const args = Reflect.getMetadata(constants_1.OPTIONAL_DEPS_METADATA, target) || [];
+            Reflect.defineMetadata(constants_1.OPTIONAL_DEPS_METADATA, [...args, index], target);
+            return;
+        }
+        const properties = Reflect.getMetadata(constants_1.OPTIONAL_PROPERTY_DEPS_METADATA, target.constructor) || [];
+        Reflect.defineMetadata(constants_1.OPTIONAL_PROPERTY_DEPS_METADATA, [...properties, key], target.constructor);
+    };
+}

package/decorators/core/set-metadata.decorator.d.ts

@@ -0,0 +1,20 @@
+export type CustomDecorator<TKey = string> = MethodDecorator & ClassDecorator & {
+    KEY: TKey;
+};
+/**
+ * Decorator that assigns metadata to the class/function using the
+ * specified `key`.
+ *
+ * Requires two parameters:
+ * - `key` - a value defining the key under which the metadata is stored
+ * - `value` - metadata to be associated with `key`
+ *
+ * This metadata can be reflected using the `Reflector` class.
+ *
+ * Example: `@SetMetadata('roles', ['admin'])`
+ *
+ * @see [Reflection](https://docs.nestjs.com/fundamentals/execution-context#reflection-and-metadata)
+ *
+ * @publicApi
+ */
+export declare const SetMetadata: <K = string, V = any>(metadataKey: K, metadataValue: V) => CustomDecorator<K>;

package/decorators/core/set-metadata.decorator.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetMetadata = void 0;
+/**
+ * Decorator that assigns metadata to the class/function using the
+ * specified `key`.
+ *
+ * Requires two parameters:
+ * - `key` - a value defining the key under which the metadata is stored
+ * - `value` - metadata to be associated with `key`
+ *
+ * This metadata can be reflected using the `Reflector` class.
+ *
+ * Example: `@SetMetadata('roles', ['admin'])`
+ *
+ * @see [Reflection](https://docs.nestjs.com/fundamentals/execution-context#reflection-and-metadata)
+ *
+ * @publicApi
+ */
+const SetMetadata = (metadataKey, metadataValue) => {
+    const decoratorFactory = (target, key, descriptor) => {
+        if (descriptor) {
+            Reflect.defineMetadata(metadataKey, metadataValue, descriptor.value);
+            return descriptor;
+        }
+        Reflect.defineMetadata(metadataKey, metadataValue, target);
+        return target;
+    };
+    decoratorFactory.KEY = metadataKey;
+    return decoratorFactory;
+};
+exports.SetMetadata = SetMetadata;

package/decorators/core/use-guards.decorator.d.ts

@@ -0,0 +1,23 @@
+import { CanActivate } from '../../interfaces';
+/**
+ * Decorator that binds guards to the scope of the controller or method,
+ * depending on its context.
+ *
+ * When `@UseGuards` is used at the controller level, the guard will be
+ * applied to every handler (method) in the controller.
+ *
+ * When `@UseGuards` is used at the individual handler level, the guard
+ * will apply only to that specific method.
+ *
+ * @param guards a single guard instance or class, or a list of guard instances
+ * or classes.
+ *
+ * @see [Guards](https://docs.nestjs.com/guards)
+ *
+ * @usageNotes
+ * Guards can also be set up globally for all controllers and routes
+ * using `app.useGlobalGuards()`.  [See here for details](https://docs.nestjs.com/guards#binding-guards)
+ *
+ * @publicApi
+ */
+export declare function UseGuards(...guards: (CanActivate | Function)[]): MethodDecorator & ClassDecorator;

package/decorators/core/use-guards.decorator.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UseGuards = UseGuards;
+const constants_1 = require("../../constants");
+const extend_metadata_util_1 = require("../../utils/extend-metadata.util");
+const shared_utils_1 = require("../../utils/shared.utils");
+const validate_each_util_1 = require("../../utils/validate-each.util");
+/**
+ * Decorator that binds guards to the scope of the controller or method,
+ * depending on its context.
+ *
+ * When `@UseGuards` is used at the controller level, the guard will be
+ * applied to every handler (method) in the controller.
+ *
+ * When `@UseGuards` is used at the individual handler level, the guard
+ * will apply only to that specific method.
+ *
+ * @param guards a single guard instance or class, or a list of guard instances
+ * or classes.
+ *
+ * @see [Guards](https://docs.nestjs.com/guards)
+ *
+ * @usageNotes
+ * Guards can also be set up globally for all controllers and routes
+ * using `app.useGlobalGuards()`.  [See here for details](https://docs.nestjs.com/guards#binding-guards)
+ *
+ * @publicApi
+ */
+function UseGuards(...guards) {
+    return (target, key, descriptor) => {
+        const isGuardValid = (guard) => guard && ((0, shared_utils_1.isFunction)(guard) || (0, shared_utils_1.isFunction)(guard.canActivate));
+        if (descriptor) {
+            (0, validate_each_util_1.validateEach)(target.constructor, guards, isGuardValid, '@UseGuards', 'guard');
+            (0, extend_metadata_util_1.extendArrayMetadata)(constants_1.GUARDS_METADATA, guards, descriptor.value);
+            return descriptor;
+        }
+        (0, validate_each_util_1.validateEach)(target, guards, isGuardValid, '@UseGuards', 'guard');
+        (0, extend_metadata_util_1.extendArrayMetadata)(constants_1.GUARDS_METADATA, guards, target);
+        return target;
+    };
+}

package/decorators/core/use-interceptors.decorator.d.ts

@@ -0,0 +1,23 @@
+import { NestInterceptor } from '../../interfaces';
+/**
+ * Decorator that binds interceptors to the scope of the controller or method,
+ * depending on its context.
+ *
+ * When `@UseInterceptors` is used at the controller level, the interceptor will
+ * be applied to every handler (method) in the controller.
+ *
+ * When `@UseInterceptors` is used at the individual handler level, the interceptor
+ * will apply only to that specific method.
+ *
+ * @param interceptors a single interceptor instance or class, or a list of
+ * interceptor instances or classes.
+ *
+ * @see [Interceptors](https://docs.nestjs.com/interceptors)
+ *
+ * @usageNotes
+ * Interceptors can also be set up globally for all controllers and routes
+ * using `app.useGlobalInterceptors()`.  [See here for details](https://docs.nestjs.com/interceptors#binding-interceptors)
+ *
+ * @publicApi
+ */
+export declare function UseInterceptors(...interceptors: (NestInterceptor | Function)[]): MethodDecorator & ClassDecorator;

package/decorators/core/use-interceptors.decorator.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UseInterceptors = UseInterceptors;
+const constants_1 = require("../../constants");
+const extend_metadata_util_1 = require("../../utils/extend-metadata.util");
+const shared_utils_1 = require("../../utils/shared.utils");
+const validate_each_util_1 = require("../../utils/validate-each.util");
+/**
+ * Decorator that binds interceptors to the scope of the controller or method,
+ * depending on its context.
+ *
+ * When `@UseInterceptors` is used at the controller level, the interceptor will
+ * be applied to every handler (method) in the controller.
+ *
+ * When `@UseInterceptors` is used at the individual handler level, the interceptor
+ * will apply only to that specific method.
+ *
+ * @param interceptors a single interceptor instance or class, or a list of
+ * interceptor instances or classes.
+ *
+ * @see [Interceptors](https://docs.nestjs.com/interceptors)
+ *
+ * @usageNotes
+ * Interceptors can also be set up globally for all controllers and routes
+ * using `app.useGlobalInterceptors()`.  [See here for details](https://docs.nestjs.com/interceptors#binding-interceptors)
+ *
+ * @publicApi
+ */
+function UseInterceptors(...interceptors) {
+    return (target, key, descriptor) => {
+        const isInterceptorValid = (interceptor) => interceptor &&
+            ((0, shared_utils_1.isFunction)(interceptor) || (0, shared_utils_1.isFunction)(interceptor.intercept));
+        if (descriptor) {
+            (0, validate_each_util_1.validateEach)(target.constructor, interceptors, isInterceptorValid, '@UseInterceptors', 'interceptor');
+            (0, extend_metadata_util_1.extendArrayMetadata)(constants_1.INTERCEPTORS_METADATA, interceptors, descriptor.value);
+            return descriptor;
+        }
+        (0, validate_each_util_1.validateEach)(target, interceptors, isInterceptorValid, '@UseInterceptors', 'interceptor');
+        (0, extend_metadata_util_1.extendArrayMetadata)(constants_1.INTERCEPTORS_METADATA, interceptors, target);
+        return target;
+    };
+}

package/decorators/core/use-pipes.decorator.d.ts

@@ -0,0 +1,23 @@
+import { PipeTransform } from '../../interfaces/index';
+/**
+ * Decorator that binds pipes to the scope of the controller or method,
+ * depending on its context.
+ *
+ * When `@UsePipes` is used at the controller level, the pipe will be
+ * applied to every handler (method) in the controller.
+ *
+ * When `@UsePipes` is used at the individual handler level, the pipe
+ * will apply only to that specific method.
+ *
+ * @param pipes a single pipe instance or class, or a list of pipe instances or
+ * classes.
+ *
+ * @see [Pipes](https://docs.nestjs.com/pipes)
+ *
+ * @usageNotes
+ * Pipes can also be set up globally for all controllers and routes
+ * using `app.useGlobalPipes()`.  [See here for details](https://docs.nestjs.com/pipes#class-validator)
+ *
+ * @publicApi
+ */
+export declare function UsePipes(...pipes: (PipeTransform | Function)[]): ClassDecorator & MethodDecorator;

package/decorators/core/use-pipes.decorator.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsePipes = UsePipes;
+const constants_1 = require("../../constants");
+const extend_metadata_util_1 = require("../../utils/extend-metadata.util");
+const shared_utils_1 = require("../../utils/shared.utils");
+const validate_each_util_1 = require("../../utils/validate-each.util");
+/**
+ * Decorator that binds pipes to the scope of the controller or method,
+ * depending on its context.
+ *
+ * When `@UsePipes` is used at the controller level, the pipe will be
+ * applied to every handler (method) in the controller.
+ *
+ * When `@UsePipes` is used at the individual handler level, the pipe
+ * will apply only to that specific method.
+ *
+ * @param pipes a single pipe instance or class, or a list of pipe instances or
+ * classes.
+ *
+ * @see [Pipes](https://docs.nestjs.com/pipes)
+ *
+ * @usageNotes
+ * Pipes can also be set up globally for all controllers and routes
+ * using `app.useGlobalPipes()`.  [See here for details](https://docs.nestjs.com/pipes#class-validator)
+ *
+ * @publicApi
+ */
+function UsePipes(...pipes) {
+    return (target, key, descriptor) => {
+        const isPipeValid = (pipe) => pipe && ((0, shared_utils_1.isFunction)(pipe) || (0, shared_utils_1.isFunction)(pipe.transform));
+        if (descriptor) {
+            (0, extend_metadata_util_1.extendArrayMetadata)(constants_1.PIPES_METADATA, pipes, descriptor.value);
+            return descriptor;
+        }
+        (0, validate_each_util_1.validateEach)(target, pipes, isPipeValid, '@UsePipes', 'pipe');
+        (0, extend_metadata_util_1.extendArrayMetadata)(constants_1.PIPES_METADATA, pipes, target);
+        return target;
+    };
+}

package/decorators/core/version.decorator.d.ts

@@ -0,0 +1,7 @@
+import { VersionValue } from '../../interfaces/version-options.interface';
+/**
+ * Sets the version of the endpoint to the passed version
+ *
+ * @publicApi
+ */
+export declare function Version(version: VersionValue): MethodDecorator;

package/decorators/core/version.decorator.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Version = Version;
+const constants_1 = require("../../constants");
+/**
+ * Sets the version of the endpoint to the passed version
+ *
+ * @publicApi
+ */
+function Version(version) {
+    if (Array.isArray(version)) {
+        // Drop duplicated versions
+        version = Array.from(new Set(version));
+    }
+    return (target, key, descriptor) => {
+        Reflect.defineMetadata(constants_1.VERSION_METADATA, version, descriptor.value);
+        return descriptor;
+    };
+}

package/decorators/http/create-route-param-metadata.decorator.d.ts

@@ -0,0 +1,13 @@
+import { PipeTransform } from '../../index';
+import { Type } from '../../interfaces';
+import { CustomParamFactory } from '../../interfaces/features/custom-route-param-factory.interface';
+export type ParamDecoratorEnhancer = ParameterDecorator;
+/**
+ * Defines HTTP route param decorator
+ *
+ * @param factory
+ * @param enhancers
+ *
+ * @publicApi
+ */
+export declare function createParamDecorator<FactoryData = any, FactoryOutput = any>(factory: CustomParamFactory<FactoryData, FactoryOutput>, enhancers?: ParamDecoratorEnhancer[]): (...dataOrPipes: (Type<PipeTransform> | PipeTransform | FactoryData)[]) => ParameterDecorator;

package/decorators/http/create-route-param-metadata.decorator.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createParamDecorator = createParamDecorator;
+const uid_1 = require("uid");
+const constants_1 = require("../../constants");
+const assign_custom_metadata_util_1 = require("../../utils/assign-custom-metadata.util");
+const shared_utils_1 = require("../../utils/shared.utils");
+/**
+ * Defines HTTP route param decorator
+ *
+ * @param factory
+ * @param enhancers
+ *
+ * @publicApi
+ */
+function createParamDecorator(factory, enhancers = []) {
+    const paramtype = (0, uid_1.uid)(21);
+    return (data, ...pipes) => (target, key, index) => {
+        const args = Reflect.getMetadata(constants_1.ROUTE_ARGS_METADATA, target.constructor, key) ||
+            {};
+        const isPipe = (pipe) => pipe &&
+            (((0, shared_utils_1.isFunction)(pipe) &&
+                pipe.prototype &&
+                (0, shared_utils_1.isFunction)(pipe.prototype.transform)) ||
+                (0, shared_utils_1.isFunction)(pipe.transform));
+        const hasParamData = (0, shared_utils_1.isNil)(data) || !isPipe(data);
+        const paramData = hasParamData ? data : undefined;
+        const paramPipes = hasParamData ? pipes : [data, ...pipes];
+        Reflect.defineMetadata(constants_1.ROUTE_ARGS_METADATA, (0, assign_custom_metadata_util_1.assignCustomParameterMetadata)(args, paramtype, index, factory, paramData, ...paramPipes), target.constructor, key);
+        enhancers.forEach(fn => fn(target, key, index));
+    };
+}

package/decorators/http/header.decorator.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Request method Decorator.  Sets a response header.
+ *
+ * For example:
+ * `@Header('Cache-Control', 'none')`
+ * `@Header('Cache-Control', () => 'none')`
+ *
+ * @param name string to be used for header name
+ * @param value string to be used for header value
+ *
+ * @see [Headers](https://docs.nestjs.com/controllers#headers)
+ *
+ * @publicApi
+ */
+export declare function Header(name: string, value: string | (() => string)): MethodDecorator;

package/decorators/http/header.decorator.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Header = Header;
+const constants_1 = require("../../constants");
+const extend_metadata_util_1 = require("../../utils/extend-metadata.util");
+/**
+ * Request method Decorator.  Sets a response header.
+ *
+ * For example:
+ * `@Header('Cache-Control', 'none')`
+ * `@Header('Cache-Control', () => 'none')`
+ *
+ * @param name string to be used for header name
+ * @param value string to be used for header value
+ *
+ * @see [Headers](https://docs.nestjs.com/controllers#headers)
+ *
+ * @publicApi
+ */
+function Header(name, value) {
+    return (target, key, descriptor) => {
+        (0, extend_metadata_util_1.extendArrayMetadata)(constants_1.HEADERS_METADATA, [{ name, value }], descriptor.value);
+        return descriptor;
+    };
+}

package/decorators/http/http-code.decorator.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Request method Decorator.  Defines the HTTP response status code.  Overrides
+ * default status code for the decorated request method.
+ *
+ * @param statusCode HTTP response code to be returned by route handler.
+ *
+ * @see [Http Status Codes](https://docs.nestjs.com/controllers#status-code)
+ *
+ * @publicApi
+ */
+export declare function HttpCode(statusCode: number): MethodDecorator;

package/decorators/http/http-code.decorator.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpCode = HttpCode;
+const constants_1 = require("../../constants");
+/**
+ * Request method Decorator.  Defines the HTTP response status code.  Overrides
+ * default status code for the decorated request method.
+ *
+ * @param statusCode HTTP response code to be returned by route handler.
+ *
+ * @see [Http Status Codes](https://docs.nestjs.com/controllers#status-code)
+ *
+ * @publicApi
+ */
+function HttpCode(statusCode) {
+    return (target, key, descriptor) => {
+        Reflect.defineMetadata(constants_1.HTTP_CODE_METADATA, statusCode, descriptor.value);
+        return descriptor;
+    };
+}

package/decorators/http/index.d.ts

@@ -0,0 +1,8 @@
+export * from './request-mapping.decorator';
+export * from './route-params.decorator';
+export * from './http-code.decorator';
+export * from './create-route-param-metadata.decorator';
+export * from './render.decorator';
+export * from './header.decorator';
+export * from './redirect.decorator';
+export * from './sse.decorator';

package/decorators/http/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./request-mapping.decorator"), exports);
+tslib_1.__exportStar(require("./route-params.decorator"), exports);
+tslib_1.__exportStar(require("./http-code.decorator"), exports);
+tslib_1.__exportStar(require("./create-route-param-metadata.decorator"), exports);
+tslib_1.__exportStar(require("./render.decorator"), exports);
+tslib_1.__exportStar(require("./header.decorator"), exports);
+tslib_1.__exportStar(require("./redirect.decorator"), exports);
+tslib_1.__exportStar(require("./sse.decorator"), exports);

package/decorators/http/redirect.decorator.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Redirects request to the specified URL.
+ *
+ * @publicApi
+ */
+export declare function Redirect(url?: string, statusCode?: number): MethodDecorator;

package/decorators/http/redirect.decorator.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Redirect = Redirect;
+const constants_1 = require("../../constants");
+/**
+ * Redirects request to the specified URL.
+ *
+ * @publicApi
+ */
+function Redirect(url = '', statusCode) {
+    return (target, key, descriptor) => {
+        Reflect.defineMetadata(constants_1.REDIRECT_METADATA, { statusCode, url }, descriptor.value);
+        return descriptor;
+    };
+}