import { InjectorService, Provider } from "@tsed/di";
import { EndpointMetadata, HandlerMetadata, ParamTypes } from "../../mvc";
import { HandlerContext } from "../domain/HandlerContext";
import { PlatformContext } from "../domain/PlatformContext";
import { PlatformRouteWithoutHandlers } from "../interfaces/PlatformRouterMethods";
export interface OnRequestOptions {
    $ctx: PlatformContext;
    metadata: HandlerMetadata;
    next?: any;
    err?: any;
    [key: string]: any;
}
/**
 * Platform Handler abstraction layer. Wrap original class method to a pure platform handler (Express, Koa, etc...).
 * @platform
 */
export declare class PlatformHandler {
    protected injector: InjectorService;
    constructor(injector: InjectorService);
    /**
     * Create a native middleware based on the given metadata and return an instance of HandlerContext
     * @param input
     * @param options
     */
    createHandler(input: EndpointMetadata | HandlerMetadata | any, options?: PlatformRouteWithoutHandlers): Function;
    createCustomHandler(provider: Provider<any>, propertyKey: string): Function;
    /**
     * Create handler metadata
     * @param obj
     * @param routeOptions
     */
    createHandlerMetadata(obj: any | EndpointMetadata, routeOptions?: PlatformRouteWithoutHandlers): HandlerMetadata;
    /**
     * Get argument from parameter medata or handler context.
     * @param type
     * @param h
     */
    protected getArg(type: ParamTypes | string, h: HandlerContext): any;
    protected onCtxRequest(requestOptions: OnRequestOptions): Promise<any>;
    /**
     * Call handler when a request his handle
     * @param requestOptions
     */
    protected onRequest(requestOptions: OnRequestOptions): Promise<any>;
    protected onError(er: unknown, requestOptions: OnRequestOptions): Promise<any>;
    /**
     * Manage success scenario
     * @param data
     * @param requestOptions
     * @protected
     */
    protected onSuccess(data: any, requestOptions: OnRequestOptions): Promise<any>;
    /**
     * Call the returned middleware by the handler.
     * @param middleware
     * @param ctx
     * @param next
     * @protected
     */
    protected callReturnedMiddleware(middleware: any, ctx: PlatformContext, next: any): any;
    /**
     * Send the response to the consumer.
     * @param data
     * @param ctx
     * @protected
     */
    protected flush(data: any, ctx: PlatformContext): Promise<void>;
    /**
     * Render the view if the endpoint has a configured view.
     * @param data
     * @param ctx
     * @protected
     */
    protected render(data: any, ctx: PlatformContext): Promise<any>;
    /**
     * create Raw handler
     * @param metadata
     */
    protected createRawHandler(metadata: HandlerMetadata): Function;
    /**
     * Set response headers
     * @param ctx
     * @protected
     */
    protected setHeaders(ctx: PlatformContext): void;
    protected next(requestOptions: OnRequestOptions): any;
    /**
     * Return arguments to call handler
     * @param h
     */
    private getArgs;
    /**
     * Sort pipes before calling it
     * @param metadata
     */
    private sortPipes;
    /**
     * Map argument by calling pipe.
     * @param metadata
     * @param h
     */
    private mapArg;
}