import type { MaybePromise } from './types';
import type { Data } from './data';
import { type RepliesType, type Reply, type ReplyFrom } from './reply';
import type { Logger } from './logger';
export type MiddlewareHandler = (input: {
    event: any;
    env: Environment;
    logger: Logger;
}) => MaybePromise<void>;
export interface Middleware<T> {
    name?: string;
    requires?: MiddlewareList;
    handler: (input: {
        event: any;
        env: Environment;
        ctx: ExecutionContext | DurableObjectState;
        logger: Logger;
    }) => MaybePromise<void>;
    replies?: RepliesType;
}
export type MiddlewareList = readonly [...readonly Middleware<any>[]];
export type ExtensionFrom<MW> = MW extends Middleware<infer Extension> ? Extension : never;
export type ExtensionsFrom<MWs, Accumulator = unknown> = MWs extends readonly [infer Current, ...infer Rest] ? ExtensionsFrom<Rest, Accumulator & ExtensionFrom<Current>> : Accumulator;
export type MiddlewareContext = {
    isDurableObject: true;
    /**
     * @deprecated
     */
    state: DurableObjectState;
} | {
    isDurableObject: false;
    /**
     * @deprecated
     */
    ctx: ExecutionContext;
};
declare class NextData<const T extends Record<string, unknown> = Record<never, never>> {
    data: T;
    constructor(data?: T);
}
type NextFn = <const T extends Record<string, unknown> = Record<never, never>>(data?: T) => NextData<T>;
export declare const next: NextFn;
export declare function middleware<const Extension extends Record<string, unknown> = Record<never, never>>(handler: (input: {
    event: Data & {
        reply: Reply;
        next: NextFn;
    } & MiddlewareContext;
    env: Environment;
    ctx: ExecutionContext | DurableObjectState;
    logger: Logger;
}) => MaybePromise<NextData<Extension> | Reply>): Middleware<Extension extends Record<any, any> ? Extension : unknown>;
export declare function middleware<const Requires extends MiddlewareList, const Replies extends RepliesType | undefined = undefined, const Extension extends Record<string, unknown> = Record<never, never>>(options: {
    name?: string;
    requires?: Requires;
    replies?: Replies;
}, handler: (input: {
    event: Data & {
        reply: ReplyFrom<Replies>;
        next: NextFn;
        body: unknown;
    } & MiddlewareContext & ExtensionsFrom<Requires>;
    env: Environment;
    ctx: ExecutionContext | DurableObjectState;
    logger: Logger;
}) => MaybePromise<NextData<Extension> | Reply>): Middleware<Extension extends Record<any, any> ? Extension : unknown>;
export {};