@verdant-web/store 3.3.1 → 3.4.0-next.0

package/dist/esm/queries/BaseQuery.d.ts

@@ -1,53 +0,0 @@
-import { Context } from '../context.js';
-import { Disposable } from '../utils/Disposable.js';
-export type BaseQueryEvents = {
-    change: (value: any) => void;
-    statusChange: (status: QueryStatus) => void;
-};
-export type BaseQueryOptions<T> = {
-    context: Context;
-    initial: T;
-    collection: string;
-    key: string;
-    shouldUpdate?: (updatedCollections: string[]) => boolean;
-};
-export type QueryStatus = 'initial' | 'initializing' | 'revalidating' | 'ready';
-export declare const ON_ALL_UNSUBSCRIBED: unique symbol;
-export declare const UPDATE: unique symbol;
-export declare abstract class BaseQuery<T> extends Disposable {
-    private _rawValue;
-    private _value;
-    private _events;
-    private _internalUnsubscribes;
-    private _allUnsubscribedHandler?;
-    private _status;
-    private _executionPromise;
-    protected context: Context;
-    readonly collection: string;
-    readonly key: string;
-    constructor({ initial, context, collection, key, shouldUpdate, }: BaseQueryOptions<T>);
-    get current(): T;
-    get resolved(): Promise<T>;
-    get subscribed(): boolean;
-    get status(): QueryStatus;
-    /**
-     * Subscribe to changes in the query value.
-     *
-     * @deprecated use the two parameter form instead
-     */
-    subscribe(callback: (value: T) => void): () => void;
-    /**
-     * Subscribe to changes in the query value.
-     */
-    subscribe(event: 'change', callback: (value: T) => void): () => void;
-    /**
-     * Subscribe to changes in the query state.
-     */
-    subscribe(event: 'statusChange', callback: (status: QueryStatus) => void): () => void;
-    protected setValue: (value: T) => void;
-    protected refreshValue: () => void;
-    private subscribeToDeleteAndRestore;
-    execute: () => Promise<T>;
-    protected abstract run(): Promise<void>;
-    [ON_ALL_UNSUBSCRIBED]: (handler: (query: BaseQuery<T>) => void) => void;
-}

package/dist/esm/queries/CollectionQueries.d.ts

@@ -1,55 +0,0 @@
-import { CollectionFilter } from '@verdant-web/common';
-import { Context } from '../context.js';
-import { EntityStore } from '../entities/EntityStore.js';
-import { GetQuery } from './GetQuery.js';
-import { QueryCache } from './QueryCache.js';
-import { FindOneQuery } from './FindOneQuery.js';
-import { FindPageQuery } from './FindPageQuery.js';
-import { FindInfiniteQuery } from './FindInfiniteQuery.js';
-import { FindAllQuery } from './FindAllQuery.js';
-import { DocumentManager } from '../DocumentManager.js';
-import { ObjectEntity } from '../index.js';
-export declare class CollectionQueries<T extends ObjectEntity<any, any>, Init, Filter extends CollectionFilter> {
-    private cache;
-    private collection;
-    private hydrate;
-    private context;
-    private documentManager;
-    put: (init: Init, options?: {
-        undoable?: boolean;
-    }) => Promise<T>;
-    delete: (id: string, options?: {
-        undoable?: boolean;
-    }) => Promise<void>;
-    deleteAll: (ids: string[], options?: {
-        undoable?: boolean;
-    }) => Promise<void>;
-    constructor({ collection, cache, entities, context, documentManager, }: {
-        collection: string;
-        cache: QueryCache;
-        entities: EntityStore;
-        context: Context;
-        documentManager: DocumentManager<any>;
-    });
-    private serializeIndex;
-    get: (id: string) => GetQuery<T>;
-    findOne: ({ index, key: providedKey, }?: {
-        index?: Filter | undefined;
-        key?: string | undefined;
-    }) => FindOneQuery<T>;
-    findAll: ({ index, key: providedKey, }?: {
-        index?: Filter | undefined;
-        key?: string | undefined;
-    }) => FindAllQuery<T>;
-    findPage: ({ index, pageSize, page, key: providedKey, }: {
-        index?: Filter | undefined;
-        pageSize: number;
-        page: number;
-        key?: string | undefined;
-    }) => FindPageQuery<T>;
-    findAllInfinite: ({ index, pageSize, key: providedKey, }: {
-        index?: Filter | undefined;
-        pageSize: number;
-        key?: string | undefined;
-    }) => FindInfiniteQuery<T>;
-}

