import type { BridgeInterface, BridgeMultiSelectorInterface, BridgeSelectorInterface, GateInterface, GateTransferInterface, LinkStrategyInterface, SubscriberInterface } from "./interfaces";
import type { BaseSelectorKey, DataHandler, SelectorKey, InputTransfer, OutputTransfer, DuplexTransfer } from "./types";
import type { BridgeAggregatorConfig, BridgeMultiSelectorConfig, BridgeSelectorConfig, PassBridgeConfig, TransformBridgeConfig, TransferBridgeConfig, AsyncTransformBridgeConfig } from "./configs";
import { ConvertTransfer, AsyncConvertTransfer } from "./transfers";
import { StateSubscriptionManager } from "./helpers";
/**
 * Simple gated bridge — passes data from source to target through an internal GateTransfer.
 *
 * @category Bridges
 */
export declare class PassBridge<T> implements BridgeInterface {
    protected readonly _source: OutputTransfer<T>;
    protected readonly _target: InputTransfer<T>;
    protected readonly _gate: GateTransferInterface<T>;
    protected readonly _gateState: StateSubscriptionManager<GateInterface>;
    protected readonly _linkStrategy: LinkStrategyInterface;
    protected _subscribers: SubscriberInterface[];
    constructor(config: PassBridgeConfig<T>);
    get active(): boolean;
    activate(): void;
    deactivate(): void;
    toggle(): boolean;
    onStateChange(handler: DataHandler<GateInterface>): SubscriberInterface;
    destroy(): void;
}
/**
 * Gated bridge with synchronous data transformation — source → gate → converter → target.
 *
 * @category Bridges
 */
export declare class TransformBridge<TInput, TOutput> implements BridgeInterface {
    protected readonly _source: OutputTransfer<TInput>;
    protected readonly _target: InputTransfer<TOutput>;
    protected readonly _converter: ConvertTransfer<TInput, TOutput>;
    protected readonly _gate: GateTransferInterface<TInput>;
    protected readonly _gateState: StateSubscriptionManager<GateInterface>;
    protected readonly _linkStrategy: LinkStrategyInterface;
    protected _subscribers: SubscriberInterface[];
    constructor(config: TransformBridgeConfig<TInput, TOutput>);
    get active(): boolean;
    activate(): void;
    deactivate(): void;
    toggle(): boolean;
    onStateChange(handler: DataHandler<GateInterface>): SubscriberInterface;
    destroy(): void;
}
/**
 * Gated bridge with an intermediate duplex transfer — source → gate → middle → target.
 *
 * @category Bridges
 */
export declare class TransferBridge<TInput, TOutput> implements BridgeInterface {
    protected readonly _source: OutputTransfer<TInput>;
    protected readonly _target: InputTransfer<TOutput>;
    protected readonly _middle: DuplexTransfer<TInput, TOutput>;
    protected readonly _gate: GateTransferInterface<TInput>;
    protected readonly _gateState: StateSubscriptionManager<GateInterface>;
    protected readonly _middleOwned: boolean;
    protected readonly _linkStrategy: LinkStrategyInterface;
    protected _subscribers: SubscriberInterface[];
    constructor(config: TransferBridgeConfig<TInput, TOutput>);
    get active(): boolean;
    activate(): void;
    deactivate(): void;
    toggle(): boolean;
    onStateChange(handler: DataHandler<GateInterface>): SubscriberInterface;
    destroy(): void;
}
/**
 * Bridge with asynchronous data type transformation via AsyncOperator.
 *
 * Flow structure: source → gate → asyncConverter → target
 *
 * Gate and subscription remain synchronous. AsyncConvertTransfer receives
 * data via asyncPush (the gate→converter link uses the async strategy of
 * linkTransfers), transforms via await operator.apply() and notifies
 * subscribers synchronously.
 *
 * Configuration (AsyncTransformBridgeConfig):
 * - source: OutputTransfer<TInput>
 * - target: InputTransfer<TOutput>
 * - operator: AsyncOperatorInterface<TInput, TOutput | undefined>
 * - activated: boolean
 * - onError?: ErrorHandler — operator error handler
 *
 * @category Async Bridges
 */
