import FindMyWay, { Handler, HTTPVersion, HTTPMethod, RouteOptions } from 'find-my-way';
import { StatusCodes } from 'readable-http-codes';
import * as pino from 'pino';
import { Logger } from 'pino';
import { LambdaRequestTrackerOptions, lambdaRequestTracker } from 'pino-lambda';
import { RequireAllOrNone, Promisable } from 'type-fest';
import { Buffer } from 'node:buffer';

type RouterInstance = ReturnType<typeof FindMyWay<HTTPVersion.V1>>;
interface FMWRoute {
    handler: Handler<HTTPVersion.V1>;
    method: HTTPMethod;
    path: string;
    pattern?: string;
    params: string[];
    opts?: RouteOptions;
    store?: Record<any, any>;
}
type Plugin<Instance extends Router<any>, PluginOptions = any> = (instance: Instance, options: PluginOptions) => any;
type HandlerEvent = Record<any, any> & RequireAllOrNone<{
    version: string;
    routeKey: string;
    rawPath: string;
    rawQueryString: string;
    headers: {
        [key: string]: string;
        'accept-encoding': string;
        'host': string;
        'user-agent': string;
        'via': string;
        'x-amz-cf-id': string;
        'x-amzn-trace-id': string;
        'x-forwarded-for': string;
        'x-forwarded-port': string;
        'x-forwarded-proto': string;
    };
    requestContext: {
        accountId: string;
        apiId: string;
        domainName: string;
        domainPrefix: string;
        http: {
            method: string;
            path: string;
            protocol: string;
            sourceIp: string;
            userAgent: string;
        };
        requestId: string;
        routeKey: string;
        stage: string;
        time: string;
        timeEpoch: number;
    };
    isBase64Encoded: boolean;
}> & RequireAllOrNone<{
    Records: HandlerEventRecord[];
}>;
type HandlerEventRecord = Record<any, any> & RequireAllOrNone<{
    eventVersion: string;
    eventSource: string;
    awsRegion: string;
    eventTime: string;
    eventName: string;
    userIdentity: any | {
        principalId: string;
    };
    requestParameters: any | {
        sourceIPAddress: string;
    };
    responseElements: any;
    [key: string]: any;
}>;
interface HandlerContext {
    callbackWaitsForEmptyEventLoop: boolean;
    functionName: string;
    functionVersion: string;
    invokedFunctionArn: string;
    memoryLimitInMB: string;
    awsRequestId: string;
    logGroupName: string;
    logStreamName: string;
    identity?: any | undefined;
    clientContext?: any | undefined;
    getRemainingTimeInMillis: () => number;
}
interface HandlerResponse {
    headers?: {
        [key: string]: any;
    };
    cookies?: string[];
    statusCode?: number;
    body?: any;
    isBase64Encoded?: boolean;
    [key: string]: any;
}
interface VoieEventInterfaceAdapter {
    route: {
        method: Route<any>['method'];
        path: Route<any>['path'];
        params: Record<any, any>;
        cookies?: Record<string, string>;
    };
}
interface EventRoute {
    eventSource: string;
    name: string;
    handler: (record: HandlerEventRecord, context: HandlerContext) => any;
    befores: MiddlewareBefore<HandlerEventRecord>[];
    afters: MiddlewareAfter<HandlerEventRecord>[];
    before: (fn: MiddlewareBefore<HandlerEventRecord>) => this;
    after: (fn: MiddlewareAfter<HandlerEventRecord>) => this;
}
interface Route<EventInterface extends HandlerEvent> extends Pick<FMWRoute, 'method' | 'path'> {
    handler: LambdaHandler<EventInterface>;
    befores: MiddlewareBefore<EventInterface>[];
    afters: MiddlewareAfter<EventInterface>[];
    before: (fn: MiddlewareBefore<EventInterface>) => this;
    after: (fn: MiddlewareAfter<EventInterface>) => this;
}
type MiddlewareBefore<D> = (data: D, context: HandlerContext) => Promisable<void>;
type MiddlewareAfter<D> = (data: D, context: HandlerContext, res: HandlerResponse) => Promisable<any>;
type LambdaHandler<EventInterface extends HandlerEvent> = (event: EventInterface, context: HandlerContext) => Promisable<HandlerResponse> | any;
interface RouterConstructOptions {
    /**
     * Pass in your custom logger if needed.
     */
    logger?: Logger;
    /**
     * Options for `pino-lambda`'s withRequest(), could be disabled with falsy values.
     */
    withRequestOptions?: LambdaRequestTrackerOptions;
}

declare function fakeEvent(method: Route<any>['method'], path: Route<any>['path'], spread?: Record<string, any>): HandlerEvent;
declare function tryIt<F extends (...args: any) => any, D = any>(fn: F, fallbackValue?: D): ReturnType<F> | D | undefined;
declare class DetailedError extends Error {
    /**
     * Additional message that will be logged AND returned to client
     */
    detail?: any;
    /**
     * Additional code that will be logged AND returned to client
     */
    code?: any;
    /**
     * Additional object that will be logged AND NOT returned to client
     */
    log?: any;
    /**
     * Optionally set the status code to return
     */
    statusCode?: any;
    constructor(message: string, options?: {
        detail?: any;
        code?: any;
        statusCode?: number;
        log?: any;
    });
}
declare function eventMethodUrl(event: HandlerEvent): {
    method: string;
    url: string;
};
/**
 * This utility picks the follow keys from the event: routeKey, rawPath, rawQueryString, headers, requestContext, isBase64Encoded
 *
 * @param {boolean} [options.minimal] - pick only necessary contexts for a response call, that is: routeKey, rawPath, headers, requestContext.http.method
 * @returns
 */