package/dist/esm/queries/FindAllQuery.d.ts

@@ -1,12 +0,0 @@
-import { CollectionFilter } from '@verdant-web/common';
-import { BaseQuery, BaseQueryOptions, UPDATE } from './BaseQuery.js';
-export declare class FindAllQuery<T> extends BaseQuery<T[]> {
-    private index;
-    private hydrate;
-    constructor({ index, hydrate, ...rest }: {
-        index?: CollectionFilter;
-        hydrate: (oid: string) => Promise<T>;
-    } & Omit<BaseQueryOptions<T[]>, 'initial'>);
-    protected run: () => Promise<void>;
-    [UPDATE]: (index: CollectionFilter | undefined) => void;
-}

package/dist/esm/queries/FindInfiniteQuery.d.ts

@@ -1,19 +0,0 @@
-import { CollectionFilter } from '@verdant-web/common';
-import { BaseQuery, BaseQueryOptions, UPDATE } from './BaseQuery.js';
-export declare class FindInfiniteQuery<T> extends BaseQuery<T[]> {
-    private index;
-    private hydrate;
-    private _upToPage;
-    private _pageSize;
-    private _hasNextPage;
-    get pageSize(): number;
-    get hasMore(): boolean;
-    constructor({ hydrate, pageSize, index, ...rest }: {
-        hydrate: (oid: string) => Promise<T>;
-        pageSize: number;
-        index?: CollectionFilter;
-    } & Omit<BaseQueryOptions<T[]>, 'initial'>);
-    protected run: () => Promise<void>;
-    loadMore: () => Promise<void>;
-    [UPDATE]: (index: CollectionFilter | undefined) => void;
-}

package/dist/esm/queries/FindOneQuery.d.ts

@@ -1,12 +0,0 @@
-import { CollectionFilter } from '@verdant-web/common';
-import { BaseQuery, BaseQueryOptions, UPDATE } from './BaseQuery.js';
-export declare class FindOneQuery<T> extends BaseQuery<T | null> {
-    private index;
-    private hydrate;
-    constructor({ index, hydrate, ...rest }: {
-        index?: CollectionFilter;
-        hydrate: (oid: string) => Promise<T>;
-    } & Omit<BaseQueryOptions<T | null>, 'initial'>);
-    protected run: () => Promise<void>;
-    [UPDATE]: (index: CollectionFilter | undefined) => void;
-}

package/dist/esm/queries/FindPageQuery.d.ts

@@ -1,24 +0,0 @@
-import { CollectionFilter } from '@verdant-web/common';
-import { BaseQuery, BaseQueryOptions, UPDATE } from './BaseQuery.js';
-export declare class FindPageQuery<T> extends BaseQuery<T[]> {
-    private index;
-    private hydrate;
-    private _pageSize;
-    private _page;
-    private _hasNextPage;
-    get pageSize(): number;
-    get page(): number;
-    get hasNextPage(): boolean;
-    get hasPreviousPage(): boolean;
-    constructor({ index, hydrate, pageSize, page, ...rest }: {
-        index?: CollectionFilter;
-        hydrate: (oid: string) => Promise<T>;
-        pageSize: number;
-        page: number;
-    } & Omit<BaseQueryOptions<T[]>, 'initial'>);
-    protected run: () => Promise<void>;
-    nextPage: () => Promise<void>;
-    previousPage: () => Promise<void>;
-    setPage: (page: number) => Promise<void>;
-    [UPDATE]: (index: CollectionFilter | undefined) => void;
-}

