/**
 * This file has helper types that map from the specfication type to handler function types.
 */
import { ResponsesSpec, ContentsSpec, RootSpec, PathsSpec, OperationsSpec, OperationSpec, RequestBodySpec } from "./spec-types";
/**
 * From the root of the spec, create a type for an object with handler functions
 */
export declare type HandlerFnsFromRootSpec<T extends RootSpec, Context> = HandlerFnsFromPathsSpec<T["paths"], Context>;
/**
 * From the paths of the spec, create a type for an object with handler functions for each path and operation
 */
export declare type HandlerFnsFromPathsSpec<T extends PathsSpec, Context> = {
    readonly [K in keyof T]: HandlerFnsFromOperationsSpec<T[K], Context>;
};
/**
 * From the operations spec, create function types
 */
export declare type HandlerFnsFromOperationsSpec<T extends OperationsSpec, Context> = {
    readonly [K in keyof T]: HandlerFnFromOperationSpec<T[K], Context>;
};
/**
 * Create a handler function from the operation spec.
 */
export declare type HandlerFnFromOperationSpec<T extends OperationSpec, Context> = HandlerFn<Context, T["parameters"], T["requestBody"] extends RequestBodySpec ? HandlerContentFromSpec<T["requestBody"]["content"]> : {}, HandlerResponseFromSpec<T["responses"]>>;
/**
 * From the specification, create a union type of possible response types
 */
export declare type HandlerResponseFromSpec<T extends ResponsesSpec> = {
    readonly [K in keyof T]: {
        readonly httpCode: K;
    } & (T[K]["content"] extends {} ? HandlerContentFromSpec<T[K]["content"]> : {});
}[keyof T];
/**
 * From the specification, create a union type of possible content types
 */
export declare type HandlerContentFromSpec<T extends ContentsSpec | undefined> = {
    readonly [K in keyof T]: {
        readonly contentType: K;
        readonly content: T[K];
    };
}[keyof T];
/**
 * A general description of a handler function
 */
export declare type HandlerFn<Context, Parameters extends HandlerParameters<ParamSet, ParamSet, ParamSet, ParamSet>, RequestBody extends ContentWithType<unknown, unknown>, Response extends HandlerResponse<unknown, unknown, unknown>> = (ctx: Context, parameters: Parameters, requestBody: RequestBody) => Promise<Response>;
/**
 * A general description of a handler function response
 */
export declare type HandlerResponse<HttpCode, ContentType, Content> = {
    readonly httpCode: HttpCode;
} & ContentWithType<ContentType, Content>;
export declare type ContentWithType<ContentType, Content> = {
    readonly contentType?: ContentType;
    readonly content?: Content;
};
export declare type ParamSet = {
    readonly [key: string]: unknown;
};
export declare type HandlerParameters<PathParams extends ParamSet, QueryParams extends ParamSet, HeaderParams extends ParamSet, CookieParams extends ParamSet> = {
    readonly path: PathParams;
    readonly query: QueryParams;
    readonly header: HeaderParams;
    readonly cookie: CookieParams;
};
/**
 * A general description of a handler object with functions for each path/operation
 */
export declare type HandlerFns = {
    readonly [path: string]: {
        readonly [op: string]: HandlerFn<unknown, HandlerParameters<ParamSet, ParamSet, ParamSet, ParamSet>, ContentWithType<unknown, unknown>, HandlerResponse<unknown, unknown, unknown>>;
    };
};
//# sourceMappingURL=type-mappers.d.ts.map