@delali/sirannon-db 0.2.0 → 0.2.1

package/dist/database-BY0L5Q2n.d.ts

@@ -1,172 +0,0 @@
-import { i as QueryHookContext, j as ConnectionHookContext, k as BeforeSubscribeHook, H as HookConfig, l as MetricsConfig, m as QueryMetrics, n as ConnectionMetrics, o as CDCMetrics, h as ChangeEvent, a as SQLiteDriver, D as DatabaseOptions, P as Params, Q as QueryOptions, E as ExecuteResult, T as Transaction, e as SQLiteConnection, p as SubscriptionBuilder, M as Migration, q as MigrationResult, r as RollbackResult, f as BackupScheduleOptions, B as BeforeQueryHook, A as AfterQueryHook } from './types-zhnRXrsb.js';
-import { c as ReplicationChange, C as ConflictResolver, A as ApplyResult, R as ReplicationBatch } from './types-C_D8IhpO.js';
-import { A as AppliedMigrationRow, b as BulkLoadOptions, a as BulkLoadResult } from './server-options-1JHu8pid.js';
-import { L as LiveQueryOptions, a as LiveQuery } from './types-CL6piSnD.js';
-
-type HookEvent = 'beforeQuery' | 'afterQuery' | 'beforeConnect' | 'databaseOpen' | 'databaseClose' | 'beforeSubscribe';
-type SubscribeHookContext = Parameters<BeforeSubscribeHook>[0];
-interface HookEventContextMap {
-    beforeQuery: QueryHookContext;
-    afterQuery: QueryHookContext & {
-        durationMs: number;
-    };
-    beforeConnect: ConnectionHookContext;
-    databaseOpen: ConnectionHookContext;
-    databaseClose: ConnectionHookContext;
-    beforeSubscribe: SubscribeHookContext;
-}
-type HookHandler<E extends HookEvent> = (ctx: HookEventContextMap[E]) => void | Promise<void>;
-type HookDispose = () => void;
-
-declare class HookRegistry {
-    private hooks;
-    constructor(config?: HookConfig);
-    register<E extends HookEvent>(event: E, hook: HookHandler<E>): HookDispose;
-    invoke<E extends HookEvent>(event: E, ctx: HookEventContextMap[E]): Promise<void>;
-    invokeSync<E extends HookEvent>(event: E, ctx: HookEventContextMap[E]): void;
-    has(event: HookEvent): boolean;
-    count(event: HookEvent): number;
-    clear(event?: HookEvent): void;
-    private addHook;
-    private loadConfig;
-}
-
-declare class MetricsCollector {
-    private config;
-    constructor(config?: MetricsConfig);
-    trackQuery<T>(fn: () => Promise<T>, context: Omit<QueryMetrics, 'durationMs' | 'error'>): Promise<T>;
-    trackConnection(metrics: ConnectionMetrics): void;
-    trackCDCEvent(metrics: CDCMetrics): void;
-    get active(): boolean;
-}
-
-interface StagedRecovery {
-    resumeSeq: bigint | null;
-    appliedSeq: bigint | null;
-    /**
-     * The failure that stopped the recovery apply, or null. The staged rows
-     * are untouched by the failure and the resume watermark still covers
-     * them, so the caller opens the subscription anyway: a schema-gate refusal
-     * there is what tells a device it must migrate before this apply can
-     * succeed. The caller must then retry the recovery, because the resume
-     * watermark is past the transaction this apply left unapplied, so the
-     * server sends nothing that would prompt another attempt.
-     */
-    applyError: unknown | null;
-}
-
-interface DeviceSyncPullState {
-    seq: bigint;
-    epoch: string | undefined;
-}
-interface DeviceSyncPort {
-    identity(): Promise<{
-        nodeId: string;
-    }>;
-    applyPulledTransaction(changes: readonly ReplicationChange[], pullSeq: bigint, resolver?: ConflictResolver | ((table: string) => ConflictResolver)): Promise<ApplyResult>;
-    stagePulledChanges(events: readonly ChangeEvent[]): Promise<bigint | null>;
-    applyStagedPull(resolver?: ConflictResolver | ((table: string) => ConflictResolver), onChange?: (event: ChangeEvent) => void): Promise<bigint | null>;
-    recoverStagedPull(resolver?: ConflictResolver | ((table: string) => ConflictResolver), onChange?: (event: ChangeEvent) => void): Promise<StagedRecovery>;
-    readOutboxBatch(afterSeq: bigint, limit: number): Promise<ReplicationBatch | null>;
-    countOutboxPending(afterSeq: bigint): Promise<number>;
-    getPushCursor(): Promise<bigint>;
-    setPushCursor(seq: bigint): Promise<void>;
-    getPullState(): Promise<DeviceSyncPullState | null>;
-    getResyncRequired(): Promise<boolean>;
-    setResyncRequired(required: boolean): Promise<void>;
-    setPullState(seq: bigint, epoch?: string): Promise<void>;
-    protectUnpushedChanges(pushedSeq: bigint): void;
-    snapshotLoadPending(): Promise<boolean>;
-    beginSnapshotLoad(tables: readonly string[]): Promise<void>;
-    applySnapshotSchema(schema: readonly string[]): Promise<void>;
-    loadSnapshotPage(table: string, rows: readonly Record<string, unknown>[]): Promise<void>;
-    replaceMigrationHistory(rows: readonly AppliedMigrationRow[]): Promise<void>;
-    endSnapshotLoad(tables: readonly string[]): Promise<void>;
-    abortSnapshotLoad(): Promise<void>;
-}
-
-interface DatabaseInternals {
-    parentHooks?: HookRegistry;
-    metrics?: MetricsCollector;
-}
-
-declare class Database {
-    readonly id: string;
-    readonly path: string;
-    readonly readOnly: boolean;
-    private readonly pool;
-    private readonly driver;
-    private readonly synchronous;
-    private readonly walMode;
-    private readonly writerLock;
-    private readonly writeGate;
-    private readonly groupCommitter;
-    private readonly closeListeners;
-    private _closed;
-    private readonly cdc;
-    private readonly sync;
-    private readonly hookRegistry;
-    private readonly observer;
-    private readonly backups;
-    private readonly reads;
-    private constructor();
-    static create(id: string, path: string, driver: SQLiteDriver, options?: DatabaseOptions, internals?: DatabaseInternals): Promise<Database>;
-    applyChanges(batch: ReplicationBatch, resolver?: ConflictResolver | ((table: string) => ConflictResolver)): Promise<ApplyResult>;
-    deviceSync(): DeviceSyncPort;
-    query<T = Record<string, unknown>>(sql: string, params?: Params, options?: QueryOptions): Promise<T[]>;
-    queryForWire(sql: string, params?: Params, options?: QueryOptions): Promise<unknown[]>;
-    queryOne<T = Record<string, unknown>>(sql: string, params?: Params, options?: QueryOptions): Promise<T | undefined>;
-    execute(sql: string, params?: Params, options?: QueryOptions): Promise<ExecuteResult>;
-    executeBatch(sql: string, paramsBatch: Params[], options?: QueryOptions): Promise<ExecuteResult[]>;
-    private runInTransaction;
-    /**
-     * Load rows with relaxed writer durability. The load holds the writer lock
-     * for its whole duration, so no other write commits under the relaxed level
-     * and no two loads race on the shared `synchronous` setting; the configured
-     * level is restored before this resolves, whether the load succeeds or
-     * fails. The load runs in one transaction, so one commit and one durability
-     * barrier cover the whole batch. Rows are summed rather than returned
-     * per-row to bound memory on large loads. Like `execute` and `transaction`,
-     * this writes only to the local database; under replication the server routes
-     * loads through the engine, not through this method.
-     */
-    bulkLoad(sql: string, paramsBatch: Params[], options?: BulkLoadOptions): Promise<BulkLoadResult>;
-    /**
-     * Takes the statements up front rather than a callback, since a group cannot wait on an
-     * arbitrary caller-supplied callback without delaying every transaction beside it.
-     */
-    executeTransaction(statements: readonly {
-        sql: string;
-        params?: Params;
-    }[]): Promise<ExecuteResult[]>;
-    private runStatementsAlone;
-    transaction<T>(fn: (tx: Transaction) => Promise<T>): Promise<T>;
-    watch(table: string): Promise<void>;
-    /**
-     * Runs a CDC maintenance write (change-log pruning) on the shared writer
-     * under the writer lock. Serialising it with application writes keeps it
-     * from becoming a second writer that contends for SQLite's single write
-     * lock and stalls the event loop on `busy_timeout`.
-     */
-    runCdcMaintenance(op: (writer: SQLiteConnection) => Promise<unknown>): Promise<void>;
-    ensureChangeStamping(): Promise<void>;
-    unwatch(table: string): Promise<void>;
-    on(table: string): SubscriptionBuilder;
-    live<T = Record<string, unknown>>(sql: string, params?: Params, options?: LiveQueryOptions): Promise<LiveQuery<T>>;
-    migrate(migrations: Migration[]): Promise<MigrationResult>;
-    appliedMigrations(): Promise<AppliedMigrationRow[]>;
-    rollback(migrations: Migration[], version?: number): Promise<RollbackResult>;
-    backup(destPath: string): Promise<void>;
-    scheduleBackup(options: BackupScheduleOptions): void;
-    loadExtension(extensionPath: string): Promise<void>;
-    onBeforeQuery(hook: BeforeQueryHook): void;
-    onAfterQuery(hook: AfterQueryHook): void;
-    addCloseListener(fn: () => void | Promise<void>): void;
-    close(): Promise<void>;
-    get closed(): boolean;
-    get readerCount(): number;
-    private ensureOpen;
-    private ensureNotClosed;
-}
-
-export { Database as D, type HookDispose as H, MetricsCollector as M, type SubscribeHookContext as S, type HookEvent as a, type HookEventContextMap as b, type HookHandler as c, HookRegistry as d, type DeviceSyncPort as e };