package/dist/esm/queries/GetQuery.d.ts

@@ -1,10 +0,0 @@
-import { BaseQuery, BaseQueryOptions } from './BaseQuery.js';
-export declare class GetQuery<T> extends BaseQuery<T | null> {
-    private hydrate;
-    private oid;
-    constructor({ id, hydrate, ...rest }: {
-        id: string;
-        hydrate: (oid: string) => Promise<T>;
-    } & Omit<BaseQueryOptions<T | null>, 'initial'>);
-    protected run: () => Promise<void>;
-}

package/dist/esm/queries/QueryCache.d.ts

@@ -1,17 +0,0 @@
-import { Context } from '../context.js';
-import { Disposable } from '../utils/Disposable.js';
-import { BaseQuery } from './BaseQuery.js';
-export declare class QueryCache extends Disposable {
-    private _cache;
-    private _evictionTime;
-    private context;
-    constructor({ evictionTime, context, }: {
-        evictionTime?: number;
-        context: Context;
-    });
-    get<T extends BaseQuery<any>>(key: string): T | null;
-    set<V extends BaseQuery<any>>(value: V): V;
-    getOrSet<V extends BaseQuery<any>>(key: string, create: () => V, update?: (query: V) => void): V;
-    private onQueryUnsubscribed;
-    dropAll: () => void;
-}

package/dist/esm/queries/QueryableStorage.d.ts

@@ -1,20 +0,0 @@
-import { ObjectIdentifier } from '@verdant-web/common';
-import { IDBService } from '../IDBService.js';
-import { Context } from '../context.js';
-export declare class QueryableStorage extends IDBService {
-    private ctx;
-    constructor({ ctx }: {
-        ctx: Context;
-    });
-    /**
-     * DELETES EVERYTHING IN THE QUERYABLE DATABASE
-     */
-    reset: () => Promise<void>;
-    saveEntities: (entities: {
-        oid: ObjectIdentifier;
-        getSnapshot: () => any;
-    }[], opts?: {
-        abort?: AbortSignal;
-    }) => Promise<void>;
-    private saveDocument;
-}

package/dist/esm/queries/dbQueries.d.ts

@@ -1,22 +0,0 @@
-import { CollectionFilter } from '@verdant-web/common';
-import { Context } from '../context.js';
-export declare function findOneOid({ collection, index, context, }: {
-    collection: string;
-    index?: CollectionFilter;
-    context: Context;
-}): Promise<string | null>;
-export declare function findAllOids({ collection, index, context, }: {
-    collection: string;
-    index?: CollectionFilter;
-    context: Context;
-}): Promise<string[]>;
-export declare function findPageOfOids({ collection, index, context, limit, offset, }: {
-    collection: string;
-    index?: CollectionFilter;
-    context: Context;
-    limit?: number;
-    offset?: number;
-}): Promise<{
-    result: string[];
-    hasNextPage: boolean;
-}>;

package/dist/esm/queries/keys.d.ts

@@ -1,10 +0,0 @@
-export interface QueryParams {
-    collection: string;
-    range: IDBKeyRange | IDBValidKey | undefined;
-    index?: string;
-    direction?: IDBCursorDirection;
-    limit?: number;
-    single?: boolean;
-    write?: boolean;
-}
-export declare function getQueryKey({ range, ...rest }: QueryParams): string;

package/dist/esm/queries/ranges.d.ts

@@ -1,2 +0,0 @@
-import { CollectionFilter, StorageSchema } from '@verdant-web/common';
-export declare function getRange(schema: StorageSchema, collection: string, index?: CollectionFilter): IDBKeyRange | undefined;

package/dist/esm/queries/types.d.ts

@@ -1,6 +0,0 @@
-import type { FindAllQuery } from './FindAllQuery.js';
-import type { FindPageQuery } from './FindPageQuery.js';
-import type { FindOneQuery } from './FindOneQuery.js';
-import type { FindInfiniteQuery } from './FindInfiniteQuery.js';
-import type { GetQuery } from './GetQuery.js';
-export type Query<T> = FindAllQuery<T> | FindPageQuery<T> | FindOneQuery<T> | FindInfiniteQuery<T> | GetQuery<T>;