declare function pickEventContext(event: HandlerEvent, options?: {
    minimal?: boolean;
}): Pick<HandlerEvent, "routeKey" | "rawPath" | "rawQueryString" | "headers" | "requestContext" | "isBase64Encoded"> | {
    requestContext: {
        http: {
            method: string;
        };
    };
    routeKey: string;
    rawPath: string;
    headers: {
        [key: string]: string;
        'accept-encoding': string;
        host: string;
        'user-agent': string;
        via: string;
        'x-amz-cf-id': string;
        'x-amzn-trace-id': string;
        'x-forwarded-for': string;
        'x-forwarded-port': string;
        'x-forwarded-proto': string;
    };
};
/**
 * Compress inputted data, `response` could be passed in to mutate it.
 */
declare function compress(data: any, options?: {
    response?: HandlerResponse;
    acceptEncoding?: string;
    level?: number;
}): {
    encoding: string;
    data: Buffer;
};
declare function decompress(compressedData: string | Buffer, options: {
    contentEncoding: string;
}): string;
declare function decodeBody(body: any): any;
/**
 * Helper to decompress and parse the response's body if needed
 */
declare function decodeResponse<R extends HandlerResponse>(response: R): R;

declare const logger: pino.Logger<{
    level: "debug" | "info";
    base: undefined;
}>;

declare class Router<EventInterface extends HandlerEvent = HandlerEvent> {
    EventInterface: EventInterface;
    RouteInterface: Route<EventInterface>;
    __pluginData__: Record<string, any>;
    $event?: EventInterface;
    logger: Logger;
    withRequest?: ReturnType<typeof lambdaRequestTracker>;
    router: RouterInstance;
    routes: Record<string, this['RouteInterface']>;
    eventRoutes: Record<string, Record<string, EventRoute>>;
    allowEmptyRouteLookup: boolean;
    constructor(options?: RouterConstructOptions);
    use<P extends Plugin<this, any>>(plugin: P, options?: Parameters<P>[1]): this;
    getDefaultRoute(): any;
    setDefaultRoute(handler: this['RouteInterface']['handler'], passThrough?: boolean): void;
    eventRoute(eventSource: EventRoute['eventSource'], name: EventRoute['name']): EventRoute | undefined;
    eventRoute(eventSource: EventRoute['eventSource'], name: EventRoute['name'], handler: EventRoute['handler'], options?: {
        override?: boolean;
    }): EventRoute;
    route(method: this['RouteInterface']['method'], path: this['RouteInterface']['path']): this['RouteInterface'] | undefined;
    route(method: this['RouteInterface']['method'], path: this['RouteInterface']['path'], handler: this['RouteInterface']['handler'], options?: {
        override?: boolean;
    }): this['RouteInterface'];
    routeHandler(route: this['RouteInterface'], data: EventInterface, context: HandlerContext): Promisable<HandlerResponse> | any;
    routeHandler(route: EventRoute, data: HandlerEventRecord, context: HandlerContext): Promisable<HandlerResponse> | any;
    _routeHandler(route: this['RouteInterface'] | EventRoute, data: EventInterface | HandlerEventRecord, context: HandlerContext): Promise<any>;
    handle(): LambdaHandler<EventInterface>;
    _lookupShims(event: EventInterface, context?: HandlerContext): ReturnType<this["RouteInterface"]["handler"]>;
    _lookupTransform(fn: (lookupData: {
        method: string;
        path: string;
        event: EventInterface;
        context: HandlerContext;
        params: {
            [k: string]: string | undefined;
        };
        searchParams: {
            [k: string]: string;
        };
    }) => any): FMWRoute['handler'];
    makePassThrough(handler: this['RouteInterface']['handler']): FindMyWay.Handler<FindMyWay.HTTPVersion.V1>;
    makeOnHandler(route: this['RouteInterface']): FindMyWay.Handler<FindMyWay.HTTPVersion.V1>;
    makeLambdaHandler(): LambdaHandler<EventInterface>;
    processRecordHandler(handler: EventRoute['handler'], record: HandlerEventRecord, context: HandlerContext): Promise<any>;
}
declare class Voie<EventInterface extends HandlerEvent = HandlerEvent & VoieEventInterfaceAdapter> extends Router {
    EventInterface: EventInterface;
    RouteInterface: Route<EventInterface>;
    autoCorsCheck(event: EventInterface): boolean;
    response(statusCode: StatusCodes, body: any, options?: {
        event?: EventInterface;
        headers?: Record<string, string>;
        cookies?: Record<string, string> | Array<string>;
        autoAllow?: boolean;
        autoCors?: boolean;
        compress?: false | 'auto' | number;
        contentType?: string | false;
    }): HandlerResponse;
}

export { DetailedError, type EventRoute, type FMWRoute, type HandlerContext, type HandlerEvent, type HandlerEventRecord, type HandlerResponse, type LambdaHandler, type MiddlewareAfter, type MiddlewareBefore, type Plugin, type Route, Router, type RouterConstructOptions, type RouterInstance, Voie, type VoieEventInterfaceAdapter, compress, decodeBody, decodeResponse, decompress, eventMethodUrl, fakeEvent, logger, pickEventContext, tryIt };