import { BaseObserver, PowerSyncLogger, SyncStatus, BaseListener, PowerSyncBackendConnector, SyncStream, SyncOptions, SyncStreamConnectionMethod } from '@powersync/common';
import { StreamingSyncImplementation, SubscribedStream } from './sync/stream/AbstractStreamingSyncImplementation.js';
import { ResolvedSyncOptions } from './sync/options.js';
/**
 * @internal
 */
export interface ConnectionManagerSyncImplementationResult {
    sync: StreamingSyncImplementation;
    /**
     * Additional cleanup function which is called after the sync stream implementation
     * is disposed.
     */
    onDispose: () => Promise<void> | void;
}
/**
 * The subset of {@link AbstractStreamingSyncImplementationOptions} managed by the connection manager.
 *
 * @internal
 */
export interface CreateSyncImplementationOptions {
    subscriptions: SubscribedStream[];
    serializedSchema: any;
}
/**
 * @internal
 */
export interface InternalSubscriptionAdapter {
    firstStatusMatching(predicate: (status: SyncStatus) => any, abort?: AbortSignal): Promise<void>;
    resolveOfflineSyncStatus(): Promise<void>;
    rustSubscriptionsCommand(payload: any): Promise<void>;
}
/**
 * @internal
 */
export interface ConnectionManagerOptions {
    createSyncImplementation(connector: PowerSyncBackendConnector, options: CreateSyncImplementationOptions): Promise<ConnectionManagerSyncImplementationResult>;
    readonly defaultConnectionMethod: SyncStreamConnectionMethod;
    logger: PowerSyncLogger;
}
type StoredConnectionOptions = {
    connector: PowerSyncBackendConnector;
    options: ResolvedSyncOptions;
    schema: any;
};
/**
 * @internal
 */
export interface ConnectionManagerListener extends BaseListener {
    syncStreamCreated: (sync: StreamingSyncImplementation) => void;
}
/**
 * @internal
 */
export declare class ConnectionManager extends BaseObserver<ConnectionManagerListener> {
    protected options: ConnectionManagerOptions;
    /**
     * Tracks active connection attempts
     */
    protected connectingPromise: Promise<void> | null;
    /**
     * Tracks actively instantiating a streaming sync implementation.
     */
    protected syncStreamInitPromise: Promise<void> | null;
    /**
     * Active disconnect operation. Calling disconnect multiple times
     * will resolve to the same operation.
     */
    protected disconnectingPromise: Promise<void> | null;
    /**
     * Tracks the last parameters supplied to `connect` calls.
     * Calling `connect` multiple times in succession will result in:
     * - 1 pending connection operation which will be aborted.
     * - updating the last set of parameters while waiting for the pending
     *   attempt to be aborted
     * - internally connecting with the last set of parameters
     */
    protected pendingConnectionOptions: StoredConnectionOptions | null;
    private currentOptions;
    syncStreamImplementation: StreamingSyncImplementation | null;
    /**
     * Additional cleanup function which is called after the sync stream implementation
     * is disposed.
     */
    protected syncDisposer: (() => Promise<void> | void) | null;
    /**
     * Subscriptions managed in this connection manager.
     *
     * On the web, these local subscriptions are merged across tabs by a shared worker.
     */
    private locallyActiveSubscriptions;
    constructor(options: ConnectionManagerOptions);
    get connector(): PowerSyncBackendConnector | null;
    get connectionOptions(): Required<SyncOptions> | null;
    get logger(): PowerSyncLogger;
    close(): Promise<void>;
    connect(connector: PowerSyncBackendConnector, options: SyncOptions, serializedSchema: any): Promise<void>;
    protected connectInternal(): Promise<void>;
    /**
     * Close the sync connection.
     *
     * Use {@link ConnectionManager.connect} to connect again.
     */
    disconnect(): Promise<void>;
    protected disconnectInternal(): Promise<void>;
    protected performDisconnect(): Promise<void>;
    stream(adapter: InternalSubscriptionAdapter, name: string, parameters: Record<string, any> | null): SyncStream;
    /**
     * @internal exposed for testing
     */
    get activeStreams(): {
        name: string;
        params: Record<string, any> | null;
    }[];
    private subscriptionsMayHaveChanged;
}
export {};