package/dist/esm/queries/utils.d.ts

@@ -1,3 +0,0 @@
-import { CollectionIndexFilter } from '@verdant-web/common';
-export declare function filterResultSet(results: any): any;
-export declare function areIndexesEqual(a?: CollectionIndexFilter, b?: CollectionIndexFilter): boolean | undefined;

package/dist/esm/sync/FileSync.d.ts

@@ -1,24 +0,0 @@
-import { FileData } from '@verdant-web/common';
-import { ServerSyncEndpointProvider } from './ServerSyncEndpointProvider.js';
-export interface FileUploadResult {
-    success: boolean;
-    retry: boolean;
-}
-export type FilePullResult = {
-    success: true;
-    data: FileData;
-} | {
-    success: false;
-    retry: boolean;
-    error?: any;
-};
-export declare class FileSync {
-    private endpointProvider;
-    private log;
-    constructor({ endpointProvider, log, }: {
-        endpointProvider: ServerSyncEndpointProvider;
-        log: (...args: any[]) => any;
-    });
-    uploadFile: (data: FileData) => Promise<FileUploadResult>;
-    getFile: (id: string) => Promise<FilePullResult>;
-}

package/dist/esm/sync/Heartbeat.d.ts

@@ -1,25 +0,0 @@
-import { EventSubscriber } from '@verdant-web/common';
-export declare class Heartbeat extends EventSubscriber<{
-    missed: () => void;
-    beat: () => void;
-}> {
-    private _interval;
-    private deadlineLength;
-    private nextBeat;
-    private deadline;
-    get interval(): number;
-    constructor({ interval, deadlineLength, restartOnTabFocus, }?: {
-        interval?: number;
-        deadlineLength?: number;
-        restartOnTabFocus?: boolean;
-    });
-    keepAlive: () => void;
-    start: (immediate?: boolean) => void;
-    stop: () => void;
-    private beat;
-    private onDeadline;
-    /**
-     * Only takes affect after the next beat
-     */
-    setInterval: (interval: number) => void;
-}

package/dist/esm/sync/PresenceManager.d.ts

@@ -1,55 +0,0 @@
-import { ServerMessage, EventSubscriber } from '@verdant-web/common';
-import type { UserInfo } from '../index.js';
-import { LocalReplicaInfo, LocalReplicaStore } from '../metadata/LocalReplicaStore.js';
-export declare const HANDLE_MESSAGE: unique symbol;
-export declare class PresenceManager<Profile = any, Presence = any> extends EventSubscriber<{
-    /**
-     * Fired when a particular peer's presence changes
-     */
-    peerChanged: (userId: string, presence: UserInfo<Profile, Presence>) => void;
-    /**
-     * Fired immediately when a change to local presence is made. This change may not
-     * yet have been sent to the server (see: "update" event)
-     */
-    selfChanged: (presence: UserInfo<Profile, Presence>) => void;
-    /** Fired when any number of peer presences have changed */
-    peersChanged: (peers: Record<string, UserInfo<Profile, Presence>>) => void;
-    /** Fired when a peer presence goes offline */
-    peerLeft: (userId: string, lastPresence: UserInfo<Profile, Presence>) => void;
-    /** Fired after local presence changes are flushed to the server. */
-    update: (presence: Partial<Presence>) => void;
-    load: () => void;
-}> {
-    private _peers;
-    private _self;
-    private _selfReplicaIds;
-    private _peerIds;
-    private _updateBatcher;
-    private _updateBatch;
-    get self(): UserInfo<Profile, Presence>;
-    get peers(): Record<string, UserInfo<Profile, Presence>>;
-    get peerIds(): string[];
-    get everyone(): {
-        [x: string]: UserInfo<Profile, Presence>;
-    };
-    get selfReplicaIds(): Set<string>;
-    constructor({ initialPresence, updateBatchTimeout, defaultProfile, replicaStore, }: {
-        initialPresence: Presence;
-        defaultProfile: Profile;
-        updateBatchTimeout?: number;
-        replicaStore: LocalReplicaStore;
-    });
-    /**
-     * Decides if an update is for the local user or not. Even if it's a different replica
-     * than the local one.
-     *
-     * If the replicaId matches, we use that first - we may not know the local replica's User ID yet,
-     * e.g. on the first presence update.
-     *
-     * Otherwise, match the user ID to our local copy.
-     */
-    private isSelf;
-    [HANDLE_MESSAGE]: (localReplicaInfo: LocalReplicaInfo, message: ServerMessage) => Promise<void>;
-    update: (presence: Partial<Presence>) => Promise<void>;
-    flushPresenceUpdates: (presenceUpdates: Partial<Presence>[]) => void;
-}

