import { Effect } from "@effect/io/Effect";
import { Context } from "@fp-ts/data/Context";
import { ParsedShapeOf } from "@effect-ts-app/boilerplate-prelude/schema";
import type { _E, _R } from "@effect-ts-app/boilerplate-prelude/_ext/Prelude.ext";
import type { GetRequest, GetResponse } from "@effect-ts-app/boilerplate-prelude/schema";
import * as MO from "@effect-ts-app/boilerplate-prelude/schema";
import * as Ex from "@effect-ts-app/infra/express/index";
import type { Encode, RequestHandler, RequestHandlerOptRes, RequestParsers } from "@effect-ts-app/infra/express/schema/requestHandler";
import type { RouteDescriptorAny } from "@effect-ts-app/infra/express/schema/routing";
import type express from "express";
import type { ValidationError } from "../../errors.js";
import { RequestContext } from "../../lib/RequestContext.js";
import type { SupportedErrors } from "./defaultErrorHandler.js";
export declare function makeRequestParsers<R, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA extends PathA & QueryA & BodyA, ResA, Errors>(Request: RequestHandler<R, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA, ResA, Errors>["Request"]): RequestParsers<PathA, CookieA, QueryA, BodyA, HeaderA>;
export type MakeMiddlewareContext<ResE, R2 = never, PR = never> = (req: express.Request, res: express.Response, context: RequestContext) => Effect<R2, ResE, Context<PR>>;
export type Middleware<R, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA extends PathA & QueryA & BodyA, ResA, ResE, R2 = never, PR = never> = (handler: RequestHandler<R, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA, ResA, ResE>) => {
    handler: typeof handler;
    makeContext: MakeMiddlewareContext<ResE, R2, PR>;
};
export declare function match<R, E, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA extends PathA & QueryA & BodyA, ResA, R2 = never, PR = never, RErr = never>(requestHandler: RequestHandler<R, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA, ResA, E>, errorHandler: <R>(req: express.Request, res: express.Response, requestContext: RequestContext, r2: Effect<R, E | ValidationError, void>) => Effect<RErr, never, void>, middleware?: Middleware<R, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA, ResA, E, R2, PR>): import("@effect/io/Effect").Effect<R | R2 | RErr | Ex.ExpressEnv, never, import("@effect-ts-app/infra/express/schema/routing").RouteDescriptor<R, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA, ResA, E, MO.Methods>>;
export declare function respondSuccess<ReqA, A, E>(encodeResponse: (req: ReqA) => Encode<A, E>): (req: ReqA, res: express.Response, a: A) => import("@effect/io/Effect").Effect<never, never, void>;
export declare function makeRequestHandler<R, E, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA extends PathA & QueryA & BodyA, ResA = void, R2 = never, PR = never, RErr = never>(handler: RequestHandlerOptRes<R | PR, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA, ResA, E>, errorHandler: <R>(req: express.Request, res: express.Response, requestContext: RequestContext, r2: Effect<R, E | ValidationError, void>) => Effect<RErr | R, never, void>, makeMiddlewareContext?: MakeMiddlewareContext<E, R2, PR>): (req: express.Request, res: express.Response) => Effect<RErr | R | R2, never, void>;
export type RequestHandlers = {
    [key: string]: BasicRequestHandler;
};
export type BasicRequestHandler = RequestHandler<any, any, any, any, any, any, any, any, ValidationError>;
export type AnyRequestHandler = RequestHandler<any, any, any, any, any, any, any, any, any>;
type RouteAll<T extends RequestHandlers> = {
    [K in keyof T]: T[K] extends RequestHandler<infer R, any, // infer PathA,
    any, // infer CookieA,
    any, // infer QueryA,
    any, // infer BodyA,
    any, // infer HeaderA,
    any, // infer ReqA,
    any, // infer ResA,
    ValidationError> ? RouteMatch<R, never> : never;
};
export type RouteMatch<R, PR = never> = Effect<Ex.ExpressAppConfig | Ex.ExpressApp | Exclude<R, PR>, never, RouteDescriptorAny>;
/**
 * Gather all handlers of a module and attach them to the Server.
 * Requires no login.
 */
export declare function matchAll<T extends RequestHandlers>(handlers: T): RouteAll<T>;
/**
 * Gather all handlers of a module and attach them to the Server.
 * Requires no login.
 */
