@congruent-stack/congruent-api 0.4.0 → 0.6.0

package/dist/index.d.cts

@@ -1,3 +1,367 @@
-declare function getHelloWorldMessage(name: string): string;
+import z, { z as z$1 } from 'zod';
 
-export { getHelloWorldMessage };
+declare enum HttpStatusCode {
+    Continue_100 = 100,
+    SwitchingProtocols_101 = 101,
+    OK_200 = 200,
+    Created_201 = 201,
+    Accepted_202 = 202,
+    NoContent_204 = 204,
+    MultipleChoices_300 = 300,
+    MovedPermanently_301 = 301,
+    Found_302 = 302,
+    SeeOther_303 = 303,
+    NotModified_304 = 304,
+    BadRequest_400 = 400,
+    Unauthorized_401 = 401,
+    Forbidden_403 = 403,
+    NotFound_404 = 404,
+    Conflict_409 = 409,
+    InternalServerError_500 = 500,
+    NotImplemented_501 = 501,
+    BadGateway_502 = 502,
+    ServiceUnavailable_503 = 503,
+    GatewayTimeout_504 = 504
+}
+declare function isHttpStatusCode(value: any): value is HttpStatusCode;
+
+type HttpMethod = "ALL" | "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD";
+type LowerCasedHttpMethod = Lowercase<HttpMethod>;
+
+declare function response<TStatus extends HttpStatusCode, TDef extends IHttpMethodEndpointResponseDefinition<TStatus>>(definition: TDef): HttpMethodEndpointResponse<TStatus, TDef>;
+interface IHttpMethodEndpointResponseDefinition<_TStatus extends HttpStatusCode> {
+    headers?: Record<string, string>;
+    body?: z.ZodType;
+}
+declare class HttpMethodEndpointResponse<TStatus extends HttpStatusCode, TDef extends IHttpMethodEndpointResponseDefinition<TStatus>> {
+    private _definition;
+    get definition(): TDef;
+    constructor(definition: TDef);
+}
+
+declare function endpoint<TDef extends IHttpMethodEndpointDefinition & ValidateHttpMethodEndpointDefinition<TDef>>(definition: TDef): HttpMethodEndpoint<TDef>;
+interface IHttpMethodEndpointDefinition {
+    headers?: z$1.ZodType;
+    query?: z$1.ZodType;
+    body?: z$1.ZodType;
+    responses: HttpMethodEndpointResponses;
+}
+type ValidateHttpMethodEndpointDefinition<TDef extends IHttpMethodEndpointDefinition> = {
+    responses: {
+        [K in keyof TDef['responses']]: K extends HttpStatusCode ? TDef['responses'][K] extends HttpMethodEndpointResponse<infer TStatus, infer TResponseDef> ? HttpMethodEndpointResponse<TStatus, TResponseDef> : "❌ ERROR: HttpMethodEndpointResponse only allowed on HttpStatusCode key" : "❌ ERROR: HttpMethodEndpointResponse only allowed on HttpStatusCode key";
+    };
+};
+type HttpMethodEndpointResponses = Partial<{
+    readonly [status in HttpStatusCode]: HttpMethodEndpointResponse<status, any>;
+}>;
+declare class HttpMethodEndpoint<const TDef extends IHttpMethodEndpointDefinition & ValidateHttpMethodEndpointDefinition<TDef>> {
+    private _definition;
+    get definition(): TDef;
+    private _pathSegments;
+    get pathSegments(): readonly string[];
+    private _cachedGenericPath;
+    get genericPath(): string;
+    private _method;
+    get method(): HttpMethod;
+    get lowerCasedMethod(): LowerCasedHttpMethod;
+    constructor(definition: TDef);
+}
+
+declare function apiContract<const TDef extends IApiContractDefinition & ValidateApiContractDefinition<TDef>>(definition: TDef): ApiContract<TDef>;
+interface IApiContractDefinition {
+    readonly [key: string]: IApiContractDefinition | HttpMethodEndpoint<any>;
+}
+type ValidateApiContractDefinition<T> = {
+    [K in keyof T]: T[K] extends HttpMethodEndpoint<infer TEndpDef> ? K extends HttpMethod ? HttpMethodEndpoint<TEndpDef> : "❌ ERROR: HttpMethodEndpoint only allowed on HttpMethod key" : K extends HttpMethod ? " ❌ ERROR: method key must hold an HttpMethodEndpoint" : T[K] extends object ? ValidateApiContractDefinition<T[K]> : T[K];
+};
+declare class ApiContract<const TDef extends IApiContractDefinition & ValidateApiContractDefinition<TDef>> {
+    readonly definition: TDef;
+    constructor(definition: TDef);
+    cloneInitDef(): TDef;
+    private static _deepCloneInitDef;
+}
+
+/**
+ * Extracts typed path parameters from a path string.
+ * For example, given a path string like ":p1:p2:...:pn", it will return an object type with properties for each parameter.
+ *
+ * @template TPathParams - The path parameters string, e.g., ":id:name:age".
+ * @returns An object type with properties for each parameter.
+ *
+ * @example
+ * ```
+ * const typedParams: TypedPathParams<':id:name'> = {
+ *   id: '1',
+ *   name: 'Bulbasaur'
+ * };
+ * console.log(typedParams.id);   // "1"
+ * console.log(typedParams.name); // "Bulbasaur"
+ * ```
+ */
+type TypedPathParams<TPathParams extends string> = TPathParams extends `:${infer ParamName}:${infer RestParams}` ? {
+    [K in ParamName]: string;
+} & TypedPathParams<`:${RestParams}`> : TPathParams extends `:${infer ParamName}` ? {
+    [K in ParamName]: string;
+} : {};
+type ExtractConcatenatedParamNamesFromMethodFirstPath<TPath extends string> = TPath extends `${string} ${infer PathPart}` ? ExtractConcatenatedParamNamesFromPathSegments<PathPart> : never;
+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> = {
+    method: HttpMethod;
+    pathSegments: readonly string[];
+    path: string;
+    genericPath: string;
+    headers: TEndpointDefinition['headers'] extends z$1.ZodType ? z$1.output<TEndpointDefinition['headers']> : Record<string, string>;
+    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;
+    pathSegments: readonly string[];
+    path: string;
+    genericPath: string;
+    headers: Record<string, string>;
+    pathParams: Record<string, string>;
+    query?: any;
+    body?: any;
+};
+
+type HttpMethodEndpointHandlerOutput<TEndpointDefinition extends IHttpMethodEndpointDefinition> = {
+    [THttpStatusCode in keyof TEndpointDefinition['responses'] & HttpStatusCode]: TEndpointDefinition['responses'][THttpStatusCode] extends HttpMethodEndpointResponse<THttpStatusCode, infer TRespDef> ? CreateHandlerOutput<THttpStatusCode, TRespDef> : never;
+}[keyof TEndpointDefinition['responses'] & HttpStatusCode];
+type CreateHandlerOutput<THttpStatusCode extends HttpStatusCode, TRespDef> = TRespDef extends {
+    body: z$1.ZodType;
+} ? {
+    code: THttpStatusCode;
+    body: z$1.input<TRespDef['body']>;
+} : {
+    code: THttpStatusCode;
+    body?: never;
+};
+type ClientHttpMethodEndpointHandlerOutput = {
+    code: HttpStatusCode;
+    body: any;
+};
+type HttpResponseObject = {
+    code: HttpStatusCode;
+    body?: any;
+};
+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>>;
+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 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];
+};
+/**
+ * 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];
+};
+/**
+ * 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.
+     */
+    createScope(): DIScope<R>;
+    createTestClone(): 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>;
+}
+
+type MiddlewareHandlerInputSchemas = {
+    headers?: z$1.ZodType;
+    query?: z$1.ZodType;
+    body?: z$1.ZodType;
+};
+type MiddlewareHandlerInput<TPathParams extends string, InputSchemas extends MiddlewareHandlerInputSchemas, TInjected> = {
+    method: HttpMethod;
+    pathSegments: readonly string[];
+    path: string;
+    genericPath: string;
+    headers: InputSchemas['headers'] extends z$1.ZodType ? z$1.output<InputSchemas['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>;
+};
+type MiddlewareHandlerInputInternal<TInjected> = {
+    method: HttpMethod;
+    pathSegments: readonly string[];
+    path: string;
+    genericPath: string;
+    headers: Record<string, string>;
+    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>;
+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> {
+    private readonly _dicontainer;
+    private readonly _middlewareGenericPath;
+    get genericPath(): string;
+    private _splitMiddlewarePath;
+    private readonly _inputSchemas;
+    private readonly _handler;
+    constructor(diContainer: TDIContainer, middlewarePath: string, inputSchemas: MiddlewareHandlerInputSchemas, injection: (dicontainer: TDIContainer) => TInjected, handler: MiddlewareHandlerInternal<TInjected>);
+    private _injection;
+    trigger(data: {
+        headers: Record<string, string>;
+        pathParams: Record<string, string>;
+        query: object;
+        body: object;
+    }, next: () => void): Promise<any>;
+}
+declare class MiddlewareHandlersRegistryEntry<TApiDef extends IApiContractDefinition & ValidateApiContractDefinition<TApiDef>, TDIContainer extends DIContainer, TPathParams extends string, const TPath extends MiddlewarePath<TApiDef>, TInjected> {
+    private readonly _registry;
+    private readonly _path;
+    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;
+}
+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>);
+    register<TInjected>(entry: MiddlewareHandlersRegistryEntryInternal<TDIContainer, TInjected>): void;
+    private _onHandlerRegisteredCallback;
+    _onHandlerRegistered(callback: OnMiddlewareHandlerRegisteredCallback<TDIContainer, unknown>): void;
+}
+
+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>;
+interface IRegistrySettings<TDIContainer extends DIContainer> {
+    handlerRegisteredCallback: GenericOnHandlerRegisteredCallback<TDIContainer>;
+    middlewareHandlerRegisteredCallback: OnMiddlewareHandlerRegisteredCallback<TDIContainer, unknown>;
+}
+declare class InnerApiHandlersRegistry<TDef extends IApiContractDefinition & ValidateApiContractDefinition<TDef>, TDIContainer extends DIContainer> {
+    constructor(dicontainer: TDIContainer, contract: ApiContract<TDef>, settings: IRegistrySettings<TDIContainer>);
+    private static _initialize;
+}
+type ApiHandlersRegistryDef<ObjType extends object, TDIContainer extends DIContainer, TPathParams extends string> = {
+    [Key in keyof ObjType]: Key extends `:${infer ParamName}` ? ObjType[Key] extends HttpMethodEndpoint<infer TMethodEndpointDef> ? MethodEndpointHandlerRegistryEntry<TMethodEndpointDef, TDIContainer, `${TPathParams}:${ParamName}`> : ObjType[Key] extends object ? ApiHandlersRegistryDef<ObjType[Key], TDIContainer, `${TPathParams}:${ParamName}`> : ObjType[Key] : ObjType[Key] extends HttpMethodEndpoint<infer TMethodEndpointDef> ? MethodEndpointHandlerRegistryEntry<TMethodEndpointDef, TDIContainer, TPathParams> : ObjType[Key] extends object ? ApiHandlersRegistryDef<ObjType[Key], TDIContainer, TPathParams> : ObjType[Key];
+};
+type ApiHandlersRegistry<TDef extends IApiContractDefinition & ValidateApiContractDefinition<TDef>, TDIContainer extends DIContainer, TPathParams extends string = ""> = Omit<ApiHandlersRegistryDef<InnerApiHandlersRegistry<TDef, TDIContainer> & TDef, TDIContainer, TPathParams>, '_middlewareRegistry'>;
+declare const ApiHandlersRegistry: new <TDef extends IApiContractDefinition & ValidateApiContractDefinition<TDef>, TDIContainer extends DIContainer, TPathParams extends string = "">(dicontainer: TDIContainer, contract: ApiContract<TDef>, settings: IRegistrySettings<TDIContainer>) => ApiHandlersRegistry<TDef, TDIContainer, TPathParams>;
+
+declare function partialPathString<TApiDef extends IApiContractDefinition & ValidateApiContractDefinition<TApiDef>, TPathParams extends string, const TPath extends PartialPath<TApiDef>>(_apiReg: ApiHandlersRegistry<TApiDef, any, TPathParams>, path: TPath): string;
+type PartialPath<TDef, BasePath extends string = ""> = (BasePath extends "" ? "" : never) | {
+    [K in keyof TDef & string]: TDef[K] extends HttpMethodEndpoint<infer _TEndpointDef> ? never : TDef[K] extends object ? `${BasePath}/${K}` | PartialPath<TDef[K], `${BasePath}/${K}`> : never;
+}[keyof TDef & string];
+
+declare function partial<TDIContainer extends DIContainer, TApiDef extends IApiContractDefinition & ValidateApiContractDefinition<TApiDef>, TPathParams extends string, const TPath extends PartialPath<TApiDef>>(apiReg: ApiHandlersRegistry<TApiDef, TDIContainer, TPathParams>, path: TPath): PartialPathResult<TApiDef, TPath> extends infer TPartialApi ? TPartialApi extends IApiContractDefinition & ValidateApiContractDefinition<TPartialApi> ? ApiHandlersRegistry<TPartialApi, TDIContainer, ExtractConcatenatedParamNamesFromPathSegments<TPath>> : never : never;
+type PartialPathResult<TApiDef extends IApiContractDefinition, TPath extends string> = TPath extends `/${infer Rest}` ? NavigateToPartialPath<TApiDef, SplitPath$1<Rest>> : NavigateToPartialPath<TApiDef, SplitPath$1<TPath>>;
+type SplitPath$1<TPath extends string> = TPath extends `${infer First}/${infer Rest}` ? [First, ...SplitPath$1<Rest>] : TPath extends "" ? [] : [TPath];
+type NavigateToPartialPath<TDef, TSegments extends readonly string[]> = TSegments extends readonly [
+    infer First extends string,
+    ...infer Rest extends readonly string[]
+] ? First extends keyof TDef ? Rest extends readonly [] ? TDef[First] extends object ? TDef[First] : never : NavigateToPartialPath<TDef[First], Rest> : never : TDef;
+
+declare function route<TApiDef extends IApiContractDefinition & ValidateApiContractDefinition<TApiDef>, TDIContainer extends DIContainer, TPathParams extends string, const TPath extends MethodFirstPath<TApiDef>>(apiReg: ApiHandlersRegistry<TApiDef, TDIContainer, TPathParams>, path: TPath): MethodEndpointHandlerRegistryEntry<ExtractEndpointFromPath<TApiDef, TPath>, TDIContainer, `${TPathParams}${ExtractConcatenatedParamNamesFromMethodFirstPath<TPath>}`, {}>;
+type MethodFirstPath<TDef, BasePath extends string = ""> = {
+    [K in keyof TDef & string]: TDef[K] extends HttpMethodEndpoint<infer _TEndpointDef> ? `${K} ${BasePath}` : TDef[K] extends object ? MethodFirstPath<TDef[K], `${BasePath}/${K}`> : never;
+}[keyof TDef & string];
+type ExtractEndpointFromPath<TApiDef, TPath extends string> = TPath extends `${infer Method} ${infer Path}` ? ExtractEndpointFromPathSegments<TApiDef, Path, Method> : never;
+type ExtractEndpointFromPathSegments<TDef, TPath extends string, TMethod extends string, TSegments extends readonly string[] = SplitPath<TPath>> = NavigateToEndpoint<TDef, TSegments> extends infer TEndpointContainer ? TEndpointContainer extends Record<string, any> ? TMethod extends keyof TEndpointContainer ? TEndpointContainer[TMethod] extends HttpMethodEndpoint<infer TEndpointDef> ? TEndpointDef : never : never : never : never;
+type SplitPath<TPath extends string> = TPath extends `/${infer Rest}` ? SplitPathSegments<Rest> : SplitPathSegments<TPath>;
+type SplitPathSegments<TPath extends string> = TPath extends `${infer First}/${infer Rest}` ? [First, ...SplitPathSegments<Rest>] : TPath extends "" ? [] : [TPath];
+type NavigateToEndpoint<TDef, TSegments extends readonly string[]> = TSegments extends readonly [
+    infer First extends string,
+    ...infer Rest extends readonly string[]
+] ? First extends keyof TDef ? NavigateToEndpoint<TDef[First], Rest> : never : TDef;
+
+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;
+
+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;
+type HttpMethodCallFunc<T extends IHttpMethodEndpointDefinition> = HttpMethodCallInput<T> extends never ? () => Promise<HttpMethodEndpointHandlerOutput<T>> : (input: HttpMethodCallInput<T>) => Promise<HttpMethodEndpointHandlerOutput<T>>;
+
+declare function createClient<TDef extends IApiContractDefinition & ValidateApiContractDefinition<TDef>>(contract: ApiContract<TDef>, clientGenericHandler: ClientHttpMethodEndpointHandler): ApiClient<TDef>;
+type PathParamFunc<TDef> = (value: string | number) => TDef;
+interface IClientContext {
+    pathParameters: Record<string, string>;
+}
+declare class InnerApiClient<TDef extends IApiContractDefinition & ValidateApiContractDefinition<TDef>> {
+    constructor(contract: ApiContract<TDef>, clientGenericHandler: ClientHttpMethodEndpointHandler);
+    private static _initNewContext;
+    private static _initialize;
+}
+type ApiClientDef<ObjType extends object> = {
+    [Key in keyof ObjType as Key extends `:${infer Param}` ? Param : Key]: Key extends `:${string}` ? ObjType[Key] extends object ? PathParamFunc<ApiClientDef<ObjType[Key]>> : never : ObjType[Key] extends HttpMethodEndpoint<infer TMethodEndpointDef> ? HttpMethodCallFunc<TMethodEndpointDef> : ObjType[Key] extends object ? ApiClientDef<ObjType[Key]> : ObjType[Key];
+};
+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>;
+
+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 };