export declare class AsyncTransformBridge<TInput, TOutput> implements BridgeInterface {
    protected readonly _source: OutputTransfer<TInput>;
    protected readonly _target: InputTransfer<TOutput>;
    protected readonly _converter: AsyncConvertTransfer<TInput, TOutput>;
    protected readonly _gate: GateTransferInterface<TInput>;
    protected readonly _gateState: StateSubscriptionManager<GateInterface>;
    protected readonly _linkStrategy: LinkStrategyInterface;
    protected _subscribers: SubscriberInterface[];
    constructor(config: AsyncTransformBridgeConfig<TInput, TOutput>);
    get active(): boolean;
    activate(): void;
    deactivate(): void;
    toggle(): boolean;
    onStateChange(handler: DataHandler<GateInterface>): SubscriberInterface;
    destroy(): void;
}
/**
 * Aggregator bridge — controls multiple bridges as a group. Active only when ALL nested bridges are active.
 *
 * @category Bridges
 */
export declare class BridgeAggregator implements BridgeInterface {
    protected _bridges: BridgeInterface[];
    protected readonly _owned: boolean;
    protected readonly _gateState: StateSubscriptionManager<GateInterface>;
    constructor(config: BridgeAggregatorConfig);
    get active(): boolean;
    activate(): void;
    deactivate(): void;
    toggle(): boolean;
    onStateChange(handler: DataHandler<GateInterface>): SubscriberInterface;
    destroy(): void;
}
/**
 * Single-choice selector bridge — activates exactly one bridge from a map at a time.
 *
 * @category Bridges
 */
export declare class BridgeSelector<TMap extends Record<BaseSelectorKey, BridgeInterface>> implements BridgeSelectorInterface<TMap> {
    protected _bridges: TMap;
    protected _selectedKey: SelectorKey<TMap>;
    protected _active: boolean;
    protected readonly _owned: boolean;
    protected readonly _gateState: StateSubscriptionManager<GateInterface>;
    protected _subscribers: SubscriberInterface[];
    protected _syncing: boolean;
    constructor(config: BridgeSelectorConfig<TMap>);
    get active(): boolean;
    activate(): void;
    deactivate(): void;
    toggle(): boolean;
    onStateChange(handler: DataHandler<GateInterface>): SubscriberInterface;
    destroy(): void;
    select(key: SelectorKey<TMap>): void;
    get selectedKey(): SelectorKey<TMap>;
    get selectedBridge(): BridgeInterface;
    protected _tryActivateBridge(key: SelectorKey<TMap>): void;
    protected _deactivateBridges(): void;
}
/**
 * Multi-choice selector bridge — activates any subset of bridges from a map simultaneously.
 *
 * @category Bridges
 */
export declare class BridgeMultiSelector<TMap extends Record<BaseSelectorKey, BridgeInterface>> implements BridgeMultiSelectorInterface<TMap> {
    protected _bridges: TMap;
    protected _selectedKeys: Set<SelectorKey<TMap>>;
    protected _active: boolean;
    protected readonly _owned: boolean;
    protected readonly _gateState: StateSubscriptionManager<GateInterface>;
    protected _subscribers: SubscriberInterface[];
    protected _syncing: boolean;
    constructor(config: BridgeMultiSelectorConfig<TMap>);
    get active(): boolean;
    activate(): void;
    deactivate(): void;
    toggle(): boolean;
    onStateChange(handler: DataHandler<GateInterface>): SubscriberInterface;
    destroy(): void;
    select(keys: SelectorKey<TMap>[]): void;
    get selectedKeys(): SelectorKey<TMap>[];
    get selectedBridges(): BridgeInterface[];
    check(key: SelectorKey<TMap>): void;
    uncheck(key: SelectorKey<TMap>): void;
    protected _tryActivateBridges(keys: SelectorKey<TMap>[] | Set<SelectorKey<TMap>>): void;
    protected _tryActivateBridge(key: SelectorKey<TMap>): void;
    protected _deactivateBridges(): void;
    protected _deactivateBridge(key: SelectorKey<TMap>): void;
    protected _selectKeys(keys: SelectorKey<TMap>[]): void;
    protected _selectKey(key: SelectorKey<TMap>): void;
    protected _unselectKey(key: SelectorKey<TMap>): void;
}
//# sourceMappingURL=bridges.d.ts.map