package/dist/protocol-6KrSq2Hy.d.ts

@@ -1,66 +0,0 @@
-import { W as WriteConcern, R as ReadConcern, E as ExecuteResult } from './types-zhnRXrsb.js';
-import { B as BulkLoadDurability, a as BulkLoadResult } from './server-options-1JHu8pid.js';
-
-interface QueryRequest {
-    sql: string;
-    params?: Record<string, unknown> | unknown[];
-    readConcern?: ReadConcern;
-}
-interface ExecuteRequest {
-    sql: string;
-    params?: Record<string, unknown> | unknown[];
-    writeConcern?: WriteConcern;
-}
-interface TransactionStatement {
-    sql: string;
-    params?: Record<string, unknown> | unknown[];
-}
-interface TransactionRequest {
-    statements: TransactionStatement[];
-    writeConcern?: WriteConcern;
-}
-/** The whole batch commits atomically in one server-side transaction with one fsync. */
-interface BatchRequest {
-    sql: string;
-    paramsBatch: (Record<string, unknown> | unknown[])[];
-    writeConcern?: WriteConcern;
-}
-interface QueryResponse {
-    rows: Record<string, unknown>[];
-}
-interface ExecuteResponse {
-    changes: number;
-    lastInsertRowId: number | string;
-}
-interface TransactionResponse {
-    results: ExecuteResponse[];
-}
-interface BatchResponse {
-    results: ExecuteResponse[];
-}
-/**
- * Loads rows with relaxed writer durability; the configured durability is
- * restored before the response is sent, and a load interrupted by a crash is
- * recovered by re-running it.
- */
-interface LoadRequest {
-    sql: string;
-    paramsBatch: (Record<string, unknown> | unknown[])[];
-    durability?: BulkLoadDurability;
-    checkpoint?: boolean;
-}
-type LoadResponse = BulkLoadResult;
-interface AckResponse {
-    acked: boolean;
-    seq: string;
-}
-interface ErrorResponse {
-    error: {
-        code: string;
-        message: string;
-        details?: Record<string, unknown>;
-    };
-}
-declare function toExecuteResponse(result: ExecuteResult): ExecuteResponse;
-
-export { type AckResponse as A, type BatchResponse as B, type ExecuteResponse as E, type LoadResponse as L, type QueryResponse as Q, type TransactionStatement as T, type TransactionResponse as a, type BatchRequest as b, type ErrorResponse as c, type ExecuteRequest as d, type LoadRequest as e, type QueryRequest as f, type TransactionRequest as g, toExecuteResponse as t };