package/dist/esm/sync/PushPullSync.d.ts

@@ -1,39 +0,0 @@
-import { ClientMessage, EventSubscriber } from '@verdant-web/common';
-import { Metadata } from '../metadata/Metadata.js';
-import { PresenceManager } from './PresenceManager.js';
-import { ServerSyncEndpointProvider } from './ServerSyncEndpointProvider.js';
-import { SyncTransport, SyncTransportEvents } from './Sync.js';
-export declare class PushPullSync extends EventSubscriber<SyncTransportEvents> implements SyncTransport {
-    readonly meta: Metadata;
-    readonly presence: PresenceManager;
-    private endpointProvider;
-    private heartbeat;
-    private fetch;
-    readonly mode = "pull";
-    private log;
-    private _isConnected;
-    private _status;
-    private _hasSynced;
-    constructor({ endpointProvider, meta, presence, interval, log, fetch, }: {
-        endpointProvider: ServerSyncEndpointProvider;
-        meta: Metadata;
-        presence: PresenceManager;
-        interval?: number;
-        log?: (...args: any[]) => any;
-        fetch?: typeof window.fetch;
-    });
-    setInterval: (interval: number) => void;
-    get interval(): number;
-    private sendRequest;
-    private handleServerMessage;
-    send: (message: ClientMessage) => Promise<void> | undefined;
-    start(): void;
-    stop(): void;
-    destroy: () => void;
-    reconnect(): void;
-    ignoreIncoming(): void;
-    private onHeartbeat;
-    private onHeartbeatMissed;
-    get isConnected(): boolean;
-    get status(): "active" | "paused";
-}

package/dist/esm/sync/ServerSyncEndpointProvider.d.ts

@@ -1,34 +0,0 @@
-import { ReplicaType } from '@verdant-web/common';
-export interface ServerSyncEndpointProviderConfig {
-    /**
-     * The location of the endpoint used to retrieve an
-     * authorization token for the client.
-     */
-    authEndpoint?: string;
-    /**
-     * A custom function to retrieve authorization
-     * data. Use whatever fetching mechanism you want.
-     */
-    fetchAuth?: () => Promise<{
-        accessToken: string;
-    }>;
-    /**
-     * A spec-compliant fetch implementation. If not provided,
-     * the global fetch will be used. authEndpoint will
-     * be used to fetch the token.
-     */
-    fetch?: typeof fetch;
-}
-export declare class ServerSyncEndpointProvider {
-    private config;
-    private cached;
-    type: ReplicaType;
-    constructor(config: ServerSyncEndpointProviderConfig);
-    getEndpoints: () => Promise<{
-        http: string;
-        websocket: string;
-        files: string;
-        token: string;
-    }>;
-    clearCache: () => void;
-}

package/dist/esm/sync/Sync.d.ts