export declare function matchAllAlt<T extends RequestHandlersTest>(handlers: T): Flatten<RouteAllTest<T>>;
export type RequestHandlersTest = {
    [key: string]: Record<string, BasicRequestHandler>;
};
export type RouteAllTest<T extends RequestHandlersTest> = {
    [K in keyof T]: RouteAll<T[K]>;
};
export type Flatten<T extends object> = object extends T ? object : {
    [K in keyof T]-?: (x: NonNullable<T[K]> extends infer V ? V extends object ? V extends readonly any[] ? Pick<T, K> : FlattenLVL1<V> extends infer FV ? ({
        [P in keyof FV as `${Extract<K, string | number>}.${Extract<P, string | number>}`]: FV[P];
    }) : never : Pick<T, K> : never) => void;
} extends Record<keyof T, (y: infer O) => void> ? O extends unknown ? {
    [K in keyof O]: O[K];
} : never : never;
type FlattenLVL1<T extends object> = object extends T ? object : {
    [K in keyof T]-?: (x: NonNullable<T[K]> extends infer V ? V extends object ? V extends readonly any[] ? Pick<T, K> : Pick<T, K> : never : never) => void;
} extends Record<keyof T, (y: infer O) => void> ? O extends unknown ? {
    [K in keyof O]: O[K];
} : never : never;
export declare function handle<TModule extends Record<string, any>>(_: TModule & {
    ResponseOpenApi?: any;
}, adaptResponse?: any): <R, E>(h: (r: InstanceType<GetRequest<TModule> extends new (...args: any[]) => any ? GetRequest<TModule> : never>) => import("@effect/io/Effect").Effect<R, E, MO.ParsedShapeOf<Extr<GetResponse<TModule>>>>) => ReqHandler<InstanceType<GetRequest<TModule> extends new (...args: any[]) => any ? GetRequest<TModule> : never>, R, E, MO.ParsedShapeOf<Extr<GetResponse<TModule>>>, GetRequest<TModule>, GetResponse<TModule>, any>;
export type Extr<T> = T extends {
    Model: MO.SchemaAny;
} ? T["Model"] : T extends MO.SchemaAny ? T : never;
export interface ReqHandler<Req, R, E, Res, ReqSchema extends MO.SchemaAny, ResSchema extends MO.SchemaAny, CTX = any> {
    h: (r: Req, ctx: CTX) => Effect<R, E, Res>;
    Request: ReqSchema;
    Response: ResSchema;
    ResponseOpenApi: any;
}
/**
 * Provided a module with resources, and provided an Object with resource handlers, will prepare route handlers to be attached to server.
 * @param mod The module with Resources you want to match.
 * @returns A function that must be called with an Object with a handler "Request -> Effect<R, E, Response>" for each resource defined in the Module.
 *
 * Example:
 * ```
 * class SayHelloRequest extends Get("/say-hello")<SayHelloRequest>()({ name: prop(ReasonableString) }) {}
 * class SayHelloResponse extends Model<SayHelloRequest>()({ message: prop(LongString) }) {}
 *
 * export const SayHelloControllers = matchResource({ SayHello: { SayHelloRequest, SayHelloResponse } })({
 *   SayHello: (req) => Effect({ message: `Hi ${req.name}` })
 * })
 * ```
 */
export declare function matchResource<TModules extends Record<string, Record<string, any>>>(mod: TModules): <THandlers extends { [K in keyof TModules]: (req: InstanceType<GetRequest<TModules[K]> extends infer T ? T extends GetRequest<TModules[K]> ? T extends new (...args: any[]) => any ? T : never : never : never>) => import("@effect/io/Effect").Effect<any, SupportedErrors, MO.ParsedShapeOf<Extr<GetResponse<TModules[K]>>>>; }>(handlers: THandlers) => { [K_1 in keyof TModules]: ReqHandler<InstanceType<GetRequest<TModules[K_1]> extends infer T_1 ? T_1 extends GetRequest<TModules[K_1]> ? T_1 extends new (...args: any[]) => any ? T_1 : never : never : never>, _R<ReturnType<THandlers[K_1]>>, _E<ReturnType<THandlers[K_1]>>, MO.ParsedShapeOf<Extr<GetResponse<TModules[K_1]>>>, GetRequest<TModules[K_1]>, GetResponse<TModules[K_1]>, any>; };
export type ReqFromSchema<ReqSchema> = InstanceType<ReqSchema extends {
    new (...args: any[]): any;
} ? ReqSchema : never>;
export type ResFromSchema<ResSchema> = ParsedShapeOf<Extr<ResSchema>>;
export {};
//# sourceMappingURL=routing.d.ts.map