import { RootStore, Store, Transceiver } from "atom.io/internal";
import { Json } from "atom.io/foundations/json";
import { UList } from "atom.io/transceivers/u-list";
import * as AtomIO from "atom.io";
import { MutableAtomToken, ReadonlyPureSelectorToken, RegularAtomToken, ViewOf, WritableToken } from "atom.io";
import { AnyMosaicTransceiver, Clock, MosaicAtomAddress, MosaicIntent, MosaicOperation, MosaicOperationProposal, MosaicPresenceEnvelope, MosaicRecovery, MosaicRejectionCode, MosaicSignal, RoomKey, Socket, SocketKey, UserKey } from "atom.io/realtime";
import { Canonical } from "atom.io/foundations/canonical";
//#region src/realtime-client/create-subscriber.d.ts
type SubData = {
  clock: Clock;
  close: () => void;
  coalesceMs: number;
  completion: Promise<void> | null;
  completionResolve: (() => void) | null;
  refcount: number;
  sessionId: string | undefined;
  stopWatchingForReconnect: () => void;
  task: number | null;
};
declare const SUBSCRIPTION_COALESCE_MS = 50;
type SubscriberOptions = {
  /** Injectable for deterministic coalescing tests. Defaults to wall time. */
  readonly clock?: Clock;
  readonly coalesceMs?: number;
};
declare function getSubMap(socket: Socket): Map<string, SubData>;
declare function createSubscriber<K extends string>(socket: Socket, key: K, open: (key: K) => () => void, options?: SubscriberOptions): () => void;
//#endregion
//#region src/realtime-client/mosaic/types.d.ts
type MosaicClientStatus = `live` | `offline` | `recovering` | `rejected` | `syncing`;
/** The small transport surface required by the Store-bound client. */
type MosaicClientTransport = {
  /** Socket.IO exposes this; transports without it are presumed connected. */
  readonly connected?: boolean;
  emit(event: string, ...args: Json.Serializable[]): void;
  off(event: string, listener?: (...args: Json.Serializable[]) => void): void;
  on(event: string, listener: (...args: Json.Serializable[]) => void): void;
};
type MosaicClientIdKind = `group` | `operation` | `session`;
type MosaicClientIdContext = {
  readonly actor: string;
  readonly kind: MosaicClientIdKind;
  readonly now: number;
  readonly sequence: number;
  readonly session: string | null;
};
/** Must return a unique stable ID for every supplied sequence. */
type MosaicClientIdSource = (context: MosaicClientIdContext) => string;
type MosaicClientClock = {
  now(): number;
};
type MosaicClientProblem<T extends AnyMosaicTransceiver = AnyMosaicTransceiver> = {
  readonly code: MosaicRejectionCode;
  readonly discarded: readonly MosaicOperationProposal<MosaicOperation<T>>[];
  readonly kind: `rejection`;
  readonly operationId: string | null;
  readonly reason: string;
  readonly recovery: MosaicRecovery;
} | {
  readonly discarded: readonly MosaicOperationProposal<MosaicOperation<T>>[];
  readonly kind: `protocol`;
  readonly reason: string;
};
type MosaicSubmitOptions = {
  /** Use `createGroupId` to group several intents into one undo gesture. */
  readonly group?: string | null;
};
type MosaicSyncOptions = {
  readonly actor: string;
  readonly clock?: MosaicClientClock | (() => number);
  readonly idSource?: MosaicClientIdSource;
  /** Stable for the lifetime of an outbox; supply it to persist across reloads. */
  readonly session?: string;
  readonly transport?: MosaicClientTransport;
};
type MosaicSyncState<T extends AnyMosaicTransceiver, Presence extends Json.Serializable> = {
  readonly pending: readonly string[];
  readonly presence: readonly MosaicPresenceEnvelope<Presence>[];
  readonly problem: MosaicClientProblem<T> | null;
  readonly revision: number;
  readonly status: MosaicClientStatus;
};
/** Store-owned control plane for an ordinary Mosaic mutable atom. */
interface MosaicController<T extends AnyMosaicTransceiver, Presence extends Json.Serializable> {
  readonly actor: string;
  readonly address: MosaicAtomAddress;
  readonly atom: MutableAtomToken<T>;
  readonly session: string;
  readonly store: RootStore;
  readonly syncState: RegularAtomToken<MosaicSyncState<T, Presence>>;
  change(intent: MosaicIntent<T>, options?: MosaicSubmitOptions): MosaicSignal<T> | null;
  clearProblem(): void;
  connect(transport: MosaicClientTransport): () => void;
  createGroupId(): string;
  dispose(): void;
  publishPresence(presence: Presence | null): void;
  /** Resend unacknowledged envelopes without assigning new operation IDs. */
  retryPending(): void;
  /** Request a fresh checkpoint while retaining the optimistic outbox. */
  synchronize(): void;
}
//#endregion
//#region src/realtime-client/mosaic/sync-mosaic.d.ts
/**
 * Synchronize an ordinary Mosaic mutable atom in one Store. Equivalent callers
 * share the Store-owned replica for this atom address and session.
 */