@@ -1,160 +0,0 @@
-import { ClientMessage, DocumentBaseline, EventSubscriber, FileData, Operation, ServerMessage } from '@verdant-web/common';
-import { Metadata } from '../metadata/Metadata.js';
-import { PresenceManager } from './PresenceManager.js';
-import { FilePullResult, FileUploadResult } from './FileSync.js';
-import { ServerSyncEndpointProviderConfig } from './ServerSyncEndpointProvider.js';
-type SyncEvents = {
-    onlineChange: (isOnline: boolean) => void;
-    syncingChange: (syncing: boolean) => void;
-};
-export type SyncTransportEvents = SyncEvents & {
-    message: (message: ServerMessage) => void;
-};
-export interface SyncTransport extends EventSubscriber<SyncTransportEvents> {
-    readonly presence: PresenceManager;
-    readonly mode: SyncTransportMode;
-    send(message: ClientMessage): void;
-    start(): void;
-    ignoreIncoming(): void;
-    stop(): void;
-    destroy(): void;
-    reconnect(): void;
-    readonly isConnected: boolean;
-    readonly status: 'active' | 'paused';
-}
-export interface Sync<Presence = any, Profile = any> extends EventSubscriber<SyncEvents> {
-    setMode(mode: SyncTransportMode): void;
-    setPullInterval(interval: number): void;
-    readonly pullInterval: number;
-    uploadFile(data: FileData): Promise<FileUploadResult>;
-    getFile(fileId: string): Promise<FilePullResult>;
-    readonly presence: PresenceManager<Profile, Presence>;
-    send(message: ClientMessage): void;
-    start(): void;
-    stop(): void;
-    ignoreIncoming(): void;
-    destroy(): void;
-    reconnect(): void;
-    readonly isConnected: boolean;
-    readonly status: 'active' | 'paused';
-    readonly mode: SyncTransportMode;
-}
-export declare class NoSync<Presence = any, Profile = any> extends EventSubscriber<SyncEvents> implements Sync<Presence, Profile> {
-    readonly mode = "pull";
-    send(): void;
-    start(): void;
-    stop(): void;
-    ignoreIncoming(): void;
-    destroy: () => void;
-    reconnect(): void;
-    setMode(): void;
-    setPullInterval(): void;
-    readonly isConnected = false;
-    readonly status = "paused";
-    readonly pullInterval = 0;
-    readonly presence: PresenceManager<any, any>;
-    constructor({ meta }: {
-        meta: Metadata;
-    });
-    uploadFile: () => Promise<{
-        success: boolean;
-        retry: boolean;
-    }>;
-    getFile: () => Promise<FilePullResult>;
-}
-export type SyncTransportMode = 'realtime' | 'pull';
-export interface ServerSyncOptions<Profile = any, Presence = any> extends ServerSyncEndpointProviderConfig {
-    /**
-     * When a client first connects, it will use this presence value.
-     */
-    initialPresence: Presence;
-    /**
-     * Before connecting to the server, the local client will have
-     * this value for their profile data. You can either cache and store
-     * profile data from a previous connection or provide defaults like
-     * empty strings.
-     */
-    defaultProfile: Profile;
-    /**
-     * Provide `false` to disable transport selection. Transport selection
-     * automatically switches between HTTP and WebSocket based sync depending
-     * on the number of peers connected. If a user is alone, they will use
-     * HTTP push/pull to sync changes. If another user joins, both users will
-     * be upgraded to websockets.
-     *
-     * Provide `peers-only` to only automatically use websockets if other
-     * users connect, but not if another device for the current user connects.
-     * By default, automatic transport selection will upgrade to websockets if
-     * another device from the current user connects, but if realtime sync is
-     * not necessary for such cases, you can save bandwidth by disabling this.
-     *
-     * Turning off this feature allows you more control over the transport
-     * which can be useful for low-power devices or to save server traffic.
-     * To modify transport modes manually, utilize `client.sync.setMode`.
-     * The built-in behavior is essentially switching modes based on
-     * the number of peers detected by client.sync.presence.
-     */
-    automaticTransportSelection?: boolean | 'peers-only';
-    initialTransport?: SyncTransportMode;
-    autoStart?: boolean;
-    /**
-     * Optionally specify an interval, in milliseconds, to poll the server
-     * when in pull mode.
-     */
-    pullInterval?: number;
-    /**
-     * Presence updates are batched to reduce number of requests / messages
-     * sent to the server. You can specify the batching time slice, in milliseconds,
-     */
-    presenceUpdateBatchTimeout?: number;
-    /**
-     * Experimental: sync messages over a broadcast channel between tabs.
-     * Fixes tabs not reactively updating to changes when other tabs are open,
-     * but is not yet thoroughly vetted.
-     */
-    useBroadcastChannel?: boolean;
-}
-export declare class ServerSync<Presence = any, Profile = any> extends EventSubscriber<SyncEvents> implements Sync<Presence, Profile> {
-    private webSocketSync;
-    private pushPullSync;
-    private fileSync;
-    private activeSync;
-    private endpointProvider;
-    private onData;
-    private broadcastChannel;
-    private _activelySyncing;
-    private meta;
-    readonly presence: PresenceManager<Profile, Presence>;
-    private log;
-    constructor({ authEndpoint, fetchAuth, fetch, initialPresence, automaticTransportSelection, autoStart, initialTransport, pullInterval, presenceUpdateBatchTimeout, defaultProfile, useBroadcastChannel, }: ServerSyncOptions<Profile, Presence>, { meta, log, onData, }: {
-        meta: Metadata;
-        log?: (...args: any[]) => void;
-        onData: (data: {
-            operations: Operation[];
-            baselines: DocumentBaseline[];
-            reset?: boolean;
-        }) => Promise<void>;
-    });
-    get canDoRealtime(): boolean;
-    get syncing(): boolean;
-    private handleBroadcastChannelMessage;
-    private onTokenExpired;
-    private handleMessage;
-    private handleOnlineChange;
-    private handlePresenceUpdate;
-    setMode: (transport: SyncTransportMode) => void;
-    setPullInterval: (interval: number) => void;
-    get pullInterval(): number;
-    send: (message: ClientMessage) => void;
-    uploadFile: (info: FileData) => Promise<FileUploadResult>;
-    getFile: (id: string) => Promise<FilePullResult>;
-    start: () => void;
-    stop: () => void;
-    ignoreIncoming(): void;
-    destroy: () => void;
-    reconnect: () => void;
-    get isConnected(): boolean;
-    get status(): "active" | "paused";
-    get mode(): SyncTransportMode;
-}
-export {};

