@depup/nestjs__core 11.1.17-depup.0

package/guards/guards-consumer.d.ts

@@ -0,0 +1,9 @@
+import { CanActivate } from '@nestjs/common';
+import { ContextType, Controller } from '@nestjs/common/interfaces';
+import { Observable } from 'rxjs';
+import { ExecutionContextHost } from '../helpers/execution-context-host';
+export declare class GuardsConsumer {
+    tryActivate<TContext extends string = ContextType>(guards: CanActivate[], args: unknown[], instance: Controller, callback: (...args: unknown[]) => unknown, type?: TContext): Promise<boolean>;
+    createContext(args: unknown[], instance: Controller, callback: (...args: unknown[]) => unknown): ExecutionContextHost;
+    pickResult(result: boolean | Promise<boolean> | Observable<boolean>): Promise<boolean>;
+}

package/guards/guards-consumer.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuardsConsumer = void 0;
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const rxjs_1 = require("rxjs");
+const execution_context_host_1 = require("../helpers/execution-context-host");
+class GuardsConsumer {
+    async tryActivate(guards, args, instance, callback, type) {
+        if (!guards || (0, shared_utils_1.isEmpty)(guards)) {
+            return true;
+        }
+        const context = this.createContext(args, instance, callback);
+        context.setType(type);
+        for (const guard of guards) {
+            const result = guard.canActivate(context);
+            if (typeof result === 'boolean') {
+                if (!result) {
+                    return false;
+                }
+                continue;
+            }
+            if (await this.pickResult(result)) {
+                continue;
+            }
+            return false;
+        }
+        return true;
+    }
+    createContext(args, instance, callback) {
+        return new execution_context_host_1.ExecutionContextHost(args, instance.constructor, callback);
+    }
+    async pickResult(result) {
+        if (result instanceof rxjs_1.Observable) {
+            return (0, rxjs_1.lastValueFrom)(result);
+        }
+        return result;
+    }
+}
+exports.GuardsConsumer = GuardsConsumer;

package/guards/guards-context-creator.d.ts

@@ -0,0 +1,17 @@
+import { CanActivate } from '@nestjs/common';
+import { Controller, Type } from '@nestjs/common/interfaces';
+import { ApplicationConfig } from '../application-config';
+import { ContextCreator } from '../helpers/context-creator';
+import { NestContainer } from '../injector/container';
+import { InstanceWrapper } from '../injector/instance-wrapper';
+export declare class GuardsContextCreator extends ContextCreator {
+    private readonly container;
+    private readonly config?;
+    private moduleContext;
+    constructor(container: NestContainer, config?: ApplicationConfig | undefined);
+    create(instance: Controller, callback: (...args: unknown[]) => unknown, module: string, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): CanActivate[];
+    createConcreteContext<T extends unknown[], R extends unknown[]>(metadata: T, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): R;
+    getGuardInstance(metatype: Function | CanActivate, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): CanActivate | null;
+    getInstanceByMetatype(metatype: Type<unknown>): InstanceWrapper | undefined;
+    getGlobalMetadata<T extends unknown[]>(contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): T;
+}

