@tsclean/core/dist/router/router-execution-context.d.ts

Plugin for API Rest Full development, based on Clean Architecture, IoC and Dependency Injection.

import { ExecutionContextHost } from '../helpers';
import { InterceptorsConsumer, InterceptorsContextCreator } from '../interceptors';
import { CustomHeader, RedirectResponse } from './router-response-controller';
import { RequestMethod, RouteParamTypes } from "../enums";
import { RouteParamMetadata } from "../decorators";
import { AccessResourceInterface, HandlerMetadataInterface, HttpServer, ParamPropertiesInterface, HandlerTransform, RouteParamsFactoryInterface } from "../contracts";
import { HandlersConsumer, HandlersContextCreator } from "../core";
import { AccessResourceConsumer, AccessResourceContextCreator } from "../access";
import { ContextType, ControllerType, HandlerResponseType } from "../types";
export declare class RouterExecutionContext {
    private readonly paramsFactory;
    private readonly handlersContextCreator;
    private readonly handlersConsumer;
    private readonly accessResourceContextCreator;
    private readonly accessResourceConsumer;
    private readonly interceptorsContextCreator;
    private readonly interceptorsConsumer;
    readonly applicationRef: HttpServer;
    private readonly handlerMetadataStorage;
    private readonly contextUtils;
    private readonly responseController;
    constructor(paramsFactory: RouteParamsFactoryInterface, handlersContextCreator: HandlersContextCreator, handlersConsumer: HandlersConsumer, accessResourceContextCreator: AccessResourceContextCreator, accessResourceConsumer: AccessResourceConsumer, interceptorsContextCreator: InterceptorsContextCreator, interceptorsConsumer: InterceptorsConsumer, applicationRef: HttpServer);
    create(instance: ControllerType, callback: (...args: any[]) => unknown, methodName: string, moduleKey: string, requestMethod: RequestMethod, contextId?: import("../core").ContextId, inquirerId?: string): <T, R>(req: T, res: R, next: Function) => Promise<void>;
    getMetadata<T extends ContextType = ContextType>(instance: ControllerType, callback: (...args: any[]) => any, methodName: string, moduleKey: string, requestMethod: RequestMethod, contextType: T): HandlerMetadataInterface;
    reflectRedirect(callback: (...args: unknown[]) => unknown): RedirectResponse;
    reflectHttpStatusCode(callback: (...args: unknown[]) => unknown): number;
    reflectRenderTemplate(callback: (...args: unknown[]) => unknown): string;
    reflectResponseHeaders(callback: (...args: unknown[]) => unknown): CustomHeader[];
    exchangeKeysForValues(keys: string[], metadata: Record<number, RouteParamMetadata>, moduleContext: string, contextId?: import("../core").ContextId, inquirerId?: string, contextFactory?: (args: unknown[]) => ExecutionContextHost): ParamPropertiesInterface[];
    getParamValue<T>(value: T, { metaType, type, data }: {
        metaType: unknown;
        type: RouteParamTypes;
        data: unknown;
    }, handlers: HandlerTransform[]): Promise<unknown>;
    isHandlers(type: number | string): boolean;
    createAccessResourceFn<T extends string = ContextType>(resources: AccessResourceInterface[], instance: ControllerType, callback: (...args: any[]) => any, contextType?: T): (args: any[]) => Promise<void> | null;
    createHandlerFn(handlers: HandlerTransform[], paramsOptions: (ParamPropertiesInterface & {
        metaType?: any;
    })[]): <T, R>(args: any[], req: T, res: R, next: Function) => Promise<void>;
    createHandleResponseFn(callback: (...args: unknown[]) => unknown, isResponseHandled: boolean, redirectResponse?: RedirectResponse, httpStatusCode?: number): HandlerResponseType;
    private isResponseHandled;
}
//# sourceMappingURL=router-execution-context.d.ts.map