package/dist/esm/sync/WebSocketSync.d.ts

@@ -1,44 +0,0 @@
-import { ClientMessage, EventSubscriber } from '@verdant-web/common';
-import { Metadata } from '../metadata/Metadata.js';
-import { PresenceManager } from './PresenceManager.js';
-import { ServerSyncEndpointProvider } from './ServerSyncEndpointProvider.js';
-import { SyncTransport, SyncTransportEvents } from './Sync.js';
-export declare class WebSocketSync extends EventSubscriber<SyncTransportEvents> implements SyncTransport {
-    private meta;
-    readonly presence: PresenceManager;
-    private socket;
-    private connectQueue;
-    private syncQueue;
-    private incomingQueue;
-    private endpointProvider;
-    private _status;
-    private synced;
-    private hasStartedSync;
-    private _ignoreIncoming;
-    readonly mode = "realtime";
-    private log;
-    private heartbeat;
-    private reconnectScheduler;
-    constructor({ endpointProvider, meta, presence, log, }: {
-        endpointProvider: ServerSyncEndpointProvider;
-        meta: Metadata;
-        presence: PresenceManager;
-        log?: (...args: any[]) => any;
-    });
-    private onOpen;
-    private onOnlineChange;
-    private onMessage;
-    private onError;
-    private onClose;
-    private initializeSocket;
-    private sendHeartbeat;
-    reconnect: () => void;
-    private canSkipSyncWait;
-    send: (message: ClientMessage) => void;
-    destroy: () => void;
-    start: () => void;
-    stop: () => void;
-    ignoreIncoming(): void;
-    get isConnected(): boolean;
-    get status(): "active" | "paused";
-}