import { AppContext } from "./app-context.js";
import { IdService } from "./base-service.js";
import { Option } from "./option.js";
import { Result } from "./result.js";
export interface EventoEnDecoder<REQ, RES> {
    encode(args: REQ): Promise<Result<unknown>>;
    decode(data: unknown): Promise<Result<RES>>;
}
export interface EventoSendProvider<INREQ, REQ, RES> {
    start?(trigger: HandleTriggerCtx<INREQ, REQ, RES>): Promise<Result<void>>;
    send<IS, OS>(trigger: HandleTriggerCtx<INREQ, REQ, RES>, data: IS): Promise<Result<OS>>;
    done?(trigger: HandleTriggerCtx<INREQ, REQ, RES>): Promise<Result<void>>;
}
export interface ActionStat {
    startTime: Date;
    doneTime: Date;
}
export interface SendStatItem<T> extends ActionStat {
    readonly item: Result<T>;
}
export interface SendStat extends ActionStat {
    items: SendStatItem<unknown>[];
}
export type RequestStat = ActionStat;
export interface TriggerStats {
    readonly request: RequestStat;
    readonly encode: ActionStat;
    readonly handlers: {
        readonly handler: EventoHandler;
        readonly total: ActionStat;
        readonly validated: ActionStat;
        readonly handled: ActionStat;
    }[];
    readonly send: SendStat;
}
export declare class EventoSend<INREQ, REQ, RES> {
    readonly provider: EventoSendProvider<INREQ, REQ, RES>;
    constructor(provider: EventoSendProvider<INREQ, REQ, RES>);
    start(trigger: HandleTriggerCtx<INREQ, REQ, RES>): Promise<Result<void>>;
    done(trigger: HandleTriggerCtx<INREQ, REQ, RES>): Promise<Result<void>>;
    send<IS, OS>(trigger: HandleTriggerCtx<INREQ, REQ, RES>, data: IS): Promise<Result<SendStatItem<OS>>>;
}
export interface TriggerCtxBase<INREQ, RES> {
    ctx: AppContext;
    encoder: EventoEnDecoder<INREQ, RES>;
}
export type ReadonlyTriggerCtxBase<INREQ, REQ, RES> = Readonly<TriggerCtxBase<INREQ, RES>> & {
    readonly id: string;
    readonly send: EventoSend<INREQ, REQ, RES>;
    readonly stats: TriggerStats;
};
export type TriggerCtxBaseParams<INREQ, REQ, RES> = Partial<Omit<ReadonlyTriggerCtxBase<INREQ, REQ, RES>, "send">> & Partial<Pick<ReadonlyTriggerCtxBase<INREQ, REQ, RES>, "ctx" | "encoder">> & {
    send: EventoSendProvider<INREQ, REQ, RES>;
    stats?: TriggerStats;
    idService?: IdService;
    id?: string;
};
export type TriggerCtxParams<INREQ, REQ, RES> = TriggerCtxBaseParams<INREQ, REQ, RES> & {
    request?: INREQ;
    enRequest?: unknown;
};
export type TriggerCtx<INREQ, REQ, RES> = (ReadonlyTriggerCtxBase<INREQ, REQ, RES> & {
    request: INREQ;
}) | (ReadonlyTriggerCtxBase<INREQ, REQ, RES> & {
    enRequest: unknown;
}) | (ReadonlyTriggerCtxBase<INREQ, REQ, RES> & {
    enRequest: unknown;
    request: INREQ;
});
export type TriggerResult<INREQ, REQ, RES> = Omit<ReadonlyTriggerCtxBase<INREQ, REQ, RES>, "send"> & {
    readonly send: EventoSend<INREQ, REQ, RES>;
    readonly stats: TriggerStats;
    readonly id: string;
} & Partial<MutableHandleTriggerCtx<INREQ, REQ>>;
export declare class TriggerResultError<INREQ, REQ, RES> extends Error {
    readonly ctx: TriggerResult<INREQ, REQ, RES>;
    constructor(message: string, ctx: TriggerResult<INREQ, REQ, RES>);
}
export interface ValidateTriggerCtx<INREQ, REQ, RES> extends ReadonlyTriggerCtxBase<INREQ, REQ, RES> {
    readonly request?: INREQ;
    readonly enRequest: unknown;
}
export interface MutableHandleTriggerCtx<INREQ, REQ> {
    request: INREQ;
    enRequest: unknown;
    validated: REQ;
    error?: Error;
}
export type HandleTriggerCtx<INREQ, REQ, RES> = Readonly<MutableHandleTriggerCtx<INREQ, REQ>> & ReadonlyTriggerCtxBase<INREQ, REQ, RES>;
export declare const EventoResult: {
    readonly Continue: "continue";
    readonly Stop: "stop";
};
export type EventoResultType = (typeof EventoResult)[keyof typeof EventoResult];
export declare enum EventoOp {
    Push = "push",
    Unshift = "unshift",
    Position = "position"
}
export declare enum EventoType {
    WildCard = "wildcard",
    Regular = "regular",
    Error = "error"
}
export interface EventoHandler<INREQ = unknown, REQ = unknown, RES = unknown> {
    readonly type?: EventoType;
    readonly hash: string;
    handle(trigger: HandleTriggerCtx<INREQ, REQ, RES>): Promise<Result<EventoResultType>>;
    validate?(trigger: ValidateTriggerCtx<INREQ, REQ, RES>): Promise<Result<Option<REQ>>>;
    post?(trigger: HandleTriggerCtx<INREQ, REQ, RES>): Promise<void>;
}
export interface EventoHandlerOpSimple {
    readonly type: EventoType;
    readonly op: EventoOp.Push | EventoOp.Unshift;
    readonly handler: EventoHandler;
}
export interface EventoHandlerOpPosition {
    readonly type: EventoType;
    readonly op: EventoOp.Position;
    readonly handler: EventoHandler;
    readonly idx: number;
}
export type EventoHandlerOp = EventoHandlerOpSimple | EventoHandlerOpPosition;
export declare class Evento {
    private actions;
    private wildcards;
    private errors;
    private encoder;
    constructor(encoder: EventoEnDecoder<unknown, unknown>);
    handlers(): {
        actions: EventoHandler[];
        wildcards: EventoHandler[];
    };
    push(...hdls: (EventoHandler | EventoHandler[])[]): (() => void)[];
    unshift(...hdls: (EventoHandler | EventoHandler[])[]): (() => void)[];
    register(...hdls: EventoHandlerOp[]): (() => void)[];
    trigger<INREQ, REQ, RES>(ictx: TriggerCtxParams<INREQ, REQ, RES>): Promise<Result<TriggerResult<INREQ, REQ, RES>>>;
}
//# sourceMappingURL=evento.d.ts.map