import { DTIAction, ActionParam, DTIError, INonceStore, DTISignHeaderNames } from '@napp/dti-core';
import { Request, Response, Router } from 'express';
import { z } from 'zod';

type TActionSchema = z.ZodType;
type TAnyAction = DTIAction<any, any, any, any, any>;
type InferActionSchema<TSchema> = TSchema extends TActionSchema ? z.infer<TSchema> : void;
type DTIServerAuth<AuthContext> = [AuthContext] extends [undefined] ? {
    auth?: undefined;
} : {
    auth: AuthContext;
};
type DTIServerMeta<MetaContext> = [MetaContext] extends [undefined] ? {
    meta?: undefined;
} : {
    meta: MetaContext;
};
type DTIAuthParam<TAction extends TAnyAction = TAnyAction> = {
    action: TAction;
    req: Request;
    res: Response;
};
type DTIAuthVerify<AuthContext> = (param: DTIAuthParam) => AuthContext | Promise<AuthContext>;
type DTIMetaParam<AuthContext> = {
    req: Request;
    res: Response;
} & DTIServerAuth<AuthContext>;
type DTIMetaResolve<AuthContext, MetaContext> = (param: DTIMetaParam<AuthContext>) => MetaContext | Promise<MetaContext>;
type DTIMetaOption<AuthContext, MetaContext> = MetaContext | DTIMetaResolve<AuthContext, MetaContext>;
type DTISignSecretParam = {
    keyId: string;
    req: Request;
    res: Response;
};
type DTISignSecretProvider = (param: DTISignSecretParam) => string | Promise<string>;
type DTIServerSignOptions = {
    getSecret: DTISignSecretProvider;
    nonceStore: INonceStore;
    toleranceMs?: number;
    headerNames?: Partial<DTISignHeaderNames>;
};
type DTIErrorParseParam<TAction extends TAnyAction = TAnyAction> = {
    error: unknown;
    action: TAction;
    req: Request;
    res: Response;
};
type DTIErrorParser = (param: DTIErrorParseParam) => DTIError | undefined | Promise<DTIError | undefined>;
type DTIServerErrorOptions = {
    parse?: DTIErrorParser;
};
type DTIExpressRouterOptions<AuthContext = undefined, MetaContext = undefined> = {
    auth?: DTIAuthVerify<AuthContext>;
    error?: DTIServerErrorOptions;
    meta?: DTIMetaOption<AuthContext, MetaContext>;
    sign?: DTIServerSignOptions;
};
type DTIFileBody = Buffer | Uint8Array | ArrayBuffer | Blob | string;
type DTITextResponse = {
    type: "text";
    body: string;
    contentType?: string;
    headers?: Record<string, string>;
    status?: number;
};
type DTITextOptions = {
    contentType?: string;
    headers?: Record<string, string>;
    status?: number;
};
type DTIFileResponse = {
    type: "file";
    body: DTIFileBody;
    filename?: string;
    contentType?: string;
    headers?: Record<string, string>;
    status?: number;
};
type DTIFileOptions = {
    body: DTIFileBody;
    filename?: string;
    contentType?: string;
    headers?: Record<string, string>;
    status?: number;
};
type DTIServerParam<TAction extends TAnyAction, AuthContext = undefined, MetaContext = undefined> = TAction extends DTIAction<infer _RSchema, infer QSchema, infer BSchema, infer _ResponseType, infer PSchema> ? ActionParam<InferActionSchema<QSchema>, InferActionSchema<BSchema>, InferActionSchema<PSchema>> & {
    req: Request;
    res: Response;
} & DTIServerAuth<AuthContext> & DTIServerMeta<MetaContext> : never;
type DTIServerResult<TAction extends TAnyAction> = TAction extends DTIAction<infer RSchema, infer _QSchema, infer _BSchema, infer ResponseType, infer _PSchema> ? ResponseType extends "text" ? string | DTITextResponse : ResponseType extends "file" ? DTIFileResponse : InferActionSchema<RSchema> : never;
type DTIActionHandler<TAction extends TAnyAction, AuthContext = undefined, MetaContext = undefined> = (param: DTIServerParam<TAction, AuthContext, MetaContext>) => DTIServerResult<TAction> | Promise<DTIServerResult<TAction>>;
declare function dtiText(body: string, options?: DTITextOptions): DTITextResponse;
declare function dtiFile(response: DTIFileOptions): DTIFileResponse;
declare class DTIExpressRouter<AuthContext = undefined, MetaContext = undefined> {
    private readonly options;
    private readonly expressRouter;
    private readonly actionNames;
    private readonly routeKeys;
    private readonly signHeaderNames;
    private readonly signToleranceMs;
    constructor(options?: DTIExpressRouterOptions<AuthContext, MetaContext>);
    action<TAction extends TAnyAction>(action: TAction, handler: DTIActionHandler<TAction, AuthContext, MetaContext>): this;
    router(): Router;
    private createRouteHandler;
    private parseParam;
    private verifySignature;
    private getRequiredSignHeader;
    private validateSignTimestamp;
    private resolveSignTolerance;
    private createNonceKey;
    private verifyAuth;
    private resolveMeta;
    private parseJsonResult;
    private parseTextResult;
    private parseFileResult;
    private validateResult;
    private registerRoute;
    private assertUniqueAction;
    private createRouteKey;
    private normalizeRoutePath;
    private createBodyParser;
    private sendTextResponse;
    private sendFileResponse;
    private setHeaders;
    private createSuccessResponse;
    private createFailureResponse;
    private handleError;
    private parseError;
    private getErrorStatus;
    private isTextResponse;
    private isFileResponse;
    private createFileBlob;
    private normalizeFileBody;
    private isBlob;
    private createContentDisposition;
    private createAsciiFilenameFallback;
    private isBodylessStatus;
}
declare function createDTIExpressRouter<AuthContext = undefined, MetaContext = undefined>(options?: DTIExpressRouterOptions<AuthContext, MetaContext>): DTIExpressRouter<AuthContext, MetaContext>;

export { type DTIActionHandler, type DTIAuthParam, type DTIAuthVerify, type DTIErrorParseParam, type DTIErrorParser, DTIExpressRouter, type DTIExpressRouterOptions, type DTIFileBody, type DTIFileOptions, type DTIFileResponse, type DTIMetaOption, type DTIMetaParam, type DTIMetaResolve, type DTIServerErrorOptions, type DTIServerParam, type DTIServerResult, type DTIServerSignOptions, type DTISignSecretParam, type DTISignSecretProvider, type DTITextOptions, type DTITextResponse, createDTIExpressRouter, dtiFile, dtiText };