package/guards/guards-context-creator.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuardsContextCreator = void 0;
+const constants_1 = require("@nestjs/common/constants");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const iterare_1 = require("iterare");
+const context_creator_1 = require("../helpers/context-creator");
+const constants_2 = require("../injector/constants");
+class GuardsContextCreator extends context_creator_1.ContextCreator {
+    constructor(container, config) {
+        super();
+        this.container = container;
+        this.config = config;
+    }
+    create(instance, callback, module, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+        this.moduleContext = module;
+        return this.createContext(instance, callback, constants_1.GUARDS_METADATA, contextId, inquirerId);
+    }
+    createConcreteContext(metadata, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+        if ((0, shared_utils_1.isEmpty)(metadata)) {
+            return [];
+        }
+        return (0, iterare_1.iterate)(metadata)
+            .filter((guard) => guard && (guard.name || guard.canActivate))
+            .map(guard => this.getGuardInstance(guard, contextId, inquirerId))
+            .filter((guard) => !!guard && (0, shared_utils_1.isFunction)(guard.canActivate))
+            .toArray();
+    }
+    getGuardInstance(metatype, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+        const isObject = !!metatype.canActivate;
+        if (isObject) {
+            return metatype;
+        }
+        const instanceWrapper = this.getInstanceByMetatype(metatype);
+        if (!instanceWrapper) {
+            return null;
+        }
+        const instanceHost = instanceWrapper.getInstanceByContextId(this.getContextId(contextId, instanceWrapper), inquirerId);
+        return instanceHost && instanceHost.instance;
+    }
+    getInstanceByMetatype(metatype) {
+        if (!this.moduleContext) {
+            return;
+        }
+        const collection = this.container.getModules();
+        const moduleRef = collection.get(this.moduleContext);
+        if (!moduleRef) {
+            return;
+        }
+        const injectables = moduleRef.injectables;
+        return injectables.get(metatype);
+    }
+    getGlobalMetadata(contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+        if (!this.config) {
+            return [];
+        }
+        const globalGuards = this.config.getGlobalGuards();
+        if (contextId === constants_2.STATIC_CONTEXT && !inquirerId) {
+            return globalGuards;
+        }
+        const scopedGuardWrappers = this.config.getGlobalRequestGuards();
+        const scopedGuards = (0, iterare_1.iterate)(scopedGuardWrappers)
+            .map(wrapper => wrapper.getInstanceByContextId(this.getContextId(contextId, wrapper), inquirerId))
+            .filter(host => !!host)
+            .map(host => host.instance)
+            .toArray();
+        return globalGuards.concat(scopedGuards);
+    }
+}
+exports.GuardsContextCreator = GuardsContextCreator;

package/guards/index.d.ts

@@ -0,0 +1,3 @@
+export * from './constants';
+export * from './guards-consumer';
+export * from './guards-context-creator';

package/guards/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./constants"), exports);
+tslib_1.__exportStar(require("./guards-consumer"), exports);
+tslib_1.__exportStar(require("./guards-context-creator"), exports);

package/helpers/barrier.d.ts

@@ -0,0 +1,30 @@
+/**
+ * A simple barrier to synchronize flow of multiple async operations.
+ */
+export declare class Barrier {
+    private currentCount;
+    private targetCount;
+    private promise;
+    private resolve;
+    constructor(targetCount: number);
+    /**
+     * Signal that a participant has reached the barrier.
+     *
+     * The barrier will be resolved once `targetCount` participants have reached it.
+     */
+    signal(): void;
+    /**
+     * Wait for the barrier to be resolved.
+     *
+     * @returns A promise that resolves when the barrier is resolved.
+     */
+    wait(): Promise<void>;
+    /**
+     * Signal that a participant has reached the barrier and wait for the barrier to be resolved.
+     *
+     * The barrier will be resolved once `targetCount` participants have reached it.
+     *
+     * @returns A promise that resolves when the barrier is resolved.
+     */
+    signalAndWait(): Promise<void>;
+}

package/helpers/barrier.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Barrier = void 0;
+/**
+ * A simple barrier to synchronize flow of multiple async operations.
+ */
+class Barrier {
+    constructor(targetCount) {
+        this.currentCount = 0;
+        this.targetCount = targetCount;
+        this.promise = new Promise(resolve => {
+            this.resolve = resolve;
+        });
+    }
+    /**
+     * Signal that a participant has reached the barrier.
+     *
+     * The barrier will be resolved once `targetCount` participants have reached it.
+     */
+    signal() {
+        this.currentCount += 1;
+        if (this.currentCount === this.targetCount) {
+            this.resolve();
+        }
+    }
+    /**
+     * Wait for the barrier to be resolved.
+     *
+     * @returns A promise that resolves when the barrier is resolved.
+     */
+    async wait() {
+        return this.promise;
+    }
+    /**
+     * Signal that a participant has reached the barrier and wait for the barrier to be resolved.
+     *
+     * The barrier will be resolved once `targetCount` participants have reached it.
+     *
+     * @returns A promise that resolves when the barrier is resolved.
+     */
+    async signalAndWait() {
+        this.signal();
+        return this.wait();
+    }
+}
+exports.Barrier = Barrier;

