import { ClassType } from '@deepkit/core';
import { ClassDecoratorResult, DecoratorAndFetchSignature, DualDecorator, ExtractApiDataType, ExtractClass, PropertyDecoratorFn, ReceiveType, SerializationOptions, Serializer, Type, UnionToIntersection } from '@deepkit/type';
import { RouteParameterResolver } from './router.js';
import { HttpMiddleware, HttpMiddlewareConfig, HttpMiddlewareFn } from './middleware.js';
type HttpActionMiddleware = (() => HttpMiddlewareConfig) | ClassType<HttpMiddleware> | HttpMiddlewareFn;
export declare class HttpController {
    baseUrl: string;
    actions: Set<HttpAction>;
    groups: string[];
    middlewares: (() => HttpMiddlewareConfig)[];
    resolverForToken: Map<any, ClassType>;
    resolverForParameterName: Map<string, ClassType>;
    private actionsProcessed;
    getUrl(action: HttpAction): string;
    addAction(action: HttpAction): void;
    getActions(): Set<HttpAction>;
    removeAction(methodName: string): void;
    getAction(methodName: string): HttpAction;
}
export declare class HttpActionParameter {
    name: string;
    type?: 'body' | 'query' | 'queries';
    /**
     * undefined = propertyName, '' === root, else given path
     */
    typePath?: string;
    optional: boolean;
}
export declare class HttpAction {
    name: string;
    description: string;
    category: string;
    path: string;
    httpMethods: string[];
    methodName: string;
    groups: string[];
    serializer?: Serializer;
    middlewares: (() => HttpMiddlewareConfig)[];
    serializationOptions?: SerializationOptions;
    resolverForToken: Map<any, ClassType>;
    resolverForParameterName: Map<string, ClassType>;
    /**
     * An arbitrary data container the user can use to store app specific settings/values.
     */
    data: Map<any, any>;
    responses: {
        statusCode: number;
        description: string;
        type?: Type;
    }[];
}
export declare class HttpControllerDecorator {
    t: HttpController;
    controller(baseUrl?: string): void;
    group(...group: string[]): void;
    middleware(...middlewares: HttpActionMiddleware[]): void;
    /**
     * Adds a parameter resolver for parameters based on the class type. Use .resolveParameterByName() for name-based resolving.
     *
     * ```typescript
     *
     * class UserResolver {
     *     resolve(context: RouteParameterResolverContext): any | Promise<any> {
     *         return new User();
     *     }
     * }
     *
     * @http.resolveParameter(User, UserResolver)
     * class MyController {
     *
     *     @http.GET()
     *     myAction(user: User) {
     *     }
     * }
     *
     * new App({providers: [UserResolver]}).run();
     * ```
     */
    resolveParameter(classType: ClassType | string | any, resolver: ClassType<RouteParameterResolver>): void;
    /**
     * Adds a parameter resolver for parameters based on its name. Use .resolveParameter() for class-based resolving.
     *
     * ```typescript
     *
     * class UserResolver {
     *     resolve(context: RouteParameterResolverContext): any | Promise<any> {
     *         return new User();
     *     }
     * }
     *
     * @http.resolveParameterByName('user', UserResolver)
     * class MyController {
     *
     *     @http.GET()
     *     myAction(user: User) {
     *     }
     * }
     *
     * new App({providers: [UserResolver]}).run();
     * ```
     */
    resolveParameterByName(name: string, resolver: ClassType<RouteParameterResolver>): void;
    setAction(action: HttpAction): void;
}
export declare const httpClass: ClassDecoratorResult<typeof HttpControllerDecorator>;
export declare function getActions(target: ClassType): HttpAction[];
export declare class HttpActionDecorator {
    t: HttpAction;
    onDecorator(target: ClassType, property: string | undefined, parameterIndexOrDescriptor?: any): void;
    name(name: string): void;
    description(description: string): void;
    serialization(options: SerializationOptions): void;
    serializer(serializer: Serializer): void;
    middleware(...middlewares: HttpActionMiddleware[]): void;
    /**
     * Allows to change the HttpAction object and composite multiple properties into one function.
     *
     * @example
     * ```typescript
     * const authGroup = Symbol('authGroup');
     *
     * function authGroup(group: 'admin' | 'user') {
     *    return (action: HttpAction) => {
     *        action.data.set(authGroup, group);
     *    };
     * }
     *
     * class My Controller {
     *    @http.GET('/assets').use(authGroup('admin'))
     *    assets() {}
     * }
     * ```
     */
    use(use: (action: HttpAction) => void): void;
    /**
     * Arbitrary value container that can be read in RouterParameterResolver and all
     * HTTP workflow events (like authentication).
     *
     * @example
     * ```typescript
     * class My Controller {
     *    @http.GET('/assets').data('authGroup', 'admin')
     *    assets() {}
     * }
     * ```
     */
    data(name: string, value: any): void;
    category(category: string): void;
    group(...group: string[]): void;
    GET(path?: string): void;
    HEAD(path?: string): void;
    POST(path?: string): void;
    PUT(path?: string): void;
    DELETE(path?: string): void;
    OPTIONS(path?: string): void;
    TRACE(path?: string): void;
    PATCH(path?: string): void;
    ANY(path?: string): void;
    /**
     * Adds additional information about what HTTP status codes are available in this route.
     * You can add additionally a description and a response body type.
     *
     * The type is used for serialization for responses with the given statusCode.
     *
     * This information is available in Deepkit API console.
     *
     * ```typescript
     *
     * http.GET().response<boolean>(200, 'All ok')
     *
     * interface User {
     *     username: string;
     * }
     * http.GET().response<User>(200, 'User object')
     *
     * interface HttpErrorMessage {
     *     error: string;
     * }
     * http.GET().response<HttpErrorMessage>(500, 'Error')
     * ```
     */
    response<T>(statusCode: number, description?: string, type?: ReceiveType<T>): void;
    /**
     * Adds a parameter resolver for parameters based on the class type. Use .resolveParameterByName() for name-based resolving.
     *
     * ```typescript
     *
     * class UserResolver {
     *     resolve(context: RouteParameterResolverContext): any | Promise<any> {
     *         return new User();
     *     }
     * }
     *
     * class MyController {
     *     @http.GET()
     *     @http.resolveParameter(User, UserResolver)
     *     myAction(user: User) {
     *     }
     * }
     *
     * new App({providers: [UserResolver]}).run();
     * ```
     */
    resolveParameter(classType: ClassType | string | any, resolver: ClassType<RouteParameterResolver>): void;
    /**
     * Adds a parameter resolver for parameters based on its name. Use .resolveParameter() for class-based resolving.
     *
     * ```typescript
     *
     * class UserResolver {
     *     resolve(context: RouteParameterResolverContext): any | Promise<any> {
     *         return new User();
     *     }
     * }
     *
     * class MyController {
     *     @http.GET()
     *     @http.resolveParameterByName('user', UserResolver)
     *     myAction(user: User) {
     *     }
     * }
     *
     * new App({providers: [UserResolver]}).run();
     * ```
     */
    resolveParameterByName(name: string, resolver: ClassType<RouteParameterResolver>): void;
}
type HttpActionFluidDecorator<T, D extends Function> = {
    [name in keyof T]: name extends 'response' ? <T2>(statusCode: number, description?: string, type?: ReceiveType<T2>) => D & HttpActionFluidDecorator<T, D> : T[name] extends (...args: infer K) => any ? (...args: K) => D & HttpActionFluidDecorator<T, D> : D & HttpActionFluidDecorator<T, D> & {
        _data: ExtractApiDataType<T>;
    };
};
type HttpActionPropertyDecoratorResult = HttpActionFluidDecorator<ExtractClass<typeof HttpActionDecorator>, PropertyDecoratorFn> & DecoratorAndFetchSignature<typeof HttpActionDecorator, PropertyDecoratorFn>;
export declare const httpAction: HttpActionPropertyDecoratorResult;
type HttpMerge<U> = {
    [K in keyof U]: K extends 'response' ? <T2>(statusCode: number, description?: string, type?: ReceiveType<T2>) => PropertyDecoratorFn & U : U[K] extends ((...a: infer A) => infer R) ? R extends DualDecorator ? (...a: A) => PropertyDecoratorFn & R & U : (...a: A) => R : never;
};
type MergedHttp<T extends any[]> = HttpMerge<Omit<UnionToIntersection<T[number]>, '_fetch' | 't'>>;
export type HttpDecorator = PropertyDecoratorFn & HttpActionFluidDecorator<HttpActionDecorator, PropertyDecoratorFn>;
export declare const http: MergedHttp<[typeof httpClass, typeof httpAction]>;
export {};
export declare type __ΩHttpDecorator = any[];