package/dist/sirannon-DaQSyhbJ.d.ts

@@ -1,36 +0,0 @@
-import { D as Database } from './database-BY0L5Q2n.js';
-import { S as SirannonOptions, a as SQLiteDriver, D as DatabaseOptions, M as Migration, B as BeforeQueryHook, A as AfterQueryHook, b as BeforeConnectHook, c as DatabaseOpenHook, d as DatabaseCloseHook } from './types-zhnRXrsb.js';
-
-declare class Sirannon {
-    readonly options: SirannonOptions;
-    private readonly dbs;
-    private readonly opening;
-    private readonly resolving;
-    private migrationSet;
-    private _shutdown;
-    private readonly _driver;
-    private readonly hookRegistry;
-    private readonly metricsCollector;
-    private readonly lifecycleManager;
-    constructor(options: SirannonOptions);
-    get driver(): SQLiteDriver;
-    open(id: string, path: string, options?: DatabaseOptions): Promise<Database>;
-    private withRegistryDefaults;
-    close(id: string): Promise<void>;
-    get(id: string): Database | undefined;
-    resolve(id: string): Promise<Database | undefined>;
-    registryMigrations(): Promise<Migration[]>;
-    private applyRegistryMigrations;
-    private loadMigrationSet;
-    has(id: string): boolean;
-    databases(): Map<string, Database>;
-    shutdown(): Promise<void>;
-    onBeforeQuery(hook: BeforeQueryHook): void;
-    onAfterQuery(hook: AfterQueryHook): void;
-    onBeforeConnect(hook: BeforeConnectHook): void;
-    onDatabaseOpen(hook: DatabaseOpenHook): void;
-    onDatabaseClose(hook: DatabaseCloseHook): void;
-    private ensureRunning;
-}
-
-export { Sirannon as S };

