import { TypeInfo } from 'rtti';
import { Anonymize, ExtractMethod, ExtractPath } from '../util';
import { RouteSpec } from './create-http-route';
import { Method } from './methods';
import { RouteInfo } from './route-info';
/**
 * Creates a HttpSchema object from the given route specification object.
 * HTTP schemas may be passed to `createHttpClient` and/or `decorateExpressServer` to implement the schema on the
 * client-side and/or server-side. See those functions for more details.
 * @param routeSpecs an object keyed by route, with values describing the req/res body shape per route.
 */
export declare function createHttpSchema<RSO extends RouteSpecObject>(routeSpecs: RSO): {
    [R in keyof RSO]: ExtractRouteInfoFromRSO<RSO, R>;
};
/**
 * Creates a HttpSchema object from the given route specification array.
 * HTTP schemas may be passed to `createHttpClient` and/or `decorateExpressServer` to implement the schema on the
 * client-side and/or server-side. See those functions for more details.
 * @param routeSpecs an array with one element per route, with each element describing the route and req/res body shape.
 */
export declare function createHttpSchema<RSA extends ([RouteSpec] | RouteSpec[])>(routeSpecs: RSA): ExtractRouteInfoFromRSA<RSA>;
/** Route specifications, given as an object keyed by route, with values describing the req/res body shape per route. */
export interface RouteSpecObject {
    [route: `${Method} ${string}`]: {
        requestBody?: TypeInfo;
        responseBody?: TypeInfo;
    };
}
/** A HTTP Schema declared as an object keyed by route, with values containing detailed information about each route. */
export interface HttpSchema {
    [route: string]: RouteInfo;
}
declare type ExtractRouteInfoFromRSO<RSO, Route extends keyof RSO> = Anonymize<{
    method: ExtractMethod<Route>;
    path: ExtractPath<Route>;
    namedParams: Array<ExtractNamedParams<ExtractPath<Route>> | ExtractNumberedParams<ExtractPath<Route>>>;
    requestBody: RSO[Route] extends {
        requestBody: infer T;
    } ? T : never;
    responseBody: RSO[Route] extends {
        responseBody: infer T;
    } ? T : never;
}>;
declare type ExtractRouteInfoFromRSA<RSA extends [RouteSpec] | RouteSpec[]> = Anonymize<{
    [K in keyof RSA as K extends `${number}` ? RSA[K] extends RouteSpec<infer M, infer P> ? `${M} ${P}` : never : never]: RSA[K] extends RouteSpec<infer M, infer P> ? {
        method: M;
        path: P;
        namedParams: Array<ExtractNamedParams<P> | ExtractNumberedParams<P>>;
        requestBody: RSA[K] extends {
            requestBody: infer T;
        } ? T : never;
        responseBody: RSA[K] extends {
            responseBody: infer T;
        } ? T : never;
    } : never;
}>;
declare type ExtractNamedParams<Path, Parts = Tail<Split<Path, ':'>>> = ExtractUntilDelim<Parts[any]>;
declare type ExtractUntilDelim<S> = S extends `${Delim}${string}` ? '' : S extends `${infer First}${infer Rest}` ? `${First}${ExtractUntilDelim<Rest>}` : '';
declare type Delim = '/' | ':' | '-' | '.' | '~' | '!' | '$' | '&' | "'" | '(' | ')' | '*' | '+' | ',' | ';' | '=' | '@' | '%';
declare type ExtractNumberedParams<Path, Parts = Split<Path, '/'>> = Filter<Parts, '*'> extends [...infer U] ? {
    [K in keyof U]: K;
}[any] : never;
declare type Split<Str, Sep extends string> = Str extends `${infer First}${Sep}${infer Rest}` ? [First, ...Split<Rest, Sep>] : [Str];
declare type Tail<Tuple extends any[]> = Tuple extends [any, ...infer Rest] ? Rest : never;
declare type Filter<Tuple, U> = Tuple extends [infer First, ...infer Rest] ? First extends U ? [U, ...Filter<Rest, U>] : Filter<Rest, U> : [];
export {};