@congruent-stack/congruent-api 0.7.0 → 0.10.0

package/dist/index.d.cts

@@ -17,6 +17,7 @@ declare enum HttpStatusCode {
     Forbidden_403 = 403,
     NotFound_404 = 404,
     Conflict_409 = 409,
+    UnprocessableEntity_422 = 422,
     InternalServerError_500 = 500,
     NotImplemented_501 = 501,
     BadGateway_502 = 502,
@@ -61,6 +62,7 @@ declare class HttpMethodEndpoint<const TDef extends IHttpMethodEndpointDefinitio
     get pathSegments(): readonly string[];
     private _cachedGenericPath;
     get genericPath(): string;
+    createPath(pathParams: Record<string, string>): string;
     private _method;
     get method(): HttpMethod;
     get lowerCasedMethod(): LowerCasedHttpMethod;
@@ -107,7 +109,7 @@ type ExtractConcatenatedParamNamesFromMethodFirstPath<TPath extends string> = TP
 type ExtractConcatenatedParamNamesFromPathSegments<TPath extends string> = TPath extends `/${infer Segment}/${infer Rest}` ? Segment extends `:${infer ParamName}` ? `:${ParamName}${ExtractConcatenatedParamNamesFromPathSegments<`/${Rest}`> extends `:${infer RestParams}` ? `:${RestParams}` : ""}` : ExtractConcatenatedParamNamesFromPathSegments<`/${Rest}`> : TPath extends `/${infer Segment}` ? Segment extends `:${infer ParamName}` ? `:${ParamName}` : "" : "";
 type ExtractConcatenatedParamNamesFromPath<TPath extends string> = TPath extends `${string} ${string}` ? ExtractConcatenatedParamNamesFromMethodFirstPath<TPath> : TPath extends `/${string}` ? ExtractConcatenatedParamNamesFromPathSegments<TPath> : never;
 
-type HttpMethodEndpointHandlerInput<TEndpointDefinition extends IHttpMethodEndpointDefinition, TPathParams extends string, TInjected> = {
+type HttpMethodEndpointHandlerInput<TEndpointDefinition extends IHttpMethodEndpointDefinition, TPathParams extends string> = {
     method: HttpMethod;
     pathSegments: readonly string[];
     path: string;
@@ -116,7 +118,6 @@ type HttpMethodEndpointHandlerInput<TEndpointDefinition extends IHttpMethodEndpo
     pathParams: TypedPathParams<TPathParams>;
     query: TEndpointDefinition['query'] extends z$1.ZodType ? z$1.output<TEndpointDefinition['query']> : null;
     body: TEndpointDefinition['body'] extends z$1.ZodType ? z$1.output<TEndpointDefinition['body']> : null;
-    injected: Readonly<TInjected>;
 };
 type ClientHttpMethodEndpointHandlerInput = {
     method: HttpMethod;
@@ -125,8 +126,14 @@ type ClientHttpMethodEndpointHandlerInput = {
     genericPath: string;
     headers: Record<string, string>;
     pathParams: Record<string, string>;
-    query?: any;
-    body?: any;
+    query: any;
+    body: any;
+};
+type HttpRequestObject = {
+    headers: Record<string, string>;
+    pathParams: Record<string, string>;
+    query: Record<string, string>;
+    body: object;
 };
 
 type HttpMethodEndpointHandlerOutput<TEndpointDefinition extends IHttpMethodEndpointDefinition> = {
@@ -166,102 +173,88 @@ type HttpResponseObject = {
     headers?: any;
     body?: any;
 };
+type BadRequestValidationErrorResponse = {
+    code: HttpStatusCode.BadRequest_400;
+    body: z$1.core.$ZodIssue[] | string;
+};
 declare function isHttpResponseObject(obj: any): obj is HttpResponseObject;
 
-type HttpMethodEndpointHandler<TDef extends IHttpMethodEndpointDefinition, TPathParams extends string, TInjected> = (input: HttpMethodEndpointHandlerInput<TDef, TPathParams, TInjected>) => Promise<HttpMethodEndpointHandlerOutput<TDef>>;
+declare const __overlap__error__: unique symbol;
+type EndpointHandlerContextOverlapGuard<TInjected> = [
+    Extract<keyof TInjected, keyof EndpointHandlerContext<unknown>>
+] extends [never] ? {} : {
+    [__overlap__error__]: `❌ ERROR: property "${Extract<keyof TInjected & keyof EndpointHandlerContext<unknown>, string>}" already part of Endpoint Context. Choose a different property name to avoid conflict.`;
+};
+type MiddlewareHandlerContextOverlapGuard<TInjected> = [
+    Extract<keyof TInjected, keyof MiddlewareHandlerContext<unknown>>
+] extends [never] ? {} : {
+    [__overlap__error__]: `❌ ERROR: property "${Extract<keyof TInjected & keyof MiddlewareHandlerContext<unknown>, string>}" already part of Middleware Context. Choose a different property name to avoid conflict.`;
+};
+type MiddlewareHandlerContext<TInjected = {}> = {
+    next: () => Promise<void>;
+    originalRequest: any;
+} & Readonly<TInjected>;
+type EndpointHandlerContext<TInjected = {}> = {
+    originalRequest: any;
+} & Readonly<TInjected>;
+type DecoratorHandlerContext = {
+    next: () => Promise<void>;
+    originalRequest: any;
+};
+
+type HttpMethodEndpointHandler<TDef extends IHttpMethodEndpointDefinition, TPathParams extends string, TInjected> = (input: HttpMethodEndpointHandlerInput<TDef, TPathParams>, context: EndpointHandlerContext<TInjected>) => Promise<HttpMethodEndpointHandlerOutput<TDef>>;
 type ClientHttpMethodEndpointHandler = (input: ClientHttpMethodEndpointHandlerInput) => Promise<ClientHttpMethodEndpointHandlerOutput>;
 
-type StringLiteral<S> = S extends string ? string extends S ? never : S : never;
-type DIClass<T> = new (...args: any[]) => T;
+type StringLiteral<T extends string> = string extends T ? never : T;
+type CapitalizedStringLiteral<T extends string> = string extends T ? never : T extends `${Uppercase<infer F>}${infer _}` ? F extends Lowercase<F> ? never : T : `❌ ERROR: Must start with uppercase letter`;
 type DILifetime = 'singleton' | 'transient' | 'scoped';
-type DIServiceRegistry = Record<string, any>;
-/**
- * A scoped container that provides typed method access to services.
- */
-type DIScope<R extends DIServiceRegistry> = {
-    [K in keyof R as `get${string & K}`]: () => R[K];
+type DIRegistryEntry<T> = {
+    factory: (scope: any) => T;
+    lifetime: DILifetime;
 };
-/**
- * This is the core of the static typing. It's a "mapped type" that takes a
- * ServiceRegistry `R` and creates a new type. For each key `K` in the registry,
- * it adds a method named `getK` that returns an instance of the corresponding service type.
- *
- * For example, if R is `{ LoggerService: LoggerService }`, this type will be:
- * { getLoggerService: () => LoggerService }
- */
-type DITypedContainer<R extends DIServiceRegistry> = DIContainer<R> & {
-    [K in keyof R as `get${string & K}`]: () => R[K];
+type DIRegistry = Record<string, DIRegistryEntry<any>>;
+type DIScope<R extends DIRegistry> = {
+    [K in keyof R as `get${string & K}`]: () => R[K] extends DIRegistryEntry<infer T> ? T : never;
 };
-/**
- * A Dependency Injection (DI) Container that provides static typing for resolved services.
- */
-declare class DIContainer<R extends DIServiceRegistry = {}> {
-    private registry;
-    private singletons;
-    private proxy;
-    /**
-     * The constructor returns a Proxy. This is the runtime magic that intercepts
-     * calls to methods like `getLoggerService()`. It parses the method name,
-     * finds the corresponding service class in the registry, and resolves it.
-     */
-    constructor();
-    /**
-     * Registers a service with explicit service name (fully type-safe).
-     */
-    register<T, N extends string>(serviceNameLiteral: StringLiteral<N>, factory: (container: DITypedContainer<R>) => T, lifetime?: DILifetime): DITypedContainer<R & Record<N, T>>;
-    /**
-     * Resolves a service by service name.
-     */
-    private resolveByName;
-    /**
-     * Creates a scoped container with typed method access to services.
-     */
+declare class DIContainerBase<R extends DIRegistry> {
+    protected _map: Map<string, DIRegistryEntry<any>>;
+    protected _singletonInstances: Map<string, any>;
     createScope(): DIScope<R>;
-    createTestClone(): this;
+}
+declare class DIContainer<R extends DIRegistry = {}> extends DIContainerBase<R> {
+    register<K extends string, T>(serviceNameCapitalizedLiteral: CapitalizedStringLiteral<K>, factory: (scope: DIScope<R>) => T, lifetime: DILifetime): DIContainer<R & Record<K, DIRegistryEntry<T>>>;
+    createTestClone(): DIContainerTestClone<R, this>;
+}
+declare class DIContainerTestClone<R extends DIRegistry, TDIContainer extends DIContainer<R>> extends DIContainerBase<R> {
+    constructor(original: TDIContainer);
+    override<K extends keyof R & string>(serviceNameLiteral: K, factory: (scope: DIScope<R>) => R[K] extends DIRegistryEntry<infer T> ? T : never): this;
 }
 
-type PrepareRegistryEntryCallback<TDef extends IHttpMethodEndpointDefinition & ValidateHttpMethodEndpointDefinition<TDef>, TDIContainer extends DIContainer, TPathParams extends string> = (entry: MethodEndpointHandlerRegistryEntry<TDef, TDIContainer, TPathParams, any>) => void;
-type OnHandlerRegisteredCallback<TDef extends IHttpMethodEndpointDefinition & ValidateHttpMethodEndpointDefinition<TDef>, TDIContainer extends DIContainer, TPathParams extends string> = (entry: MethodEndpointHandlerRegistryEntry<TDef, TDIContainer, TPathParams, any>) => void;
-declare class MethodEndpointHandlerRegistryEntry<TDef extends IHttpMethodEndpointDefinition & ValidateHttpMethodEndpointDefinition<TDef>, TDIContainer extends DIContainer, TPathParams extends string, TInjected = {}> {
-    private _methodEndpoint;
-    get methodEndpoint(): HttpMethodEndpoint<TDef>;
-    private _dicontainer;
-    get dicontainer(): TDIContainer;
-    constructor(methodEndpoint: HttpMethodEndpoint<TDef>, dicontainer: TDIContainer);
-    private _handler;
-    get handler(): HttpMethodEndpointHandler<TDef, TPathParams, TInjected> | null;
-    register(handler: HttpMethodEndpointHandler<TDef, TPathParams, TInjected>): void;
-    private _onHandlerRegisteredCallback;
-    _onHandlerRegistered(callback: OnHandlerRegisteredCallback<TDef, TDIContainer, TPathParams>): void;
-    prepare(callback: PrepareRegistryEntryCallback<TDef, TDIContainer, TPathParams>): this;
-    private _injection;
-    get injection(): any;
-    inject<TNewInjected>(injection: (dicontainer: TDIContainer) => TNewInjected): MethodEndpointHandlerRegistryEntry<TDef, TDIContainer, TPathParams, TNewInjected>;
-    trigger(data: {
-        headers: Record<string, string>;
-        pathParams: Record<string, string>;
-        query: object;
-        body: object;
-    }): Promise<any>;
+interface ICanTriggerAsync {
+    triggerNoStaticTypeCheck(diScope: DIScope<any>, requestObject: HttpRequestObject, context: any): Promise<any>;
+    get genericPath(): string;
 }
 
-type MiddlewareHandlerInputSchemas = {
+type MiddlewareHandlerSchemas = {
     headers?: z$1.ZodType;
     query?: z$1.ZodType;
     body?: z$1.ZodType;
+    responses: HttpMethodEndpointResponses;
 };
-type MiddlewareHandlerInput<TPathParams extends string, InputSchemas extends MiddlewareHandlerInputSchemas, TInjected> = {
+type MiddlewareHandlerInput<TPathParams extends string, TMiddlewareSchemas extends MiddlewareHandlerSchemas> = {
     method: HttpMethod;
     pathSegments: readonly string[];
     path: string;
     genericPath: string;
-    headers: InputSchemas['headers'] extends z$1.ZodType ? z$1.output<InputSchemas['headers']> : Record<string, string>;
+    headers: TMiddlewareSchemas['headers'] extends z$1.ZodType ? z$1.output<TMiddlewareSchemas['headers']> : Record<string, string>;
     pathParams: TypedPathParams<TPathParams>;
-    query: InputSchemas['query'] extends z$1.ZodType ? z$1.output<InputSchemas['query']> : null;
-    body: InputSchemas['body'] extends z$1.ZodType ? z$1.output<InputSchemas['body']> : null;
-    injected: Readonly<TInjected>;
+    query: TMiddlewareSchemas['query'] extends z$1.ZodType ? z$1.output<TMiddlewareSchemas['query']> : null;
+    body: TMiddlewareSchemas['body'] extends z$1.ZodType ? z$1.output<TMiddlewareSchemas['body']> : null;
 };
-type MiddlewareHandlerInputInternal<TInjected> = {
+type MiddlewareHandlerOutput<TMiddlewareSchemas extends MiddlewareHandlerSchemas> = void | {
+    [THttpStatusCode in keyof TMiddlewareSchemas['responses'] & HttpStatusCode]: TMiddlewareSchemas['responses'][THttpStatusCode] extends HttpMethodEndpointResponse<THttpStatusCode, infer TRespDef> ? CreateHandlerOutput<THttpStatusCode, TRespDef> : never;
+}[keyof TMiddlewareSchemas['responses'] & HttpStatusCode];
+type MiddlewareHandlerInputInternal = {
     method: HttpMethod;
     pathSegments: readonly string[];
     path: string;
@@ -270,29 +263,37 @@ type MiddlewareHandlerInputInternal<TInjected> = {
     pathParams: Record<string, string>;
     query: Record<string, any> | null;
     body: Record<string, any> | null;
-    injected: Readonly<TInjected>;
 };
-type MiddlewareHandler<TPathParams extends string, InputSchemas extends MiddlewareHandlerInputSchemas, TInjected> = (input: MiddlewareHandlerInput<TPathParams, InputSchemas, TInjected>, next: () => void) => Promise<HttpResponseObject | void>;
-type MiddlewareHandlerInternal<TInjected> = (input: MiddlewareHandlerInputInternal<TInjected>, next: () => void) => Promise<HttpResponseObject | void>;
+type MiddlewareHandler<TPathParams extends string, TMiddlewareSchemas extends MiddlewareHandlerSchemas, TInjected> = (input: MiddlewareHandlerInput<TPathParams, TMiddlewareSchemas>, context: MiddlewareHandlerContext<TInjected>) => Promise<MiddlewareHandlerOutput<TMiddlewareSchemas>>;
+type MiddlewareHandlerInternal<TInjected> = (input: MiddlewareHandlerInputInternal, context: MiddlewareHandlerContext<TInjected>) => Promise<HttpResponseObject | void>;
 declare function middleware<TApiDef extends IApiContractDefinition & ValidateApiContractDefinition<TApiDef>, TDIContainer extends DIContainer, TPathParams extends string, const TPath extends MiddlewarePath<TApiDef>, TInjected = {}>(apiReg: ApiHandlersRegistry<TApiDef, TDIContainer, TPathParams>, path: TPath): MiddlewareHandlersRegistryEntry<TApiDef, TDIContainer, TPathParams, TPath, TInjected>;
 type MiddlewarePath<TDef, BasePath extends string = ""> = (BasePath extends "" ? "" : never) | {
     [K in keyof TDef & string]: TDef[K] extends HttpMethodEndpoint<infer _TEndpointDef> ? `${K} ${BasePath}` : TDef[K] extends object ? `${BasePath}/${K}` | MiddlewarePath<TDef[K], `${BasePath}/${K}`> : never;
 }[keyof TDef & string];
-declare class MiddlewareHandlersRegistryEntryInternal<TDIContainer extends DIContainer, TInjected> {
+declare class MiddlewareHandlersRegistryEntryInternal<TDIContainer extends DIContainer, TInjected> implements ICanTriggerAsync {
     private readonly _dicontainer;
+    get dicontainer(): TDIContainer;
     private readonly _middlewareGenericPath;
     get genericPath(): string;
-    private _splitMiddlewarePath;
-    private readonly _inputSchemas;
+    private readonly _middlewarePathSegments;
+    get pathSegments(): readonly string[];
+    private readonly _middlewareMethod;
+    get method(): string;
+    private readonly _middlewareSchemas;
+    get middlewareSchemas(): MiddlewareHandlerSchemas;
     private readonly _handler;
-    constructor(diContainer: TDIContainer, middlewarePath: string, inputSchemas: MiddlewareHandlerInputSchemas, injection: (dicontainer: TDIContainer) => TInjected, handler: MiddlewareHandlerInternal<TInjected>);
+    constructor(diContainer: TDIContainer, middlewarePath: string, middlewareSchemas: MiddlewareHandlerSchemas, decoratorFactories: ((scope: DIScope<any>) => IEndpointHandlerDecorator<any>)[], injection: (dicontainer: TDIContainer) => TInjected, handler: MiddlewareHandlerInternal<TInjected>);
+    private readonly _decoratorFactories;
+    get decoratorFactories(): ((scope: DIScope<any>) => IEndpointHandlerDecorator<any>)[];
     private _injection;
-    trigger(data: {
-        headers: Record<string, string>;
-        pathParams: Record<string, string>;
-        query: object;
-        body: object;
-    }, next: () => void): Promise<any>;
+    trigger<TPathParams extends string, const TMiddlewareSchemas extends MiddlewareHandlerSchemas>(diScope: ReturnType<TDIContainer['createScope']>, requestObject: {
+        headers: TMiddlewareSchemas['headers'] extends z$1.ZodType ? z$1.output<TMiddlewareSchemas['headers']> : Record<string, string>;
+        pathParams: TypedPathParams<TPathParams>;
+        query: TMiddlewareSchemas['query'] extends z$1.ZodType ? z$1.output<TMiddlewareSchemas['query']> : null;
+        body: TMiddlewareSchemas['body'] extends z$1.ZodType ? z$1.output<TMiddlewareSchemas['body']> : null;
+    }, context: MiddlewareHandlerContext<any>): Promise<any>;
+    triggerNoStaticTypeCheck(diScope: DIScope<any>, requestObject: HttpRequestObject, context: MiddlewareHandlerContext<any>): Promise<any>;
+    createPath(pathParams: Record<string, string>): string;
 }
 declare class MiddlewareHandlersRegistryEntry<TApiDef extends IApiContractDefinition & ValidateApiContractDefinition<TApiDef>, TDIContainer extends DIContainer, TPathParams extends string, const TPath extends MiddlewarePath<TApiDef>, TInjected> {
     private readonly _registry;
@@ -300,18 +301,167 @@ declare class MiddlewareHandlersRegistryEntry<TApiDef extends IApiContractDefini
     constructor(registry: MiddlewareHandlersRegistry<TDIContainer>, path: TPath);
     private _injection;
     get injection(): any;
-    inject<TNewInjected>(injection: (dicontainer: TDIContainer) => TNewInjected): MiddlewareHandlersRegistryEntry<TApiDef, TDIContainer, TPathParams, TPath, TNewInjected>;
-    register<const InputSchemas extends MiddlewareHandlerInputSchemas>(inputSchemas: InputSchemas, handler: MiddlewareHandler<`${TPathParams}${ExtractConcatenatedParamNamesFromPath<TPath>}`, InputSchemas, TInjected>): void;
+    inject<TNewInjected>(injection: (diScope: ReturnType<TDIContainer['createScope']>) => TNewInjected & MiddlewareHandlerContextOverlapGuard<TNewInjected>): MiddlewareHandlersRegistryEntry<TApiDef, TDIContainer, TPathParams, TPath, TNewInjected>;
+    register<const TMiddlewareSchemas extends MiddlewareHandlerSchemas>(middlewareSchemas: TMiddlewareSchemas, handler: MiddlewareHandler<`${TPathParams}${ExtractConcatenatedParamNamesFromPath<TPath>}`, TMiddlewareSchemas, TInjected>): void;
+    private readonly _decoratorFactories;
+    get decoratorFactories(): ((scope: DIScope<any>) => IEndpointHandlerDecorator<any>)[];
+    /**
+     *
+     * @param decoratorFactory must be a function that takes exactly the DI scope type and returns an instance of a class that implements IEndpointHandlerDecorator
+     * @returns this
+     *
+     * Initially, the method was defined as:
+     * ```ts
+     * decorate<
+     *   TDecoratorSchemas extends IDecoratorHandlerSchemas,
+     *   TDecorator extends IEndpointHandlerDecorator<TDecoratorSchemas>
+     * > (
+     *   decoratorFactory: IEndpointHandlerDecoratorFactory<TDecoratorSchemas, TDIContainer, TDecorator>
+     * ): this {
+     *   this._decoratorFactories.push(decoratorFactory);
+     *   return this;
+     * }
+     * ```
+     *
+     * and the type IEndpointHandlerDecoratorFactory was defined as:
+     * ```ts
+     * type IEndpointHandlerDecoratorFactory<
+     *   TDecoratorSchemas extends IDecoratorHandlerSchemas,
+     *   TDIContainer extends DIContainer,
+     *   TDecorator extends IEndpointHandlerDecorator<TDecoratorSchemas>
+     * > = (diScope: ReturnType<TDIContainer['createScope']>) => TDecorator;
+     * ```
+     *
+     * However, TypeScript was incorrectly inferring the types when using the 'decorate' method.
+     * The end developer would have had to explicitly provide the generic types, which is not ideal.
+     *
+     * With the current definition, TypeScript can infer the types from the decoratorFactory parameter,
+     * making it easier to use.
+     */
+    decorate<TDecorator extends {
+        handle(input: any, context: any): Promise<any>;
+    }>(decoratorFactory: ((diScope: ReturnType<TDIContainer['createScope']>) => TDecorator) extends infer TExpected ? TDecorator extends IEndpointHandlerDecorator<infer _TSchemas> ? TExpected : "❌ ERROR: The decoratorFactory must return an instance of a class that implements IEndpointHandlerDecorator" : never): this;
+    decorateWith<TDecorator extends {
+        handle(input: any, context: any): Promise<any>;
+    }>(decoratorStaticMethodFactory: ({
+        new (...args: any[]): TDecorator;
+        create(diScope: ReturnType<TDIContainer['createScope']>): TDecorator;
+    } extends infer TExpected ? TDecorator extends IEndpointHandlerDecorator<infer _TSchemas> ? TExpected : "❌ ERROR: The decoratorStaticMethodFactory must be a class that implements IEndpointHandlerDecorator and has a static 'create' method that takes exactly the DI scope type and returns an instance of the class" : never)): this;
 }
 type OnMiddlewareHandlerRegisteredCallback<TDIContainer extends DIContainer, TInjected> = (entry: MiddlewareHandlersRegistryEntryInternal<TDIContainer, TInjected>) => void;
 declare class MiddlewareHandlersRegistry<TDIContainer extends DIContainer> {
     readonly dicontainer: TDIContainer;
     constructor(dicontainer: TDIContainer, callback: OnMiddlewareHandlerRegisteredCallback<TDIContainer, unknown>);
+    private readonly _list;
+    get list(): Readonly<MiddlewareHandlersRegistryEntryInternal<TDIContainer, unknown>[]>;
     register<TInjected>(entry: MiddlewareHandlersRegistryEntryInternal<TDIContainer, TInjected>): void;
     private _onHandlerRegisteredCallback;
     _onHandlerRegistered(callback: OnMiddlewareHandlerRegisteredCallback<TDIContainer, unknown>): void;
 }
 
+interface IDecoratorHandlerSchemas {
+    headers?: z.ZodType;
+    query?: z.ZodType;
+    body?: z.ZodType;
+    responses: HttpMethodEndpointResponses;
+}
+type DecoratorHandlerInput<TDecoratorSchemas extends IDecoratorHandlerSchemas> = {
+    method: HttpMethod;
+    pathSegments: readonly string[];
+    path: string;
+    genericPath: string;
+    headers: TDecoratorSchemas['headers'] extends z.ZodType ? z.output<TDecoratorSchemas['headers']> : Record<string, string>;
+    pathParams: Record<string, string>;
+    query: TDecoratorSchemas['query'] extends z.ZodType ? z.output<TDecoratorSchemas['query']> : null;
+    body: TDecoratorSchemas['body'] extends z.ZodType ? z.output<TDecoratorSchemas['body']> : null;
+};
+type DecoratorHandlerOutput<TDecoratorSchemas extends IDecoratorHandlerSchemas> = void | {
+    [THttpStatusCode in keyof TDecoratorSchemas['responses'] & HttpStatusCode]: TDecoratorSchemas['responses'][THttpStatusCode] extends HttpMethodEndpointResponse<THttpStatusCode, infer TRespDef> ? CreateHandlerOutput<THttpStatusCode, TRespDef> : never;
+}[keyof TDecoratorSchemas['responses'] & HttpStatusCode];
+interface IEndpointHandlerDecorator<TDecoratorSchemas extends IDecoratorHandlerSchemas> {
+    handle(input: DecoratorHandlerInput<TDecoratorSchemas>, context: DecoratorHandlerContext): Promise<DecoratorHandlerOutput<TDecoratorSchemas>>;
+}
+type EndpointHandlerDecoratorFactory<TDecoratorSchemas extends IDecoratorHandlerSchemas, TDIContainer extends DIContainer, TDecorator extends IEndpointHandlerDecorator<TDecoratorSchemas>> = (diScope: ReturnType<TDIContainer['createScope']>) => TDecorator;
+declare function triggerEndpointDecoratorNoStaticTypeCheck(endpoint: HttpMethodEndpoint<any>, decorator: IEndpointHandlerDecorator<any>, requestObject: HttpRequestObject, context: DecoratorHandlerContext): Promise<void | HttpResponseObject>;
+declare function triggerMiddlewareDecoratorNoStaticTypeCheck(middlewareEntry: MiddlewareHandlersRegistryEntryInternal<any, unknown>, decorator: IEndpointHandlerDecorator<any>, requestObject: HttpRequestObject, context: DecoratorHandlerContext): Promise<void | HttpResponseObject>;
+
+type PrepareRegistryEntryCallback<TDef extends IHttpMethodEndpointDefinition & ValidateHttpMethodEndpointDefinition<TDef>, TDIContainer extends DIContainer, TPathParams extends string> = (entry: MethodEndpointHandlerRegistryEntry<TDef, TDIContainer, TPathParams, any>) => void;
+type OnHandlerRegisteredCallback<TDef extends IHttpMethodEndpointDefinition & ValidateHttpMethodEndpointDefinition<TDef>, TDIContainer extends DIContainer, TPathParams extends string> = (entry: MethodEndpointHandlerRegistryEntry<TDef, TDIContainer, TPathParams, any>) => void;
+declare class MethodEndpointHandlerRegistryEntry<TDef extends IHttpMethodEndpointDefinition & ValidateHttpMethodEndpointDefinition<TDef>, TDIContainer extends DIContainer, TPathParams extends string, TInjected = {}> implements ICanTriggerAsync {
+    private _methodEndpoint;
+    get methodEndpoint(): HttpMethodEndpoint<TDef>;
+    private _dicontainer;
+    get dicontainer(): TDIContainer;
+    constructor(methodEndpoint: HttpMethodEndpoint<TDef>, dicontainer: TDIContainer);
+    get genericPath(): string;
+    private _handler;
+    get handler(): HttpMethodEndpointHandler<TDef, TPathParams, TInjected> | null;
+    register(handler: HttpMethodEndpointHandler<TDef, TPathParams, TInjected>): this;
+    private _onHandlerRegisteredCallback;
+    _onHandlerRegistered(callback: OnHandlerRegisteredCallback<TDef, TDIContainer, TPathParams>): void;
+    prepare(callback: PrepareRegistryEntryCallback<TDef, TDIContainer, TPathParams>): this;
+    private _injection;
+    get injection(): any;
+    inject<TNewInjected>(injection: (diScope: ReturnType<TDIContainer['createScope']>) => TNewInjected & EndpointHandlerContextOverlapGuard<TNewInjected>): MethodEndpointHandlerRegistryEntry<TDef, TDIContainer, TPathParams, TNewInjected>;
+    private readonly _decoratorFactories;
+    get decoratorFactories(): ((scope: DIScope<any>) => IEndpointHandlerDecorator<any>)[];
+    /**
+     *
+     * @param decoratorFactory must be a function that takes exactly the DI scope type and returns an instance of a class that implements IEndpointHandlerDecorator
+     * @returns this
+     *
+     * Initially, the method was defined as:
+     * ```ts
+     * decorate<
+     *   TDecoratorSchemas extends IDecoratorHandlerSchemas,
+     *   TDecorator extends IEndpointHandlerDecorator<TDecoratorSchemas>
+     * > (
+     *   decoratorFactory: IEndpointHandlerDecoratorFactory<TDecoratorSchemas, TDIContainer, TDecorator>
+     * ): this {
+     *   this._decoratorFactories.push(decoratorFactory);
+     *   return this;
+     * }
+     * ```
+     *
+     * and the type IEndpointHandlerDecoratorFactory was defined as:
+     * ```ts
+     * type IEndpointHandlerDecoratorFactory<
+     *   TDecoratorSchemas extends IDecoratorHandlerSchemas,
+     *   TDIContainer extends DIContainer,
+     *   TDecorator extends IEndpointHandlerDecorator<TDecoratorSchemas>
+     * > = (diScope: ReturnType<TDIContainer['createScope']>) => TDecorator;
+     * ```
+     *
+     * However, TypeScript was incorrectly inferring the types when using the 'decorate' method.
+     * The end developer would have had to explicitly provide the generic types, which is not ideal.
+     *
+     * With the current definition, TypeScript can infer the types from the decoratorFactory parameter,
+     * making it easier to use.
+     */
+    decorate<TDecorator extends {
+        handle(input: any, context: any): Promise<any>;
+    }, const TDecoratingArgs extends {} = {}>(decoratorFactory: ((diScope: ReturnType<TDIContainer['createScope']>, decoratingArgs: TDecoratingArgs) => TDecorator) extends infer TExpected ? TDecorator extends IEndpointHandlerDecorator<infer _TSchemas> ? TExpected : "❌ ERROR: The decoratorFactory must return an instance of a class that implements IEndpointHandlerDecorator" : never, decoratingArgs: TDecoratingArgs): this;
+    decorateWith<TDecorator extends {
+        handle(input: any, context: any): Promise<any>;
+    }, const TDecoratingArgs extends {} = {}>(decoratorStaticMethodFactory: ({
+        new (...args: any[]): TDecorator;
+        create(diScope: ReturnType<TDIContainer['createScope']>, decoratingArgs: TDecoratingArgs): TDecorator;
+    } extends infer TExpected ? TDecorator extends IEndpointHandlerDecorator<infer _TSchemas> ? TExpected : "❌ ERROR: The decoratorStaticMethodFactory must be a class that implements IEndpointHandlerDecorator and has a static 'create' method that takes exactly the DI scope type and returns an instance of the class" : never), decoratingArgs: TDecoratingArgs): this;
+    trigger(diScope: ReturnType<TDIContainer['createScope']>, requestObject: {
+        headers: TDef['headers'] extends z.ZodType ? z.output<TDef['headers']> : Record<string, string>;
+        pathParams: TypedPathParams<TPathParams>;
+        query: TDef['query'] extends z.ZodType ? z.output<TDef['query']> : null;
+        body: TDef['body'] extends z.ZodType ? z.output<TDef['body']> : null;
+    }): Promise<any>;
+    exec(injected: TInjected, requestObject: {
+        headers: TDef['headers'] extends z.ZodType ? z.output<TDef['headers']> : Record<string, string>;
+        pathParams: TypedPathParams<TPathParams>;
+        query: TDef['query'] extends z.ZodType ? z.output<TDef['query']> : null;
+        body: TDef['body'] extends z.ZodType ? z.output<TDef['body']> : null;
+    }): Promise<HttpMethodEndpointHandlerOutput<TDef> | BadRequestValidationErrorResponse>;
+    triggerNoStaticTypeCheck(diScope: DIScope<any>, requestObject: HttpRequestObject, context: EndpointHandlerContext<any>): Promise<any>;
+}
+
 declare function flatListAllRegistryEntries<TDef extends IApiContractDefinition & ValidateApiContractDefinition<TDef>, TDIContainer extends DIContainer>(registry: ApiHandlersRegistry<TDef, TDIContainer>): MethodEndpointHandlerRegistryEntry<any, any, any, any>[];
 declare function createRegistry<TDef extends IApiContractDefinition & ValidateApiContractDefinition<TDef>, TDIContainer extends DIContainer>(diContainer: TDIContainer, contract: ApiContract<TDef>, settings: IRegistrySettings<TDIContainer>): ApiHandlersRegistry<TDef, TDIContainer, "">;
 type GenericOnHandlerRegisteredCallback<TDIContainer extends DIContainer> = OnHandlerRegisteredCallback<IHttpMethodEndpointDefinition & ValidateHttpMethodEndpointDefinition<IHttpMethodEndpointDefinition>, TDIContainer, string>;
@@ -358,6 +508,8 @@ type NavigateToEndpoint<TDef, TSegments extends readonly string[]> = TSegments e
 declare function register<const TApiDef extends IApiContractDefinition & ValidateApiContractDefinition<TApiDef>, TDIContainer extends DIContainer, TPathParams extends string, const TPath extends MethodFirstPath<TApiDef>>(apiReg: ApiHandlersRegistry<TApiDef, TDIContainer, TPathParams>, path: TPath, handler: HttpMethodEndpointHandler<ExtractEndpointFromPath<TApiDef, TPath>, `${TPathParams}${ExtractConcatenatedParamNamesFromMethodFirstPath<TPath>}`, {}>): void;
 declare function register<const TDef extends IHttpMethodEndpointDefinition & ValidateHttpMethodEndpointDefinition<TDef>, TDIContainer extends DIContainer, TPathParams extends string>(endpointEntry: MethodEndpointHandlerRegistryEntry<TDef, TDIContainer, TPathParams>, handler: HttpMethodEndpointHandler<TDef, TPathParams, {}>): void;
 
+declare function execHandlerChain(diScope: DIScope<any>, allHandlerEntries: ICanTriggerAsync[], input: ClientHttpMethodEndpointHandlerInput): Promise<any>;
+
 type InferInputProp<T extends IHttpMethodEndpointDefinition, P extends keyof T> = T[P] extends z$1.ZodType<any, any> ? Record<P, z$1.input<T[P]>> : {};
 type Merge3<A, B, C> = A & B & C;
 type HttpMethodCallInput<T extends IHttpMethodEndpointDefinition> = Merge3<InferInputProp<T, "headers">, InferInputProp<T, "query">, InferInputProp<T, "body">> extends infer M ? keyof M extends never ? never : M : never;
@@ -379,6 +531,11 @@ type ApiClientDef<ObjType extends object> = {
 type ApiClient<TDef extends IApiContractDefinition & ValidateApiContractDefinition<TDef>> = Omit<ApiClientDef<InnerApiClient<TDef> & TDef>, "__CONTEXT__">;
 declare const ApiClient: new <TDef extends IApiContractDefinition & ValidateApiContractDefinition<TDef>>(contract: ApiContract<TDef>, clientGenericHandler: ClientHttpMethodEndpointHandler) => ApiClient<TDef>;
 
-declare function createInProcApiClient<TDef extends IApiContractDefinition & ValidateApiContractDefinition<TDef>, TDIContainer extends DIContainer>(contract: ApiContract<TDef>, testContainer: TDIContainer, registry: ApiHandlersRegistry<TDef, TDIContainer>): ApiClient<TDef>;
+interface InProcApiClientOptions<TDef extends IApiContractDefinition & ValidateApiContractDefinition<TDef>, TDIContainer extends DIContainer> {
+    enhanceRequest?: (input: ClientHttpMethodEndpointHandlerInput) => ClientHttpMethodEndpointHandlerInput;
+    filterMiddleware?: (genericPath: string, middlewareIndex: number) => boolean;
+    mockEndpointResponse?: (genericPath: string, method: string, diScope: ReturnType<TDIContainer['createScope']>) => HttpResponseObject | null;
+}
+declare function createInProcApiClient<TDef extends IApiContractDefinition & ValidateApiContractDefinition<TDef>, TDIContainer extends DIContainer, TDIContainerTestClone extends DIContainerTestClone<any, TDIContainer>>(contract: ApiContract<TDef>, testContainer: TDIContainerTestClone, registry: ApiHandlersRegistry<TDef, TDIContainer>, options?: InProcApiClientOptions<TDef, TDIContainer>): ApiClient<TDef>;
 
-export { ApiClient, type ApiClientDef, ApiContract, ApiHandlersRegistry, type ApiHandlersRegistryDef, type ClientHttpMethodEndpointHandler, type ClientHttpMethodEndpointHandlerInput, type ClientHttpMethodEndpointHandlerOutput, type DIClass, DIContainer, type DILifetime, type DIScope, type ExtractConcatenatedParamNamesFromMethodFirstPath, type ExtractConcatenatedParamNamesFromPath, type ExtractConcatenatedParamNamesFromPathSegments, type ExtractEndpointFromPath, type GenericOnHandlerRegisteredCallback, type HttpMethod, type HttpMethodCallFunc, type HttpMethodCallInput, HttpMethodEndpoint, type HttpMethodEndpointHandler, type HttpMethodEndpointHandlerInput, type HttpMethodEndpointHandlerOutput, HttpMethodEndpointResponse, type HttpMethodEndpointResponses, type HttpResponseObject, HttpStatusCode, type IApiContractDefinition, type IClientContext, type IHttpMethodEndpointDefinition, type IHttpMethodEndpointResponseDefinition, type IRegistrySettings, type LowerCasedHttpMethod, MethodEndpointHandlerRegistryEntry, type MethodFirstPath, type MiddlewareHandler, type MiddlewareHandlerInput, type MiddlewareHandlerInputInternal, type MiddlewareHandlerInputSchemas, type MiddlewareHandlerInternal, MiddlewareHandlersRegistry, MiddlewareHandlersRegistryEntry, MiddlewareHandlersRegistryEntryInternal, type MiddlewarePath, type OnHandlerRegisteredCallback, type OnMiddlewareHandlerRegisteredCallback, type PartialPath, type PartialPathResult, type PathParamFunc, type PrepareRegistryEntryCallback, type TypedPathParams, type ValidateApiContractDefinition, type ValidateHttpMethodEndpointDefinition, apiContract, createClient, createInProcApiClient, createRegistry, endpoint, flatListAllRegistryEntries, isHttpResponseObject, isHttpStatusCode, middleware, partial, partialPathString, register, response, route };
+export { ApiClient, type ApiClientDef, ApiContract, ApiHandlersRegistry, type ApiHandlersRegistryDef, type BadRequestValidationErrorResponse, type CapitalizedStringLiteral, type ClientHttpMethodEndpointHandler, type ClientHttpMethodEndpointHandlerInput, type ClientHttpMethodEndpointHandlerOutput, type CreateHandlerOutput, DIContainer, DIContainerBase, DIContainerTestClone, type DILifetime, type DIRegistry, type DIRegistryEntry, type DIScope, type DecoratorHandlerContext, type DecoratorHandlerInput, type DecoratorHandlerOutput, type EndpointHandlerContext, type EndpointHandlerContextOverlapGuard, type EndpointHandlerDecoratorFactory, type ExtractConcatenatedParamNamesFromMethodFirstPath, type ExtractConcatenatedParamNamesFromPath, type ExtractConcatenatedParamNamesFromPathSegments, type ExtractEndpointFromPath, type GenericOnHandlerRegisteredCallback, type HttpMethod, type HttpMethodCallFunc, type HttpMethodCallInput, HttpMethodEndpoint, type HttpMethodEndpointHandler, type HttpMethodEndpointHandlerInput, type HttpMethodEndpointHandlerOutput, HttpMethodEndpointResponse, type HttpMethodEndpointResponses, type HttpRequestObject, type HttpResponseObject, HttpStatusCode, type IApiContractDefinition, type IClientContext, type IDecoratorHandlerSchemas, type IEndpointHandlerDecorator, type IHttpMethodEndpointDefinition, type IHttpMethodEndpointResponseDefinition, type IRegistrySettings, type InProcApiClientOptions, type LowerCasedHttpMethod, MethodEndpointHandlerRegistryEntry, type MethodFirstPath, type MiddlewareHandler, type MiddlewareHandlerContext, type MiddlewareHandlerContextOverlapGuard, type MiddlewareHandlerInput, type MiddlewareHandlerInputInternal, type MiddlewareHandlerInternal, type MiddlewareHandlerOutput, type MiddlewareHandlerSchemas, MiddlewareHandlersRegistry, MiddlewareHandlersRegistryEntry, MiddlewareHandlersRegistryEntryInternal, type MiddlewarePath, type OnHandlerRegisteredCallback, type OnMiddlewareHandlerRegisteredCallback, type PartialPath, type PartialPathResult, type PathParamFunc, type PrepareRegistryEntryCallback, type StringLiteral, type TypedPathParams, type ValidateApiContractDefinition, type ValidateHttpMethodEndpointDefinition, apiContract, createClient, createInProcApiClient, createRegistry, endpoint, execHandlerChain, flatListAllRegistryEntries, isHttpResponseObject, isHttpStatusCode, middleware, partial, partialPathString, register, response, route, triggerEndpointDecoratorNoStaticTypeCheck, triggerMiddlewareDecoratorNoStaticTypeCheck };