package/dist/types-B7gmEsZW.d.ts

@@ -1,221 +0,0 @@
-import { C as ChangeTracker } from './change-tracker-DKRVUC3l.js';
-import { e as SQLiteConnection, N as NodeHealth } from './types-zhnRXrsb.js';
-import { R as ReplicationBatch, S as SyncTableManifest, C as ConflictResolver } from './types-C_D8IhpO.js';
-import { C as ClusterCoordinator, a as CoordinatorCompatibilityMetadata, R as ReplicationGroupState } from './types-BsVabqSI.js';
-
-interface NodeInfo {
-    id: string;
-    groupId?: string;
-    role: 'primary' | 'replica';
-    primaryTerm?: bigint;
-    protocolVersion?: string;
-    joinedAt: number;
-    lastSeenAt: number;
-    lastAckedSeq: bigint;
-    metadata?: Record<string, unknown>;
-}
-interface ReplicationAck {
-    batchId: string;
-    ackedSeq: bigint;
-    nodeId: string;
-    groupId?: string;
-    primaryTerm?: bigint;
-}
-interface ForwardedTransaction {
-    statements: Array<{
-        sql: string;
-        params?: Record<string, unknown> | unknown[];
-    }>;
-    requestId: string;
-    groupId?: string;
-    primaryTerm?: bigint;
-}
-interface ForwardedTransactionResult {
-    results: Array<{
-        changes: number;
-        lastInsertRowId: number | string;
-    }>;
-    requestId: string;
-    groupId?: string;
-    primaryTerm?: bigint;
-}
-type TopologyRole = 'primary' | 'replica';
-interface Topology {
-    role: TopologyRole;
-    canWrite(): boolean;
-    shouldReplicateTo(peerId: string, peerRole: TopologyRole): boolean;
-    shouldAcceptFrom(peerId: string, peerRole: TopologyRole): boolean;
-    requiresConflictResolution(): boolean;
-}
-interface TransportConfig {
-    endpoints?: string[];
-    localRole?: TopologyRole;
-    groupId?: string;
-    primaryTerm?: bigint;
-    protocolVersion?: string;
-    metadata?: Record<string, unknown>;
-}
-interface ReplicationTransport {
-    connect(localNodeId: string, config: TransportConfig): Promise<void>;
-    disconnect(): Promise<void>;
-    send(peerId: string, batch: ReplicationBatch): Promise<void>;
-    broadcast(batch: ReplicationBatch): Promise<void>;
-    sendAck(peerId: string, ack: ReplicationAck): Promise<void>;
-    forward(peerId: string, request: ForwardedTransaction): Promise<ForwardedTransactionResult>;
-    requestSync(peerId: string, request: SyncRequest): Promise<void>;
-    sendSyncBatch(peerId: string, batch: SyncBatch): Promise<void>;
-    sendSyncComplete(peerId: string, complete: SyncComplete): Promise<void>;
-    sendSyncAck(peerId: string, ack: SyncAck): Promise<void>;
-    onBatchReceived(handler: (batch: ReplicationBatch, fromPeerId: string) => Promise<void>): void;
-    onAckReceived(handler: (ack: ReplicationAck, fromPeerId: string) => void): void;
-    onForwardReceived(handler: (request: ForwardedTransaction, fromPeerId: string) => Promise<ForwardedTransactionResult>): void;
-    onSyncRequested(handler: (request: SyncRequest, fromPeerId: string) => Promise<void>): void;
-    onSyncBatchReceived(handler: (batch: SyncBatch, fromPeerId: string) => Promise<void>): void;
-    onSyncCompleteReceived(handler: (complete: SyncComplete, fromPeerId: string) => Promise<void>): void;
-    onSyncAckReceived(handler: (ack: SyncAck, fromPeerId: string) => void): void;
-    onPeerConnected(handler: (peer: NodeInfo) => void): void;
-    onPeerDisconnected(handler: (peerId: string) => void): void;
-    peers(): ReadonlyMap<string, NodeInfo>;
-}
-interface InFlightBatch {
-    batchId: string;
-    fromSeq: bigint;
-    toSeq: bigint;
-    sentAt: number;
-}
-interface PeerState {
-    nodeId: string;
-    lastAckedSeq: bigint;
-    lastSentSeq: bigint;
-    lastReceivedHlc: string;
-    connected: boolean;
-    pendingBatches: number;
-    inFlightBatches: InFlightBatch[];
-}
-interface CoordinatorControllerConfig {
-    enabled?: boolean;
-    holderId?: string;
-    leaseTtlMs?: number;
-    tickIntervalMs?: number;
-}
-interface CoordinatorModeConfig {
-    clusterId: string;
-    groupId: string;
-    endpoint?: string;
-    votingDataBearingNodeIds?: string[];
-    coordinator: ClusterCoordinator;
-    sessionTtlMs?: number;
-    controller?: boolean | CoordinatorControllerConfig;
-    compatibility?: CoordinatorCompatibilityMetadata;
-}
-interface ReplicationConfig {
-    nodeId?: string;
-    topology: Topology;
-    transport: ReplicationTransport;
-    transportConfig?: TransportConfig;
-    writeForwarding?: boolean;
-    conflictResolvers?: Record<string, ConflictResolver>;
-    defaultConflictResolver?: ConflictResolver;
-    batchSize?: number;
-    batchIntervalMs?: number;
-    maxPendingBatches?: number;
-    snapshotThreshold?: number;
-    maxClockDriftMs?: number;
-    maxBatchChanges?: number;
-    ackTimeoutMs?: number;
-    onBeforeForwardedQuery?: (sql: string, params?: unknown[] | Record<string, unknown>) => void;
-    flowControl?: {
-        maxLagSeconds?: number;
-        onLagExceeded?: (peerId: string, lagMs: number) => void;
-    };
-    initialSync?: boolean;
-    syncBatchSize?: number;
-    maxConcurrentSyncs?: number;
-    maxSyncDurationMs?: number;
-    maxSyncLagBeforeReady?: number;
-    syncAckTimeoutMs?: number;
-    catchUpDeadlineMs?: number;
-    resumeFromSeq?: bigint;
-    snapshotConnectionFactory?: () => Promise<SQLiteConnection>;
-    changeTracker?: ChangeTracker;
-    coordinator?: CoordinatorModeConfig;
-}
-interface ReplicationStatus {
-    nodeId: string;
-    role: TopologyRole;
-    peers: PeerState[];
-    localSeq: bigint;
-    replicating: boolean;
-    health: NodeHealth;
-    syncState?: SyncState;
-    coordinator?: CoordinatorRuntimeStatus;
-}
-interface CoordinatorRuntimeStatus {
-    clusterId: string;
-    groupId: string;
-    currentPrimary: ReplicationGroupState['currentPrimary'];
-    primaryTerm: bigint;
-    inSyncNodeIds: string[];
-    drainingNodeIds: string[];
-    repairingNodeIds: string[];
-    faultedNodeIds: string[];
-    votingDataBearingNodeIds: string[];
-    authority: boolean;
-    connected: boolean;
-    controllerState: 'disabled' | 'standby' | 'active' | 'lost';
-}
-type SyncPhase = 'pending' | 'syncing' | 'catching-up' | 'ready';
-interface SyncState {
-    phase: SyncPhase;
-    sourcePeerId: string | null;
-    snapshotSeq: bigint | null;
-    completedTables: string[];
-    totalTables: number;
-    startedAt: number | null;
-    error: string | null;
-}
-interface SyncRequest {
-    requestId: string;
-    joinerNodeId: string;
-    completedTables: string[];
-    supportsStreamVerification?: boolean;
-    groupId?: string;
-    primaryTerm?: bigint;
-}
-interface SyncBatch {
-    requestId: string;
-    table: string;
-    batchIndex: number;
-    rows: Record<string, unknown>[];
-    schema?: string[];
-    checksum: string;
-    isLastBatchForTable: boolean;
-    totalTables?: number;
-    groupId?: string;
-    primaryTerm?: bigint;
-}
-interface SyncComplete {
-    requestId: string;
-    snapshotSeq: bigint;
-    manifests: SyncTableManifest[];
-    groupId?: string;
-    primaryTerm?: bigint;
-}
-interface SyncAck {
-    requestId: string;
-    joinerNodeId: string;
-    table: string;
-    batchIndex: number;
-    success: boolean;
-    error?: string;
-    groupId?: string;
-    primaryTerm?: bigint;
-}
-interface ReplicationErrorEvent {
-    error: Error;
-    operation: string;
-    peerId?: string;
-    recoverable: boolean;
-}
-
-export type { ForwardedTransaction as F, InFlightBatch as I, NodeInfo as N, PeerState as P, ReplicationAck as R, SyncRequest as S, TransportConfig as T, ForwardedTransactionResult as a, SyncBatch as b, SyncComplete as c, SyncAck as d, ReplicationTransport as e, TopologyRole as f, SyncPhase as g, ReplicationConfig as h, SyncState as i, ReplicationStatus as j, ReplicationErrorEvent as k, Topology as l };