declare function syncMosaic<T extends AnyMosaicTransceiver, Presence extends Json.Serializable = Json.Serializable>(store: RootStore, token: MutableAtomToken<T>, options: MosaicSyncOptions): MosaicController<T, Presence>;
//#endregion
//#region src/realtime-client/observe-socket-wind-down.d.ts
/**
 * Observe the current cleanup wave for a socket's pending subscriptions.
 *
 * @remarks
 * This is exported for internal framework coordination, especially test
 * teardown, and is not intended as a general-purpose public utility.
 */
declare function observeSocketWindDown(socket: Socket): Promise<string[]>;
//#endregion
//#region src/realtime-client/pull-atom.d.ts
declare function pullAtom<J extends Json.Serializable>(store: Store, socket: Socket, token: AtomIO.RegularAtomToken<J, any, any>): () => void;
//#endregion
//#region src/realtime-client/pull-atom-family-member.d.ts
declare function pullAtomFamilyMember<J extends Json.Serializable, K extends Canonical>(store: Store, socket: Socket, family: AtomIO.AtomFamilyToken<J, K, any>, key: NoInfer<K>): () => void;
//#endregion
//#region src/realtime-client/pull-mutable-atom.d.ts
declare function pullMutableAtom<T extends Transceiver<any, any, any>>(store: Store, socket: Socket, token: AtomIO.MutableAtomToken<T>): () => void;
//#endregion
//#region src/realtime-client/pull-mutable-atom-family-member.d.ts
declare function pullMutableAtomFamilyMember<T extends Transceiver<any, any, any>, K extends Canonical>(store: Store, socket: Socket, family: AtomIO.MutableAtomFamilyToken<T, K>, key: NoInfer<K>): () => void;
//#endregion
//#region src/realtime-client/pull-selector.d.ts
declare function pullSelector<T>(store: Store, socket: Socket, token: AtomIO.SelectorToken<T>): () => void;
//#endregion
//#region src/realtime-client/pull-selector-family-member.d.ts
declare function pullSelectorFamilyMember<T, K extends Canonical>(store: Store, socket: Socket, familyToken: AtomIO.SelectorFamilyToken<T, K>, key: NoInfer<K>): () => void;
//#endregion
//#region src/realtime-client/push-state.d.ts
declare function pushState<J extends Json.Serializable>(store: Store, socket: Socket, token: WritableToken<J>): () => void;
//#endregion
//#region src/realtime-client/realtime-client-stores/client-main-store.d.ts
declare const mySocketKeyAtom: RegularAtomToken<SocketKey | undefined>;
declare const myUserKeyAtom: RegularAtomToken<UserKey | null>;
declare const myRoomKeySelector: ReadonlyPureSelectorToken<RoomKey | null>;
declare const usersHereSelector: ReadonlyPureSelectorToken<ViewOf<UList<UserKey> | null>>;
declare const roomOwnerSelector: ReadonlyPureSelectorToken<UserKey | null>;
//#endregion
export { type MosaicClientClock, type MosaicClientIdContext, type MosaicClientIdKind, type MosaicClientIdSource, type MosaicClientProblem, type MosaicClientStatus, type MosaicClientTransport, type MosaicController, type MosaicSubmitOptions, type MosaicSyncOptions, type MosaicSyncState, SUBSCRIPTION_COALESCE_MS, SubscriberOptions, createSubscriber, getSubMap, myRoomKeySelector, mySocketKeyAtom, myUserKeyAtom, observeSocketWindDown, pullAtom, pullAtomFamilyMember, pullMutableAtom, pullMutableAtomFamilyMember, pullSelector, pullSelectorFamilyMember, pushState, roomOwnerSelector, syncMosaic, usersHereSelector };
//# sourceMappingURL=index.d.ts.map