import { APIGatewayProxyEvent, APIGatewayProxyEventV2, Callback, Context as ApiGatewayContext } from "aws-lambda";
import { APIGatewayProxyResult } from "aws-lambda/trigger/api-gateway-proxy";
import { AnySchema, Schema, ValidationError } from "joi";
import { LogLevel } from "ts-injection";
import { BigsbyInstance } from "../bigsby";
import { ResponseBuilder } from "../response";
import { InferredType, ParameterInstructionTarget } from "./enums";
import { AuthenticationError, RequestInvalidError, RequestParseError, ResponseInvalidError, TypeCoercionError } from "./errors";
export declare type DeepPartial<T> = {
    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};
export interface ParameterInstruction {
    paramIndex: number;
    mapsTo: ParameterInstructionTarget;
    searchKey: string;
    type?: InferredType;
}
export declare type ApiEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2;
export declare type HandlerFunction = (event: ApiEvent, context: ApiGatewayContext, callback?: Callback<ApiResponse>) => Promise<ApiResponse>;
export declare type LifecycleErrors = AuthenticationError | ResponseInvalidError | RequestInvalidError | RequestParseError;
export declare type HandlerClassesInput = ApiHandlerConstructor | {
    [VersionId: string]: ApiHandlerConstructor;
} | ApiHandlerConstructor[];
export interface ApiResponse extends Omit<APIGatewayProxyResult, "body"> {
    body?: any;
}
export interface ApiErrorResponseBody {
    code: string;
    message: string;
    url: string;
}
export interface ApiHandlerConstructor {
    new (...args: any[]): ApiHandler;
}
export declare type ApiHandlerInvokeFunction = (...args: any[]) => Promise<any | ApiResponse>;
export declare type RawHandlerInvokeFunction = (event: ApiEvent, context: ApiGatewayContext, config: ApiConfig) => Promise<any | ApiResponse>;
export interface ApiHandler {
    invoke: ApiHandlerInvokeFunction;
}
export interface RequestContext {
    rawEvent: APIGatewayProxyEvent | APIGatewayProxyEventV2;
    event: StandardizedEvent;
    apiGwContext: ApiGatewayContext;
    config: ApiConfig;
    bigsby: BigsbyInstance;
    state: Record<string, any>;
    apiVersion: string;
}
export declare type StandardizedEvent = Omit<ApiEvent, "body"> & {
    body: string | Record<string, unknown> | undefined;
    method: string;
    path: string;
    protocol: string;
    version: "1.0" | "2.0";
};
export declare type RequestValidationSchema = {
    body?: AnySchema;
    headers?: AnySchema;
    pathParameters?: AnySchema;
    queryStringParameters?: AnySchema;
};
export interface ResponseValidationSchemaMap {
    [statusCode: number]: Schema<ApiResponse>;
}
export declare type Authenticator = (context: RequestContext) => Promise<void>;
export declare type AuthMethod = Authenticator | AuthSchemeName;
export declare type AuthSchemeName = string;
export interface AuthScheme {
    name: AuthSchemeName;
    authenticator: Authenticator;
}
export declare enum VersioningMethod {
    HEADER = "HEADER",
    PATH = "PATH"
}
export declare type BigsbyPluginFunction = (bigsby: BigsbyInstance, options?: Record<string, unknown>) => Promise<void>;
export interface BigsbyPlugin {
    name: string;
    onRegister: BigsbyPluginFunction;
}
export interface BigsbyPluginRegistration {
    plugin: BigsbyPlugin | string;
    options?: Record<string, unknown>;
}
export interface RegisteredPlugin extends BigsbyPluginRegistration {
    plugin: BigsbyPlugin;
}
export declare type ApiLifecycle = Required<Required<BigsbyConfig["api"]>["lifecycle"]>;
export declare type ApiHookNames = keyof ApiLifecycle;
export interface BigsbyConfig {
    api: ApiConfig;
    logging: LoggingConfig;
}
export declare type HookChain<HookMethod> = HookMethod[];
export declare type HookResult = {
    response: ResponseBuilder;
    immediate?: boolean;
} | void;
export declare type HookInput<InputType> = InputType & {
    response?: ResponseBuilder;
};
export interface LoggingConfig {
    enabled: boolean;
    level: LogLevel;
    logger?: BigsbyLogger;
}
export interface BigsbyLogger {
    debug: LogFunction;
    info: LogFunction;
    warn: LogFunction;
    error: LogFunction;
}
export declare type LogFunction = (msg: string, ...meta: any[]) => void;
declare type ContextInputs = HookInput<{
    context: RequestContext;
}>;
export declare type OnInitInputs = {
    bigsby: BigsbyInstance;
};
export declare type OnInitHook = HookChain<(inputs: OnInitInputs) => Promise<void>>;
export declare type PreInvokeInputs = ContextInputs;
export declare type PreInvokeHook = HookChain<(inputs: PreInvokeInputs) => Promise<HookResult>>;
export declare type PreAuthInputs = ContextInputs;
export declare type PreAuthHook = HookChain<(inputs: PreAuthInputs) => Promise<HookResult>>;
export declare type OnAuthFailInputs<ErrorType> = HookInput<{
    error: ErrorType;
    context: RequestContext;
}>;
export declare type OnAuthFailHook = HookChain<(<ErrorType>(inputs: OnAuthFailInputs<ErrorType>) => Promise<HookResult>)>;
export declare type PreParseInputs = ContextInputs;
export declare type PreValidateInputs = ContextInputs;
export declare type OnRequestInvalidInputs = HookInput<{
    error: ValidationError | RequestParseError;
    context: RequestContext;
}>;
export declare type PreExecuteInputs = ContextInputs;
export declare type PreResponseInputs = HookInput<{
    handlerResponse: ApiResponse;
    context: RequestContext;
}>;
export declare type OnResponseInvalidInputs = HookInput<{
    error: ValidationError | TypeCoercionError;
    context: RequestContext;
}>;
export declare type OnErrorInputs = HookInput<{
    error: unknown;
    context: RequestContext;
}>;
export declare type PreParseHook = HookChain<(inputs: PreParseInputs) => Promise<HookResult>>;
export declare type PreValidateHook = HookChain<(inputs: PreValidateInputs) => Promise<HookResult>>;
export declare type OnRequestInvalidHook = HookChain<(inputs: OnRequestInvalidInputs) => Promise<HookResult>>;
export declare type PreExecuteHook = HookChain<(inputs: PreExecuteInputs) => Promise<HookResult>>;
export declare type PreResponseHook = HookChain<(inputs: PreResponseInputs) => Promise<HookResult>>;
export declare type OnResponseInvalidHook = HookChain<(inputs: OnResponseInvalidInputs) => Promise<HookResult>>;
export declare type OnErrorHook = HookChain<(inputs: OnErrorInputs) => Promise<HookResult>>;
export interface ApiConfig {
    request: {
        enableTypeCoercion: boolean;
        auth?: AuthMethod;
        schema?: RequestValidationSchema;
    };
    response: {
        enableInferContentType: boolean;
        schema?: ResponseValidationSchemaMap;
        headers?: {
            [headerName: string]: string;
        };
    };
    versioning?: {
        method: VersioningMethod;
        key: string;
        defaultVersion: string;
    };
    lifecycle?: {
        onInit?: OnInitHook;
        preInvoke?: PreInvokeHook;
        preAuth?: PreAuthHook;
        onAuthFail?: OnAuthFailHook;
        preParse?: PreParseHook;
        preValidate?: PreValidateHook;
        onRequestInvalid?: OnRequestInvalidHook;
        preExecute?: PreExecuteHook;
        preResponse?: PreResponseHook;
        onResponseInvalid?: OnResponseInvalidHook;
        onError?: OnErrorHook;
    };
}
export {};