package/helpers/context-creator.d.ts

@@ -0,0 +1,10 @@
+import { Controller } from '@nestjs/common/interfaces';
+import { ContextId, InstanceWrapper } from '../injector/instance-wrapper';
+export declare abstract class ContextCreator {
+    abstract createConcreteContext<T extends any[], R extends any[]>(metadata: T, contextId?: ContextId, inquirerId?: string): R;
+    getGlobalMetadata?<T extends any[]>(contextId?: ContextId, inquirerId?: string): T;
+    createContext<T extends unknown[] = any, R extends unknown[] = any>(instance: Controller, callback: (...args: any[]) => void, metadataKey: string, contextId?: ContextId, inquirerId?: string): R;
+    reflectClassMetadata<T>(instance: Controller, metadataKey: string): T;
+    reflectMethodMetadata<T>(callback: (...args: unknown[]) => unknown, metadataKey: string): T;
+    protected getContextId(contextId: ContextId, instanceWrapper: InstanceWrapper): ContextId;
+}

package/helpers/context-creator.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextCreator = void 0;
+const constants_1 = require("../injector/constants");
+class ContextCreator {
+    createContext(instance, callback, metadataKey, contextId = constants_1.STATIC_CONTEXT, inquirerId) {
+        const globalMetadata = this.getGlobalMetadata &&
+            this.getGlobalMetadata(contextId, inquirerId);
+        const classMetadata = this.reflectClassMetadata(instance, metadataKey);
+        const methodMetadata = this.reflectMethodMetadata(callback, metadataKey);
+        return [
+            ...this.createConcreteContext(globalMetadata || [], contextId, inquirerId),
+            ...this.createConcreteContext(classMetadata, contextId, inquirerId),
+            ...this.createConcreteContext(methodMetadata, contextId, inquirerId),
+        ];
+    }
+    reflectClassMetadata(instance, metadataKey) {
+        const prototype = Object.getPrototypeOf(instance);
+        return Reflect.getMetadata(metadataKey, prototype.constructor);
+    }
+    reflectMethodMetadata(callback, metadataKey) {
+        return Reflect.getMetadata(metadataKey, callback);
+    }
+    getContextId(contextId, instanceWrapper) {
+        return contextId.getParent
+            ? contextId.getParent({
+                token: instanceWrapper.token,
+                isTreeDurable: instanceWrapper.isDependencyTreeDurable(),
+            })
+            : contextId;
+    }
+}
+exports.ContextCreator = ContextCreator;

package/helpers/context-id-factory.d.ts

@@ -0,0 +1,41 @@
+import { ContextId, HostComponentInfo } from '../injector/instance-wrapper';
+export declare function createContextId(): ContextId;
+export type ContextIdResolverFn = (info: HostComponentInfo) => ContextId;
+export interface ContextIdResolver {
+    /**
+     * Payload associated with the custom context id
+     */
+    payload: unknown;
+    /**
+     * A context id resolver function
+     */
+    resolve: ContextIdResolverFn;
+}
+export interface ContextIdStrategy<T = any> {
+    /**
+     * Allows to attach a parent context id to the existing child context id.
+     * This lets you construct durable DI sub-trees that can be shared between contexts.
+     * @param contextId auto-generated child context id
+     * @param request request object
+     */
+    attach(contextId: ContextId, request: T): ContextIdResolverFn | ContextIdResolver | undefined;
+}
+export declare class ContextIdFactory {
+    private static strategy?;
+    /**
+     * Generates a context identifier based on the request object.
+     */
+    static create(): ContextId;
+    /**
+     * Generates a random identifier to track asynchronous execution context.
+     * @param request request object
+     */
+    static getByRequest<T extends Record<any, any> = any>(request: T, propsToInspect?: string[]): ContextId;
+    /**
+     * Registers a custom context id strategy that lets you attach
+     * a parent context id to the existing context id object.
+     * @param strategy strategy instance
+     */
+    static apply(strategy: ContextIdStrategy): void;
+    private static isContextIdResolverWithPayload;
+}

