import { EventEmitter } from "node:events";
import { RedisAdapter } from "@myunisoft/redis";
import { type Logger } from "pino";
import type { Result } from "@openally/result";
import type { EventSubscribe, CallBackEventMessage, GenericEvent } from "../types/index.js";
import { type StandardLog } from "../utils/index.js";
import { Externals } from "./externals.class.js";
import { customValidationCbFn, eventsValidationFn } from "./events.class.js";
export declare const RESOLVED: unique symbol;
export declare const UNRESOLVED: unique symbol;
export type Resolved = "RESOLVED";
export type Unresolved = "UNRESOLVED";
export type EventCallbackResponse<T extends Resolved | Unresolved = Resolved | Unresolved> = Result<T extends Resolved ? {
    status: T;
} : {
    status: T;
    retryStrategy?: {
        maxIteration: number;
    };
    reason: string;
}, string>;
export type IncomerOptions<TListenedEvents extends GenericEvent = GenericEvent, KCastedEvents extends GenericEvent = GenericEvent> = {
    name: string;
    redis: RedisAdapter;
    subscriber: RedisAdapter;
    logger?: Logger;
    standardLog?: StandardLog<TListenedEvents | KCastedEvents>;
    eventsCast: string[];
    eventsSubscribe: EventSubscribe[];
    eventsValidation?: {
        eventsValidationFn?: eventsValidationFn<TListenedEvents | KCastedEvents>;
        customValidationCbFn?: customValidationCbFn<TListenedEvents | KCastedEvents>;
    };
    eventCallback: (message: CallBackEventMessage<TListenedEvents>) => Promise<EventCallbackResponse>;
    dispatcherInactivityOptions?: {
        maxPingInterval?: number;
        publishInterval?: number;
        idleTime?: number;
    };
    isDispatcherInstance?: boolean;
    externalsInitialized?: boolean;
};
export declare class Incomer<TListenedEvents extends GenericEvent = GenericEvent, KCastedEvents extends GenericEvent = GenericEvent> extends EventEmitter {
    #private;
    readonly name: string;
    readonly eventCallback: (message: CallBackEventMessage<TListenedEvents>) => Promise<EventCallbackResponse>;
    dispatcherConnectionState: boolean;
    baseUUID: `${string}-${string}-${string}-${string}-${string}`;
    providedUUID: string;
    private incomerChannel;
    private incomerChannelName;
    private subscriber;
    private defaultIncomerTransactionStore;
    private incomerStore;
    private newTransactionStore;
    private logger;
    private dispatcherChannelName;
    private lastActivity;
    externals: Externals<TListenedEvents, KCastedEvents> | undefined;
    constructor(options: IncomerOptions<TListenedEvents, KCastedEvents>);
    private checkDispatcherState;
    private lazyRetryPublish;
    private retryPublish;
    private registrationAttempt;
    private registrationIntervalCb;
    initialize(): Promise<void>;
    close(): Promise<void>;
    private cleanupTransactions;
    publish(event: KCastedEvents): Promise<string>;
    private handleMessages;
    private handleDispatcherMessages;
    private handleIncomerMessages;
    private handlePing;
    private customEvent;
    private handleApprovement;
}
//# sourceMappingURL=incomer.class.d.ts.map