/**
 * @module CircuitBreaker
 */
import { type CircuitBreakerEventMap, type CircuitBreakerProviderCreateSettings, type ICircuitBreaker, type ICircuitBreakerProvider, type ICircuitBreakerAdapter, type CircuitBreakerTrigger } from "../../../../circuit-breaker/contracts/_module.js";
import { type EventListener, type IEventBus, type Unsubscribe } from "../../../../event-bus/contracts/_module.js";
import { Namespace } from "../../../../namespace/_module.js";
import { type ISerderRegister } from "../../../../serde/contracts/_module.js";
import { type ITask } from "../../../../task/contracts/_module.js";
import { type ITimeSpan } from "../../../../time-span/contracts/_module.js";
import { type ErrorPolicy, type OneOrMore } from "../../../../utilities/_module.js";
/**
 *
 * IMPORT_PATH: `"@daiso-tech/core/circuit-breaker"`
 * @group Derivables
 */
export type CircuitBreakerProviderSettingsBase = {
    /**
     * @default
     * ```ts
     * import { Namespace } from "@daiso-tech/core/namespace";
     *
     * new Namespace("@circuit-breaker")
     * ```
     */
    namespace?: Namespace;
    /**
     * @default
     * ```ts
     * import { EventBus } from "@daiso-tech/core/event-bus";
     * import { NoOpEventBusAdapter } from "@daiso-tech/core/event-bus/no-op-event-bus-adapter";
     *
     * new EventBus({
     *   adapter: new NoOpEventBusAdapter()
     * })
     * ```
     */
    eventBus?: IEventBus;
    /**
     * You can set the default `ErrorPolicy`
     *
     * @default
     * ```ts
     * (_error: unknown) => true
     * ```
     */
    defaultErrorPolicy?: ErrorPolicy;
    /**
     * You can set the default slow call threshold.
     *
     * @default
     * ```ts
     * import { TimeSpan } from "@daiso-tech/core/time-span";
     *
     * TimeSpan.fromSeconds(10);
     * ```
     */
    defaultSlowCallTime?: ITimeSpan;
    /**
     * You set the default trigger.
     *
     * @default
     * ```ts
     * import { CIRCUIT_BREAKER_TRIGGER} from "@daiso-tech/core/circuit-breaker/contracts";
     *
     * CIRCUIT_BREAKER_TRIGGER.BOTH
     * ```
     */
    defaultTrigger?: CircuitBreakerTrigger;
    /**
     * If true, metric tracking will run asynchronously in the background and won't block the function utilizing the circuit breaker logic.
     * @default true
     */
    enableAsyncTracking?: boolean;
    serde?: OneOrMore<ISerderRegister>;
    /**
     * @default ""
     */
    serdeTransformerName?: string;
};
/**
 *
 * IMPORT_PATH: `"@daiso-tech/core/circuit-breaker"`
 * @group Derivables
 */
export type CircuitBreakerProviderSettings = CircuitBreakerProviderSettingsBase & {
    adapter: ICircuitBreakerAdapter;
};
/**
 *
 * IMPORT_PATH: `"@daiso-tech/core/circuit-breaker"`
 * @group Derivables
 */
export declare const DEFAULT_CIRCUIT_BREAKER_PROVIDER_NAMESPACE: Namespace;
/**
 * `CircuitBreakerProvider` class can be derived from any {@link ICircuitBreakerAdapter | `ICircuitBreakerAdapter`}.
 *
 * Note the {@link ICircuitBreaker | `ICircuitBreaker`} instances created by the `CircuitBreakerProvider` class are serializable and deserializable,
 * allowing them to be seamlessly transferred across different servers, processes, and databases.
 * This can be done directly using {@link ISerderRegister | `ISerderRegister`} or indirectly through components that rely on {@link ISerderRegister | `ISerderRegister`} internally.
 *
 * IMPORT_PATH: `"@daiso-tech/core/circuit-breaker"`
 * @group Derivables
 */
export declare class CircuitBreakerProvider implements ICircuitBreakerProvider {
    private readonly namespace;
    private readonly eventBus;
    private readonly adapter;
    private readonly defaultSlowCallTime;
    private readonly defaultTrigger;
    private readonly defaultErrorPolicy;
    private readonly serde;
    private readonly serdeTransformerName;
    private readonly enableAsyncTracking;
    /**
     * @example
     * ```ts
     * import { KyselyCircuitBreakerStorageAdapter } from "@daiso-tech/core/circuit-breaker/kysely-circuit-breaker-storage-adapter";
     * import { DatabaseCircuitBreakerAdapter } from "@daiso-tech/core/circuit-breaker/database-circuit-breaker-adapter";
     * import { Serde } from "@daiso-tech/core/serde";
     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/super-json-serde-adapter"
     * import Sqlite from "better-sqlite3";
     * import { Kysely, SqliteDialect } from "kysely";
     *
     * const serde = new Serde(new SuperJsonSerdeAdapter());
     * const circuitBreakerStorageAdapter = new KyselyCircuitBreakerStorageAdapter({
     *   kysely: new Kysely({
     *     dialect: new SqliteDialect({
     *       database: new Sqlite("local.db"),
     *     }),
     *   }),
     *   serde
     * });
     * // You need initialize the adapter once before using it.
     * await circuitBreakerStorageAdapter.init();
     *
     * const circuitBreakerAdapter = new DatabaseCircuitBreakerAdapter({
     *   adapter: circuitBreakerStorageAdapter
     * });
     *
     * const circuitBreakerProvider = new CircuitBreakerProvider({
     *   adapter: circuitBreakerAdapter
     * })
     * ```
     */
    constructor(settings: CircuitBreakerProviderSettings);
    private registerToSerde;
    addListener<TEventName extends keyof CircuitBreakerEventMap>(eventName: TEventName, listener: EventListener<CircuitBreakerEventMap[TEventName]>): ITask<void>;
    removeListener<TEventName extends keyof CircuitBreakerEventMap>(eventName: TEventName, listener: EventListener<CircuitBreakerEventMap[TEventName]>): ITask<void>;
    listenOnce<TEventName extends keyof CircuitBreakerEventMap>(eventName: TEventName, listener: EventListener<CircuitBreakerEventMap[TEventName]>): ITask<void>;
    asTask<TEventName extends keyof CircuitBreakerEventMap>(eventName: TEventName): ITask<CircuitBreakerEventMap[TEventName]>;
    subscribeOnce<TEventName extends keyof CircuitBreakerEventMap>(eventName: TEventName, listener: EventListener<CircuitBreakerEventMap[TEventName]>): ITask<Unsubscribe>;
    subscribe<TEventName extends keyof CircuitBreakerEventMap>(eventName: TEventName, listener: EventListener<CircuitBreakerEventMap[TEventName]>): ITask<Unsubscribe>;
    create(key: string, settings?: CircuitBreakerProviderCreateSettings): ICircuitBreaker;
}