package/dist/types-BsVabqSI.d.ts

@@ -1,139 +0,0 @@
-type CoordinatorLeaseKind = 'controller' | 'node-session';
-type CoordinatorWatchDisposer = () => void | Promise<void>;
-interface CoordinatorLease {
-    id: string;
-    kind: CoordinatorLeaseKind;
-    clusterId: string;
-    holderId: string;
-    ttlMs: number;
-    grantedAtMs: number;
-    expiresAtMs: number;
-    metadata?: Record<string, unknown>;
-}
-interface AcquireControllerLeaseInput {
-    clusterId: string;
-    holderId: string;
-    ttlMs: number;
-    metadata?: Record<string, unknown>;
-}
-type AcquireControllerLeaseResult = {
-    acquired: true;
-    lease: CoordinatorLease;
-} | {
-    acquired: false;
-    lease: CoordinatorLease | null;
-};
-interface CoordinatorCompatibilityMetadata {
-    packageVersion?: string;
-    specVersion?: string;
-    protocolVersion?: string;
-}
-interface RegisterNodeSessionInput {
-    clusterId: string;
-    nodeId: string;
-    ttlMs: number;
-    endpoint?: string;
-    groupIds?: string[];
-    dataBearing?: boolean;
-    voting?: boolean;
-    compatibility?: CoordinatorCompatibilityMetadata;
-    metadata?: Record<string, unknown>;
-}
-interface CoordinatorNodeSession {
-    clusterId: string;
-    nodeId: string;
-    lease: CoordinatorLease;
-    endpoint?: string;
-    groupIds: string[];
-    dataBearing: boolean;
-    voting: boolean;
-    compatibility?: CoordinatorCompatibilityMetadata;
-    metadata?: Record<string, unknown>;
-}
-interface CoordinatorPrimary {
-    nodeId: string;
-    endpoint?: string;
-}
-interface ReplicationGroupState {
-    clusterId: string;
-    groupId: string;
-    votingDataBearingNodeIds: string[];
-    currentPrimary: CoordinatorPrimary | null;
-    primaryTerm: bigint;
-    durabilityPointSeq: bigint;
-    inSyncNodeIds: string[];
-    drainingNodeIds: string[];
-    repairingNodeIds: string[];
-    faultedNodeIds: string[];
-    compatibility?: CoordinatorCompatibilityMetadata;
-    updatedAtMs: number;
-}
-interface SetReplicationGroupStateInput {
-    clusterId: string;
-    groupId: string;
-    votingDataBearingNodeIds: string[];
-    currentPrimary?: CoordinatorPrimary | null;
-    primaryTerm?: bigint;
-    durabilityPointSeq?: bigint;
-    inSyncNodeIds?: string[];
-    drainingNodeIds?: string[];
-    repairingNodeIds?: string[];
-    faultedNodeIds?: string[];
-    compatibility?: CoordinatorCompatibilityMetadata;
-}
-interface CompareAndAdvancePrimaryTermInput {
-    clusterId: string;
-    groupId: string;
-    expectedPrimaryTerm: bigint;
-    nextPrimary: CoordinatorPrimary;
-}
-interface CompareAndAdvancePrimaryTermResult {
-    advanced: boolean;
-    state: ReplicationGroupState | null;
-}
-interface UpdateInSyncSetInput {
-    clusterId: string;
-    groupId: string;
-    inSyncNodeIds: string[];
-    durabilityPointSeq?: bigint;
-}
-interface AdmitNodeToInSyncSetInput {
-    clusterId: string;
-    groupId: string;
-    nodeId: string;
-    sourceNodeId: string;
-    appliedSeq: bigint;
-}
-interface UpdateNodeMaintenanceInput {
-    clusterId: string;
-    groupId: string;
-    nodeId: string;
-    draining?: boolean;
-    repairing?: boolean;
-    faulted?: boolean;
-}
-interface PromoteEligibleReplicaInput {
-    clusterId: string;
-    groupId: string;
-    excludeNodeIds?: string[];
-}
-type ReplicationGroupWatcher = (state: ReplicationGroupState) => void;
-interface ClusterCoordinator {
-    tryAcquireControllerLease(input: AcquireControllerLeaseInput): Promise<AcquireControllerLeaseResult>;
-    renewLease(leaseId: string, ttlMs: number): Promise<boolean>;
-    releaseLease(leaseId: string): Promise<boolean>;
-    registerNodeSession(input: RegisterNodeSessionInput): Promise<CoordinatorNodeSession>;
-    getLiveNodeSession(clusterId: string, nodeId: string): Promise<CoordinatorNodeSession | null>;
-    deregisterNodeSession(clusterId: string, nodeId: string): Promise<void>;
-    setReplicationGroupState(input: SetReplicationGroupStateInput): Promise<ReplicationGroupState>;
-    getReplicationGroupState(clusterId: string, groupId: string): Promise<ReplicationGroupState | null>;
-    watchReplicationGroup(clusterId: string, groupId: string, watcher: ReplicationGroupWatcher): CoordinatorWatchDisposer | Promise<CoordinatorWatchDisposer>;
-    compareAndAdvancePrimaryTerm(input: CompareAndAdvancePrimaryTermInput): Promise<CompareAndAdvancePrimaryTermResult>;
-    updateInSyncSet(input: UpdateInSyncSetInput): Promise<ReplicationGroupState | null>;
-    admitNodeToInSyncSet(input: AdmitNodeToInSyncSetInput): Promise<ReplicationGroupState | null>;
-    updateNodeMaintenance(input: UpdateNodeMaintenanceInput): Promise<ReplicationGroupState | null>;
-    promoteEligibleReplica(input: PromoteEligibleReplicaInput): Promise<ReplicationGroupState>;
-    close?(): Promise<void>;
-}
-
-export type { AcquireControllerLeaseInput as A, ClusterCoordinator as C, PromoteEligibleReplicaInput as P, ReplicationGroupState as R, SetReplicationGroupStateInput as S, UpdateInSyncSetInput as U, CoordinatorCompatibilityMetadata as a, AcquireControllerLeaseResult as b, RegisterNodeSessionInput as c, CoordinatorNodeSession as d, ReplicationGroupWatcher as e, CoordinatorWatchDisposer as f, CompareAndAdvancePrimaryTermInput as g, CompareAndAdvancePrimaryTermResult as h, AdmitNodeToInSyncSetInput as i, UpdateNodeMaintenanceInput as j, CoordinatorLease as k, CoordinatorPrimary as l };