package/helpers/context-id-factory.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextIdFactory = void 0;
+exports.createContextId = createContextId;
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const request_constants_1 = require("../router/request/request-constants");
+function createContextId() {
+    /**
+     * We are generating random identifier to track asynchronous
+     * execution context. An identifier does not have to be neither unique
+     * nor unpredictable because WeakMap uses objects as keys (reference comparison).
+     * Thus, even though identifier number might be equal, WeakMap would properly
+     * associate asynchronous context with its internal map values using object reference.
+     * Object is automatically removed once request has been processed (closure).
+     */
+    return { id: Math.random() };
+}
+class ContextIdFactory {
+    /**
+     * Generates a context identifier based on the request object.
+     */
+    static create() {
+        return createContextId();
+    }
+    /**
+     * Generates a random identifier to track asynchronous execution context.
+     * @param request request object
+     */
+    static getByRequest(request, propsToInspect = ['raw']) {
+        if (!request) {
+            return ContextIdFactory.create();
+        }
+        if (request[request_constants_1.REQUEST_CONTEXT_ID]) {
+            return request[request_constants_1.REQUEST_CONTEXT_ID];
+        }
+        for (const key of propsToInspect) {
+            if (request[key]?.[request_constants_1.REQUEST_CONTEXT_ID]) {
+                return request[key][request_constants_1.REQUEST_CONTEXT_ID];
+            }
+        }
+        if (!this.strategy) {
+            return ContextIdFactory.create();
+        }
+        const contextId = createContextId();
+        const resolverObjectOrFunction = this.strategy.attach(contextId, request);
+        if (this.isContextIdResolverWithPayload(resolverObjectOrFunction)) {
+            contextId.getParent = resolverObjectOrFunction.resolve;
+            contextId.payload = resolverObjectOrFunction.payload;
+        }
+        else {
+            contextId.getParent = resolverObjectOrFunction;
+        }
+        return contextId;
+    }
+    /**
+     * Registers a custom context id strategy that lets you attach
+     * a parent context id to the existing context id object.
+     * @param strategy strategy instance
+     */
+    static apply(strategy) {
+        this.strategy = strategy;
+    }
+    static isContextIdResolverWithPayload(resolverOrResolverFn) {
+        return (0, shared_utils_1.isObject)(resolverOrResolverFn);
+    }
+}
+exports.ContextIdFactory = ContextIdFactory;

package/helpers/context-utils.d.ts

@@ -0,0 +1,23 @@
+import { ParamData } from '@nestjs/common';
+import { ContextType, Controller, PipeTransform } from '@nestjs/common/interfaces';
+import { ExecutionContextHost } from './execution-context-host';
+export interface ParamProperties<T = any, IExtractor extends Function = any> {
+    index: number;
+    type: T | string;
+    data: ParamData;
+    pipes: PipeTransform[];
+    extractValue: IExtractor;
+}
+export declare class ContextUtils {
+    mapParamType(key: string): string;
+    reflectCallbackParamtypes(instance: Controller, methodName: string): any[];
+    reflectCallbackMetadata<T = any>(instance: Controller, methodName: string, metadataKey: string): T;
+    reflectPassthrough(instance: Controller, methodName: string): boolean;
+    getArgumentsLength<T>(keys: string[], metadata: T): number;
+    createNullArray(length: number): any[];
+    mergeParamsMetatypes(paramsProperties: ParamProperties[], paramtypes: any[]): (ParamProperties & {
+        metatype?: any;
+    })[];
+    getCustomFactory(factory: (...args: unknown[]) => void, data: unknown, contextFactory: (args: unknown[]) => ExecutionContextHost): (...args: unknown[]) => unknown;
+    getContextFactory<TContext extends string = ContextType>(contextType: TContext, instance?: object, callback?: Function): (args: unknown[]) => ExecutionContextHost;
+}

