import { Request, Response } from 'express';
import { Logger } from 'winston';
import { z } from 'zod';
import { ConfigType } from './config-type';
import { ApiResponse, IOSchema, Merge, OutputMarker, ReplaceMarkerInShape } from './helpers';
import { Method, MethodsDefinition } from './method';
import { MiddlewareDefinition } from './middleware';
import { ResultHandlerDefinition } from './result-handler';
export declare type Handler<IN, OUT, OPT> = (params: {
    input: IN;
    options: OPT;
    logger: Logger;
}) => Promise<OUT>;
export declare abstract class AbstractEndpoint {
    protected description?: string;
    abstract execute(params: {
        request: Request;
        response: Response;
        logger: Logger;
        config: ConfigType;
    }): Promise<void>;
    getDescription(): string | undefined;
    abstract getMethods(): Method[];
    abstract getInputSchema(): IOSchema;
    abstract getOutputSchema(): IOSchema;
    abstract getPositiveResponseSchema(): z.ZodTypeAny;
    abstract getNegativeResponseSchema(): z.ZodTypeAny;
    abstract getPositiveMimeTypes(): string[];
    abstract getNegativeMimeTypes(): string[];
}
export declare type EndpointInput<T> = T extends Endpoint<infer IN, any, infer mIN, any, any, any, any> ? z.input<Merge<IN, mIN>> : never;
export declare type EndpointOutput<T> = T extends Endpoint<any, infer OUT, any, any, any, any, any> ? z.output<OUT> : never;
export declare type EndpointResponse<E extends AbstractEndpoint> = z.output<ReturnType<E['getPositiveResponseSchema']> extends z.ZodObject<z.ZodRawShape> ? z.ZodObject<ReplaceMarkerInShape<ReturnType<E['getPositiveResponseSchema']>['_shape'], ReturnType<E['getOutputSchema']>>> : ReturnType<E['getPositiveResponseSchema']> extends OutputMarker ? ReturnType<E['getOutputSchema']> : ReturnType<E['getPositiveResponseSchema']>> | z.output<ReturnType<E['getNegativeResponseSchema']>>;
declare type EndpointProps<IN extends IOSchema, OUT extends IOSchema, mIN, OPT, M extends Method, POS extends ApiResponse, NEG extends ApiResponse> = {
    middlewares: MiddlewareDefinition<any, any, any>[];
    inputSchema: IN;
    outputSchema: OUT;
    handler: Handler<z.output<Merge<IN, mIN>>, z.input<OUT>, OPT>;
    resultHandler: ResultHandlerDefinition<POS, NEG>;
    description?: string;
} & MethodsDefinition<M>;
/** mIN, OPT - from Middlewares */
export declare class Endpoint<IN extends IOSchema, OUT extends IOSchema, mIN, OPT, M extends Method, POS extends ApiResponse, NEG extends ApiResponse> extends AbstractEndpoint {
    #private;
    protected methods: M[];
    protected middlewares: MiddlewareDefinition<any, any, any>[];
    protected inputSchema: Merge<IN, mIN>;
    protected outputSchema: OUT;
    protected handler: Handler<z.output<Merge<IN, mIN>>, z.input<OUT>, OPT>;
    protected resultHandler: ResultHandlerDefinition<POS, NEG>;
    constructor({ middlewares, inputSchema, outputSchema, handler, resultHandler, description, ...rest }: EndpointProps<IN, OUT, mIN, OPT, M, POS, NEG>);
    getMethods(): M[];
    getInputSchema(): Merge<IN, mIN>;
    getOutputSchema(): OUT;
    getPositiveResponseSchema(): POS['schema'];
    getNegativeResponseSchema(): NEG['schema'];
    getPositiveMimeTypes(): string[];
    getNegativeMimeTypes(): string[];
    execute({ request, response, logger, config }: {
        request: Request;
        response: Response;
        logger: Logger;
        config: ConfigType;
    }): Promise<void>;
}
export {};