package/dist/types-C_D8IhpO.d.ts

@@ -1,60 +0,0 @@
-interface HLCTimestamp {
-    wallMs: number;
-    logical: number;
-    nodeId: string;
-}
-interface ReplicationChange {
-    table: string;
-    operation: 'insert' | 'update' | 'delete' | 'ddl';
-    rowId: string;
-    primaryKey: Record<string, unknown>;
-    hlc: string;
-    txId: string;
-    nodeId: string;
-    newData: Record<string, unknown> | null;
-    oldData: Record<string, unknown> | null;
-    ddlStatement?: string;
-}
-interface ReplicationBatch {
-    sourceNodeId: string;
-    batchId: string;
-    fromSeq: bigint;
-    toSeq: bigint;
-    hlcRange: {
-        min: string;
-        max: string;
-    };
-    changes: ReplicationChange[];
-    checksum: string;
-    groupId?: string;
-    primaryTerm?: bigint;
-}
-interface ConflictContext {
-    table: string;
-    rowId: string;
-    localChange: ReplicationChange | null;
-    remoteChange: ReplicationChange;
-    localHlc: string | null;
-    remoteHlc: string;
-}
-interface ConflictResolution {
-    action: 'accept_remote' | 'keep_local' | 'merge';
-    mergedData?: Record<string, unknown>;
-}
-interface ConflictResolver {
-    resolve(ctx: ConflictContext): ConflictResolution | Promise<ConflictResolution>;
-}
-interface ApplyResult {
-    applied: number;
-    skipped: number;
-    conflicts: number;
-    droppedTables: string[];
-}
-interface SyncTableManifest {
-    table: string;
-    rowCount: number;
-    pkHash?: string;
-    batchDigest?: string;
-}
-
-export type { ApplyResult as A, ConflictResolver as C, HLCTimestamp as H, ReplicationBatch as R, SyncTableManifest as S, ConflictContext as a, ConflictResolution as b, ReplicationChange as c };