package/helpers/context-utils.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextUtils = void 0;
+const constants_1 = require("@nestjs/common/constants");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const execution_context_host_1 = require("./execution-context-host");
+class ContextUtils {
+    mapParamType(key) {
+        const keyPair = key.split(':');
+        return keyPair[0];
+    }
+    reflectCallbackParamtypes(instance, methodName) {
+        return Reflect.getMetadata(constants_1.PARAMTYPES_METADATA, instance, methodName);
+    }
+    reflectCallbackMetadata(instance, methodName, metadataKey) {
+        return Reflect.getMetadata(metadataKey, instance.constructor, methodName);
+    }
+    reflectPassthrough(instance, methodName) {
+        return Reflect.getMetadata(constants_1.RESPONSE_PASSTHROUGH_METADATA, instance.constructor, methodName);
+    }
+    getArgumentsLength(keys, metadata) {
+        return keys.length
+            ? Math.max(...keys.map(key => metadata[key].index)) + 1
+            : 0;
+    }
+    createNullArray(length) {
+        const a = new Array(length);
+        for (let i = 0; i < length; ++i)
+            a[i] = undefined;
+        return a;
+    }
+    mergeParamsMetatypes(paramsProperties, paramtypes) {
+        if (!paramtypes) {
+            return paramsProperties;
+        }
+        return paramsProperties.map(param => ({
+            ...param,
+            metatype: paramtypes[param.index],
+        }));
+    }
+    getCustomFactory(factory, data, contextFactory) {
+        return (0, shared_utils_1.isFunction)(factory)
+            ? (...args) => factory(data, contextFactory(args))
+            : () => null;
+    }
+    getContextFactory(contextType, instance, callback) {
+        const type = instance && instance.constructor;
+        return (args) => {
+            const ctx = new execution_context_host_1.ExecutionContextHost(args, type, callback);
+            ctx.setType(contextType);
+            return ctx;
+        };
+    }
+}
+exports.ContextUtils = ContextUtils;

package/helpers/execution-context-host.d.ts

@@ -0,0 +1,19 @@
+import { ExecutionContext } from '@nestjs/common';
+import { Type } from '@nestjs/common/interfaces';
+import { ContextType, HttpArgumentsHost, RpcArgumentsHost, WsArgumentsHost } from '@nestjs/common/interfaces/features/arguments-host.interface';
+export declare class ExecutionContextHost implements ExecutionContext {
+    private readonly args;
+    private readonly constructorRef;
+    private readonly handler;
+    private contextType;
+    constructor(args: any[], constructorRef?: Type<any> | null, handler?: Function | null);
+    setType<TContext extends string = ContextType>(type: TContext): void;
+    getType<TContext extends string = ContextType>(): TContext;
+    getClass<T = any>(): Type<T>;
+    getHandler(): Function;
+    getArgs<T extends Array<any> = any[]>(): T;
+    getArgByIndex<T = any>(index: number): T;
+    switchToRpc(): RpcArgumentsHost;
+    switchToHttp(): HttpArgumentsHost;
+    switchToWs(): WsArgumentsHost;
+}

package/helpers/execution-context-host.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionContextHost = void 0;
+class ExecutionContextHost {
+    constructor(args, constructorRef = null, handler = null) {
+        this.args = args;
+        this.constructorRef = constructorRef;
+        this.handler = handler;
+        this.contextType = 'http';
+    }
+    setType(type) {
+        type && (this.contextType = type);
+    }
+    getType() {
+        return this.contextType;
+    }
+    getClass() {
+        return this.constructorRef;
+    }
+    getHandler() {
+        return this.handler;
+    }
+    getArgs() {
+        return this.args;
+    }
+    getArgByIndex(index) {
+        return this.args[index];
+    }
+    switchToRpc() {
+        return Object.assign(this, {
+            getData: () => this.getArgByIndex(0),
+            getContext: () => this.getArgByIndex(1),
+        });
+    }
+    switchToHttp() {
+        return Object.assign(this, {
+            getRequest: () => this.getArgByIndex(0),
+            getResponse: () => this.getArgByIndex(1),
+            getNext: () => this.getArgByIndex(2),
+        });
+    }
+    switchToWs() {
+        return Object.assign(this, {
+            getClient: () => this.getArgByIndex(0),
+            getData: () => this.getArgByIndex(1),
+            getPattern: () => this.getArgByIndex(this.getArgs().length - 1),
+        });
+    }
+}
+exports.ExecutionContextHost = ExecutionContextHost;

