import { Channel, RedisAdapter } from "@myunisoft/redis";
import type { Logger } from "pino";
import { TransactionStore, type Transaction } from "./store/transaction.class.js";
import { IncomerStore } from "./store/incomer.class.js";
import { IncomerChannelHandler } from "./incomer-channel.class.js";
import { type StandardLog } from "../utils/index.js";
import { EventsHandler } from "./events.class.js";
import type { DispatcherApprovementMessage, TransactionMetadata, DistributedEventMessage, GenericEvent, IncomerChannelMessages, RegisteredIncomer } from "../types/index.js";
type DispatchedEvent<T extends GenericEvent> = (IncomerChannelMessages<T>["DispatcherMessages"] | DispatcherApprovementMessage) & {
    redisMetadata: Omit<DispatcherApprovementMessage["redisMetadata"], "transactionId">;
};
export interface DispatchEventOptions<T extends GenericEvent> {
    channel: Channel<DispatchedEvent<T>>;
    redisMetadata: {
        mainTransaction: boolean;
        relatedTransaction?: null | string;
        eventTransactionId?: null | string;
        resolved: boolean;
    };
    event: DispatchedEvent<T>;
}
export type TransactionHandlerOptions<T extends GenericEvent = GenericEvent> = {
    redis: RedisAdapter;
    eventsHandler: EventsHandler<T>;
    dispatcherTransactionStore: TransactionStore<"dispatcher">;
    backupDispatcherTransactionStore: TransactionStore<"dispatcher">;
    backupIncomerTransactionStore: TransactionStore<"incomer">;
    incomerChannelHandler: IncomerChannelHandler<T>;
    incomerStore: IncomerStore;
    privateUUID: string;
    parentLogger: Logger;
    idleTime: number;
    logger?: Logger;
    standardLog?: StandardLog<T>;
    pingInterval?: number;
};
export interface RedistributeUnresolvedSpreadTransactionOptions {
    backupIncomerTransaction: Transaction<"incomer">;
    isoListener: RegisteredIncomer;
    relatedDispatcherTransactionId: string;
    backupTransactionId: string;
}
export interface RedistributeUnresolvedSpreadTransactionResponse<T extends GenericEvent = GenericEvent> {
    dispatcherTransactionUUID: string;
    event: Omit<DistributedEventMessage, "redisMetadata"> & {
        redisMetadata: Omit<TransactionMetadata<"dispatcher">, "iteration" | "transactionId">;
    };
    redisMetadata: DispatchEventOptions<T>["redisMetadata"];
}
export interface RedistributeResolvedSpreadTransactionOptions {
    isoListener: RegisteredIncomer;
    backupIncomerTransaction: Transaction<"incomer">;
    backupTransactionId: string;
    relatedDispatcherTransaction: Transaction<"dispatcher">;
    relatedDispatcherTransactionId: string;
}
export declare class TransactionHandler<T extends GenericEvent = GenericEvent> {
    #private;
    readonly privateUUID: any;
    incomerStore: IncomerStore;
    dispatcherTransactionStore: TransactionStore<"dispatcher">;
    backupDispatcherTransactionStore: TransactionStore<"dispatcher">;
    backupIncomerTransactionStore: TransactionStore<"incomer">;
    constructor(opts: TransactionHandlerOptions<T>);
    close(): void;
    resolveTransactions(): Promise<void>;
    resolveInactiveIncomerTransactions(inactiveIncomer: RegisteredIncomer): Promise<void>;
    private backupMainTransaction;
    private distributeMainTransaction;
    private handleBackupIncomerTransactions;
    private findISOIncomer;
    private redistributeMainTransaction;
    private resolvePingTransactions;
    private resolveMainTransactions;
    private republishBackupDispatcherEvents;
}
export {};
//# sourceMappingURL=transaction-handler.class.d.ts.map