import { L as LogType, P as PayFeeLog, T as TransferLog, H as HtlcCreateLog, a as HtlcTimeoutResolveLog, b as HtlcRegularTransferLog, c as HtlcEarlyResolveLog, V as VestingCreateLog, C as CreateValidatorLog, U as UpdateValidatorLog, d as ValidatorFeeDeductionLog, D as DeactivateValidatorLog, R as ReactivateValidatorLog, e as RetireValidatorLog, f as DeleteValidatorLog, g as CreateStakerLog, S as StakeLog, h as UpdateStakerLog, i as SetActiveStakeLog, j as RetireStakeLog, k as RemoveStakeLog, l as DeleteStakerLog, m as StakerFeeDeductionLog, n as PayoutRewardLog, o as PenalizeLog, J as JailValidatorLog, p as RevertContractLog, F as FailedTransactionLog, q as Log } from './shared/nimiq-rpc-client-ts.DuCE4p5H.cjs';
import { x as Block, e as Validator } from './shared/nimiq-rpc-client-ts.BvvqdQ38.cjs';

/**
 * Stream options and defaults
 */
interface StreamOptions<T = unknown> {
    once?: boolean;
    filter?: (data: T) => boolean;
    timeout?: number | false;
    autoReconnect?: boolean | {
        retries?: number | (() => boolean);
        delay?: number;
        onFailed?: () => void;
    };
    onError?: (error: Error) => void;
    withMetadata?: boolean;
}
/**
 * Events emitted by WSSubscription
 */
interface WSEvents<T> {
    open: Event;
    data: CustomEvent<{
        data: T;
        metadata?: unknown;
    }>;
    error: CustomEvent<Error>;
    close: CustomEvent<{
        code: number;
        reason: string;
    }> | Event;
}
/**
 * A WebSocket subscription as an EventTarget
 */
interface WSSubscription<T> extends EventTarget {
    /** Returns the JSON-RPC subscription ID */
    getId: () => number;
    /** Whether the socket is currently open */
    isOpen: () => boolean;
    /** RPC method & params used */
    context: {
        method: string;
        params: any[];
        url: string;
        timestamp: number;
    };
    addEventListener: <K extends keyof WSEvents<T>>(type: K, listener: (ev: WSEvents<T>[K]) => void, options?: boolean | AddEventListenerOptions) => void;
    removeEventListener: <K extends keyof WSEvents<T>>(type: K, listener: (ev: WSEvents<T>[K]) => void, options?: boolean | EventListenerOptions) => void;
}
declare function rpcSubscribe<T>(method: string, params?: any[], options?: StreamOptions<T>): Promise<WSSubscription<T>>;
/**
 * Subscribe to new block events (retrieves the full block)
 */
declare function subscribeForHeadBlock(fullBlock?: boolean, opts?: StreamOptions<Block>): Promise<WSSubscription<Block>>;
/**
 * Subscribe to new block events (only retrieves the block hash)
 */
declare function subscribeForHeadBlockHash(opts?: StreamOptions<string[]>): Promise<WSSubscription<string[]>>;
/**
 * Maps LogType to corresponding log interface
 */
interface LogTypeMap {
    [LogType.PayFee]: PayFeeLog;
    [LogType.Transfer]: TransferLog;
    [LogType.HtlcCreate]: HtlcCreateLog;
    [LogType.HtlcTimeoutResolve]: HtlcTimeoutResolveLog;
    [LogType.HtlcRegularTransfer]: HtlcRegularTransferLog;
    [LogType.HtlcEarlyResolve]: HtlcEarlyResolveLog;
    [LogType.VestingCreate]: VestingCreateLog;
    [LogType.CreateValidator]: CreateValidatorLog;
    [LogType.UpdateValidator]: UpdateValidatorLog;
    [LogType.ValidatorFeeDeduction]: ValidatorFeeDeductionLog;
    [LogType.DeactivateValidator]: DeactivateValidatorLog;
    [LogType.ReactivateValidator]: ReactivateValidatorLog;
    [LogType.RetireValidator]: RetireValidatorLog;
    [LogType.DeleteValidator]: DeleteValidatorLog;
    [LogType.CreateStaker]: CreateStakerLog;
    [LogType.Stake]: StakeLog;
    [LogType.UpdateStaker]: UpdateStakerLog;
    [LogType.SetActiveStake]: SetActiveStakeLog;
    [LogType.RetireStake]: RetireStakeLog;
    [LogType.RemoveStake]: RemoveStakeLog;
    [LogType.DeleteStaker]: DeleteStakerLog;
    [LogType.StakerFeeDeduction]: StakerFeeDeductionLog;
    [LogType.PayoutReward]: PayoutRewardLog;
    [LogType.Penalize]: PenalizeLog;
    [LogType.JailValidator]: JailValidatorLog;
    [LogType.RevertContract]: RevertContractLog;
    [LogType.FailedTransaction]: FailedTransactionLog;
}
/**
 * Helper type to extract log type from LogType array
 */
type LogTypeToInterface<T extends LogType[]> = T extends (infer U)[] ? U extends LogType ? LogTypeMap[U] : never : never;
/**
 * Subscribe to log events related to given addresses and log types
 */
declare function subscribeForLogsByAddressesAndTypes<T extends LogType[] = []>(addresses?: string[], logTypes?: T, opts?: StreamOptions<T extends [] ? Log : LogTypeToInterface<T>>): Promise<WSSubscription<T extends [] ? Log : LogTypeToInterface<T>>>;
/**
 * Subscribe to validator election events by address
 */
declare function subscribeForValidatorElectionByAddress(address: string, opts?: StreamOptions<Validator[]>): Promise<WSSubscription<Validator[]>>;

export { type LogTypeMap, type LogTypeToInterface, type StreamOptions, type WSEvents, type WSSubscription, rpcSubscribe, subscribeForHeadBlock, subscribeForHeadBlockHash, subscribeForLogsByAddressesAndTypes, subscribeForValidatorElectionByAddress };