package/helpers/external-context-creator.d.ts

@@ -0,0 +1,51 @@
+import { ParamData } from '@nestjs/common';
+import { ContextType, Controller, PipeTransform } from '@nestjs/common/interfaces';
+import { ExternalExceptionFilterContext } from '../exceptions/external-exception-filter-context';
+import { GuardsConsumer, GuardsContextCreator } from '../guards';
+import { NestContainer } from '../injector/container';
+import { ContextId } from '../injector/instance-wrapper';
+import { ModulesContainer } from '../injector/modules-container';
+import { InterceptorsConsumer, InterceptorsContextCreator } from '../interceptors';
+import { PipesConsumer, PipesContextCreator } from '../pipes';
+import { ParamProperties } from './context-utils';
+import { ExternalHandlerMetadata } from './interfaces/external-handler-metadata.interface';
+import { ParamsMetadata } from './interfaces/params-metadata.interface';
+export interface ParamsFactory {
+    exchangeKeyForValue(type: number, data: ParamData, args: any): any;
+}
+export interface ExternalContextOptions {
+    guards?: boolean;
+    interceptors?: boolean;
+    filters?: boolean;
+}
+export declare class ExternalContextCreator {
+    private readonly guardsContextCreator;
+    private readonly guardsConsumer;
+    private readonly interceptorsContextCreator;
+    private readonly interceptorsConsumer;
+    private readonly modulesContainer;
+    private readonly pipesContextCreator;
+    private readonly pipesConsumer;
+    private readonly filtersContextCreator;
+    private readonly contextUtils;
+    private readonly externalErrorProxy;
+    private readonly handlerMetadataStorage;
+    private container;
+    constructor(guardsContextCreator: GuardsContextCreator, guardsConsumer: GuardsConsumer, interceptorsContextCreator: InterceptorsContextCreator, interceptorsConsumer: InterceptorsConsumer, modulesContainer: ModulesContainer, pipesContextCreator: PipesContextCreator, pipesConsumer: PipesConsumer, filtersContextCreator: ExternalExceptionFilterContext);
+    static fromContainer(container: NestContainer): ExternalContextCreator;
+    create<TParamsMetadata extends ParamsMetadata = ParamsMetadata, TContext extends string = ContextType>(instance: Controller, callback: (...args: unknown[]) => unknown, methodName: string, metadataKey?: string, paramsFactory?: ParamsFactory, contextId?: ContextId, inquirerId?: string, options?: ExternalContextOptions, contextType?: TContext): (...args: any[]) => Promise<any>;
+    getMetadata<TMetadata, TContext extends string = ContextType>(instance: Controller, methodName: string, metadataKey?: string, paramsFactory?: ParamsFactory, contextType?: TContext): ExternalHandlerMetadata;
+    getContextModuleKey(moduleCtor: Function | undefined): string;
+    exchangeKeysForValues<TMetadata = any>(keys: string[], metadata: TMetadata, moduleContext: string, paramsFactory: ParamsFactory, contextId?: ContextId, inquirerId?: string, contextFactory?: (args: unknown[]) => import("./execution-context-host").ExecutionContextHost): ParamProperties[];
+    createPipesFn(pipes: PipeTransform[], paramsOptions: (ParamProperties & {
+        metatype?: unknown;
+    })[]): ((args: unknown[], ...params: unknown[]) => Promise<void>) | null;
+    getParamValue<T>(value: T, { metatype, type, data }: {
+        metatype: any;
+        type: any;
+        data: any;
+    }, pipes: PipeTransform[]): Promise<any>;
+    transformToResult(resultOrDeferred: any): Promise<any>;
+    createGuardsFn<TContext extends string = ContextType>(guards: any[], instance: Controller, callback: (...args: any[]) => any, contextType?: TContext): Function | null;
+    registerRequestProvider<T = any>(request: T, contextId: ContextId): void;
+}