@dittolive/ditto 4.3.0 → 4.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dittolive/ditto",
-  "version": "4.3.0",
+  "version": "4.4.0",
   "description": "Ditto is a cross-platform embeddable NoSQL database that can sync with or without an internet connection.",
   "homepage": "https://ditto.live",
   "license": "SEE LICENSE IN LICENSE.md",
@@ -41,10 +41,10 @@
   },
 
   "dependencies": {
-    "cbor-redux": "^0.4.0"
+    "cbor-redux": "^1.0.0"
   },
 
   "devDependencies": {
-    "serve": "^14.1.2"
+    "serve": "^14.2.0"
   }
 }

package/types/ditto.d.ts

@@ -750,6 +750,21 @@ declare class UpdateResultsMap {
     private updateResultsByDocumentIDString;
 }
 
+/**
+ * Restore a `TransportConfig` from its serializable representation.
+ *
+ * @internal
+ */
+declare function transportConfigFromDeserializable(serialized: any): TransportConfig;
+/**
+ * Convert a `TransportConfig` to a serializable representation.
+ *
+ * This mainly involves converting the `TransportConfig`'s properties to have the expected key names
+ * and casing.
+ *
+ * @internal
+ */
+declare function transportConfigToSerializable(config: TransportConfig): any;
 /**
  * Part of {@link TransportConfig} type, configuration for listening for TCP
  * connections.
@@ -1096,6 +1111,8 @@ interface IdentitySharedKey {
 /**
  * A manually-provided certificate identity. This accepts a
  * base64-encoded bundle.
+ *
+ * A manual identity's `appID` is encoded in its certificate.
  */
 interface IdentityManual {
     type: 'manual';
@@ -1195,7 +1212,7 @@ type ConnectionType = 'P2PWiFi' | 'WebSocket' | 'AccessPoint' | 'Bluetooth';
  * with each other.
  */
 type Address = {
-    siteId: string;
+    siteId: number | BigInt;
     pubkey: Uint8Array;
 };
 /**
@@ -1206,13 +1223,28 @@ type Address = {
 declare function addressToString(address: Address): string;
 /** Represents a connection between two peers on the Ditto mesh network. */
 type Connection = {
-    /** Unique identifier for the connection. */
+    /** Unique identifier for the connection.
+     *
+     * These IDs are stable for any two peer keys and a given connection type.
+     *
+     * **Example ID**
+     *
+     * "1<->2:Bluetooth"
+     */
     id: string;
     /** Type of transport enabling this connection. */
-    type: ConnectionType;
-    /** The peer key of the peer at one end of the connection. */
+    connectionType: ConnectionType;
+    /**
+     * Peer key of the peer at one end of the connection.
+     *
+     * This peer key is lexicographically smaller than `peer2`.
+     */
     peer1: Uint8Array;
-    /** The peer key of the peer at one end of the connection. */
+    /**
+     * Peer key of the peer at the other end of the connection.
+     *
+     * This peer key is lexicographically larger than `peer1`.
+     */
     peer2: Uint8Array;
     approximateDistanceInMeters?: number;
 };
@@ -1431,11 +1463,15 @@ declare class LiveQueryEventInitial {
     readonly isInitial = true;
     /**
      * Returns a hash that represents the set of matching documents.
+     *
+     * @deprecated use {@link Document.hash | Document.hash()} instead.
      */
     hash(documents: Document[]): BigInt;
     /**
      * Returns a pattern of words that together create a mnemonic, which
      * represents the set of matching documents.
+     *
+     * @deprecated use {@link Document.hashMnemonic | Document.hashMnemonic()} instead.
      */
     hashMnemonic(documents: Document[]): string;
 }
@@ -1478,11 +1514,15 @@ declare class LiveQueryEventUpdate {
     readonly moves: LiveQueryMove[];
     /**
      * Returns a hash that represents the set of matching documents.
+     *
+     * @deprecated use {@link Document.hash | Document.hash()} instead.
      */
     hash(documents: Document[]): BigInt;
     /**
      * Returns a pattern of words that together create a mnemonic, which
      * represents the set of matching documents.
+     *
+     * @deprecated use {@link Document.hashMnemonic | Document.hashMnemonic()} instead.
      */
     hashMnemonic(documents: Document[]): string;
     /** @internal */
@@ -1506,11 +1546,15 @@ declare class SingleDocumentLiveQueryEvent {
     readonly oldDocument?: Document;
     /**
      * Returns a hash that represents the set of matching documents.
+     *
+     * @deprecated use {@link Document.hash | Document.hash()} instead.
      */
     hash(document: Document | null): BigInt;
     /**
      * Returns a pattern of words that together create a mnemonic, which
      * represents the set of matching documents.
+     *
+     * @deprecated use {@link Document.hashMnemonic | Document.hashMnemonic()} instead.
      */
     hashMnemonic(document: Document | null): string;
     /** @internal */
@@ -1865,8 +1909,18 @@ declare class Ditto {
     /**
      * The path this Ditto instance was initialized with, if no path was given at
      * construction time, the default value is returned (see constructor).
+     *
+     * @deprecated `Ditto.path` is deprecated. Please update your code to use the
+     * new 'Ditto.persistenceDirectory' property instead.
      */
-    readonly path: string;
+    get path(): string;
+    /**
+     * Path to the local directory used for persistent data storage.
+     *
+     * Defaults to 'ditto'. In environments without file system access, such as
+     * browsers, this is used as a namespace for the internal data store.
+     */
+    readonly persistenceDirectory: string;
     /**
      * Provides access to the SDK's store functionality.
      */
@@ -1896,10 +1950,15 @@ declare class Ditto {
     readonly isClosed: boolean;
     /**
      * Returns `true` if sync is active, otherwise returns `false`. Use
-     * {@link startSync | startSync()} to activate and {@link stopSync | stopSync()}
-     * to deactivate sync.
+     * {@link startSync | startSync()} to activate and
+     * {@link stopSync | stopSync()} to deactivate sync.
      */
     readonly isSyncActive: boolean;
+    /**
+     * Application ID associated with the {@link Identity | identity} used by this
+     * Ditto instance.
+     * */
+    readonly appID: string;
     /**
      * Initializes a new `Ditto` instance.
      *
@@ -1910,15 +1969,13 @@ declare class Ditto {
      * @param identity - Identity for the new Ditto instance, defaults to
      * `offlinePlayground` with `appID` being the empty string `''`.
      *
-     * @param path - On Node, `path` corresponds to a real directory
-     * on the file system (intermediate directories are created if needed). In the
-     * browser, `path` is used as an internal namespace for the in-memory storage.
-     * Defaults to `"ditto"`.
+     * @param persistenceDirectory optional string containing a directory path
+     * that Ditto will use for persistence. Defaults to `"ditto"`.
      *
      * @see {@link Ditto.identity}
-     * @see {@link Ditto.path}
+     * @see {@link Ditto.persistenceDirectory}
      */
-    constructor(identity?: Identity, path?: string);
+    constructor(identity?: Identity, persistenceDirectory?: string);
     /**
      * Don't terminate the process when callbacks are pending for a long time.
      *
@@ -1964,9 +2021,22 @@ declare class Ditto {
      */
     static isEnvironmentSupported(): boolean;
     /**
-     * Activate a `Ditto` instance by setting an offline only license token. You cannot initiate sync
-     * with `Ditto` before you have activated it. The offline license token is only valid for identities
-     * of type `development`, `manual`, `offlinePlayground`, and `sharedKey`.
+     * Validates and creates the given directory and returns its path.
+     *
+     * Any string containing non-whitespace characters is considered valid.
+     * Defaults to `ditto` if no path or an invalid path is given. In web
+     * environments, the given path is returned as-is if it is valid.
+     *
+     * @param path optional string containing a writable directory path
+     * @returns validated path
+     * @internal
+     */
+    static initPersistenceDirectory(path?: string): string;
+    /**
+     * Activate a `Ditto` instance by setting an offline only license token. You
+     * cannot initiate sync with `Ditto` before you have activated it. The offline
+     * license token is only valid for identities of type `development`, `manual`,
+     * `offlinePlayground`, and `sharedKey`.
      *
      * @param licenseToken the license token to activate the `Ditto` instance
      * with. You can find yours on the [Ditto portal](https://portal.ditto.live).
@@ -2053,7 +2123,7 @@ declare class Ditto {
      * transport conditions observers (not relevant when running in the browser).
      *
      * @param callback called when underlying transport conditions change with
-     * the changed `condition` and it's `source`.
+     * the changed `condition` and its `source`.
      */
     observeTransportConditions(callback: (condition: TransportCondition, source: ConditionSource) => void): Observer;
     /**
@@ -2137,7 +2207,14 @@ declare class Ditto {
     private setSyncActive;
     private makeDefaultTransportConfig;
 }
-/** @internal */
+/**
+ * Returns true if the current JS environment supports all required APIs.
+ *
+ * @param _globalObject optional global object to test this function without
+ * having to mock `global`.
+ * @returns `true` iff all required APIs exist on `global`.
+ * @internal
+ */
 declare const checkAPIs: (_globalObject?: Window | typeof globalThis) => boolean;
 /**
  * Disable deadlock timeout when Node.js is running with `--inspect` parameter.
@@ -2639,27 +2716,151 @@ declare class PendingCollectionsOperation implements PromiseLike<Collection[]> {
 }
 
 /**
- * Manages `ExperimentalSubscription` instances and removes them when Ditto is
+ * A change listener starts out in the `active` state and can be stopped by
+ * calling {@link ExperimentalChangeListener.stop | `stop()`} or letting it
+ * go out of scope.
+ *
+ * @internal
+ */
+type ExperimentalChangeListenerStatus = 'active' | 'stopped';
+/**
+ * A change listener invokes a change handler whenever results for its query
+ * change.
+ *
+ * Create a listener by calling
+ * {@link ExperimentalStore.addChangeListener | `ditto.store.experimental.addChangeListener()`}.
+ *
+ * @internal
+ */
+declare class ExperimentalChangeListener {
+    /**
+     * The DQL query this listener is reacting to.
+     */
+    readonly query: string;
+    /**
+     * The arguments to this listener's query.
+     */
+    readonly queryArgs?: QueryArguments;
+    /** @internal */
+    constructor(store: ExperimentalStore, query: string, queryArgs: QueryArguments | null, onChange: ChangeHandler | ChangeHandlerWithSignalNext, onError?: ErrorHandler, withSignalNext?: boolean);
+    /**
+     * A change listener starts out in the `active` state and can be stopped by
+     * calling {@link ExperimentalChangeListener.stop | `stop()`} or letting it go
+     * out of scope.
+     */
+    get status(): ExperimentalChangeListenerStatus;
+    /**
+     * Stops the listener from receiving any more updates.
+     */
+    stop(): void;
+    /**
+     * The ID of this listener's live query.
+     *
+     * @internal
+     */
+    readonly liveQueryID: number;
+    /**
+     * Closes the listener, preventing it from receiving any more updates.
+     *
+     * @internal
+     * */
+    close(): void;
+    private store;
+    private _status;
+    /**
+     * Signals to Ditto Core that the listener is ready for the next event.
+     */
+    private signalNext;
+    /**
+     * Creates bridged arguments for the user's change handler from the raw C callback arguments.
+     */
+    private static bridgeEventArguments;
+}
+
+/**
+ * A change handler is called whenever an active change listener receives new
+ * results.
+ *
+ * @internal
+ */
+type ChangeHandler = (result: Document[], event: LiveQueryEvent) => void;
+/**
+ * A change handler is called whenever an active change listener receives new
+ * results.
+ *
+ * Call `signalNext()` to signal that the handler is ready to receive the next
+ * callback from the change listener.
+ *
+ * @internal
+ */
+type ChangeHandlerWithSignalNext = (result: Document[], event: LiveQueryEvent, signalNext: () => void) => void;
+/**
+ * An error handler is called when a change handler throws an error.
+ *
+ * @internal
+ */
+type ErrorHandler = (error: Error) => void;
+/**
+ * Manages `ExperimentalChangeListener` instances and removes them when Ditto is closed.
+ *
+ * @internal
+ */
+declare class ExperimentalChangeListenerManager {
+    constructor(ditto: Ditto);
+    /**
+     * Register and start a change listener in core, also registering it in the listener manager.
+     *
+     * @internal
+     */
+    addChangeListener(listener: ExperimentalChangeListener): void;
+    /**
+     * Mark all change listeners as closed while deferring the closing of Ditto.
+     *
+     * @internal
+     */
+    close(): void;
+    /**
+     * Remove a change listener from the listener manager and stop it in core.
+     *
+     * @internal
+     * @param listener The change listener to remove.
+     */
+    removeChangeListener(listener: ExperimentalChangeListener): void;
+    private readonly ditto;
+    private readonly keepAlive;
+    private readonly listenersById;
+    /**
+     * Keeps track of change listeners by live query ID.
+     */
+    private readonly finalizationRegistry;
+    /**
+     * Remove a change listener without unregistering it from the finalization registry.
+     */
+    private stopLiveQuery;
+}
+
+/**
+ * Manages `ExperimentalReplicationSubscription` instances and removes them when Ditto is
  * closed.
  *
  * @internal
  */
-declare class ExperimentalSubscriptionManager {
+declare class ExperimentalReplicationSubscriptionManager {
     constructor(ditto: Ditto);
     /**
-     * Begin tracking a subscription instance and start it.
+     * Begin tracking a replication subscription instance and start it.
      *
      * @internal
      */
-    addSubscription(subscription: ExperimentalSubscription): void;
+    addSubscription(subscription: ExperimentalReplicationSubscription): void;
     /**
-     * Stop tracking a subscription instance and cancel it.
+     * Stop tracking a replication subscription instance and cancel it.
      *
      * @internal
      */
-    removeSubscription(subscription: ExperimentalSubscription): void;
+    removeSubscription(subscription: ExperimentalReplicationSubscription): void;
     /**
-     * Stop tracking all subscriptions and cancel them.
+     * Stop tracking all replication subscriptions and cancel them.
      *
      * @internal
      */
@@ -2668,54 +2869,53 @@ declare class ExperimentalSubscriptionManager {
     private subscriptions;
     private finalizationRegistry;
     /**
-     * Remove tracked subscription without unregistering from finalization
-     * registry.
-     *
-     * @internal
+     * Remove tracked replication subscription without unregistering from
+     * finalization registry.
      */
     private removeWithContextInfo;
 }
 
 /**
- * Contains all information required to deregister a subscription
- * in Ditto Core, even when the subscription instance itself has
+ * Contains all information required to deregister a replication subscription in
+ * Ditto Core, even when the replication subscription instance itself has
  * already been garbage collected.
  *
  * @internal
  */
-type ExperimentalSubscriptionContextInfo = {
+type ExperimentalReplicationSubscriptionContextInfo = {
     /** Unique ID per `ExperimentalSubscription` instance. */
     id: string;
     query: string;
     queryArgsCBOR: Uint8Array | null;
 };
 /**
- * Create a subscription to receive updates from remote peers about documents
- * matching the subscription's query.
+ * Create a replication subscription to receive updates from remote peers about
+ * documents matching the replication subscription's query.
  *
- * The subscription will remain active until {@link cancel | cancel()} is called
- * or the subscription object goes out of scope and is garbage collected.
+ * The replication subscription will remain active until
+ * {@link cancel | cancel()} is called or the replication subscription object
+ * goes out of scope and is garbage collected.
  *
  * @internal
  */
-declare class ExperimentalSubscription {
+declare class ExperimentalReplicationSubscription {
     /**
-     * Documents matching this query will be included in the subscription.
+     * Documents matching this query will be included in the replication subscription.
      */
     readonly query: string;
     /**
      * `true` when {@link cancel | cancel()} has been called or the Ditto instance
-     * managing this subscription has been closed.
+     * managing this replication subscription has been closed.
      */
     readonly isCancelled = false;
     /**
-     * Cancels a subscription and releases all associated resources.
+     * Cancels a replication subscription and releases all associated resources.
      */
     cancel(): void;
     /** @internal */
-    constructor(manager: ExperimentalSubscriptionManager, query: string, queryArgsCBOR: Uint8Array | null);
+    constructor(manager: ExperimentalReplicationSubscriptionManager, query: string, queryArgsCBOR: Uint8Array | null);
     /** @internal */
-    contextInfo: ExperimentalSubscriptionContextInfo;
+    contextInfo: ExperimentalReplicationSubscriptionContextInfo;
     /**
      * The corresponding named arguments for {@link query}, if any.
      *
@@ -2739,7 +2939,69 @@ declare class ExperimentalStore {
      * */
     readonly ditto: Ditto;
     /** @internal */
+    readonly listenerManager: ExperimentalChangeListenerManager;
+    /** @internal */
     constructor(ditto: Ditto);
+    /**
+     * Register a handler to be called whenever a query's results change in the
+     * local store.
+     *
+     * The returned {@link ExperimentalChangeListener} must be kept in scope for
+     * as long as the change handler should be called with new change events.
+     *
+     * The given query may not modify any documents and must be a valid Ditto
+     * Query Language query.
+     *
+     * If no `onError` argument is provided, errors that are thrown in the
+     * provided change handler will be logged to the console.
+     *
+     * The first invocation of `onChange` will always happen after this method
+     * returns. The next call to `onChange` will always wait until the previous
+     * call has returned. Use
+     * {@link ExperimentalStore.addChangeListenerWithSignalNext | addChangeListenerWithSignalNext()}
+     * if you want to control the rate of callbacks yourself.
+     *
+     * @internal
+     */
+    addChangeListener(query: string, onChange: ChangeHandler, onError?: ErrorHandler, queryArgs?: QueryArguments): ExperimentalChangeListener;
+    /**
+     * Register a handler to be called whenever a query's results change in the
+     * local store and control when the next invocation of the change handler
+     * happens.
+     *
+     * Here, a function is passed as an additional argument to the change handler.
+     * Call this function as soon as the change handler is ready to process the
+     * the next change event. This allows the change handler to control how often
+     * it is called.
+     *
+     * Otherwise identical to
+     * {@link ExperimentalStore.addChangeListener | addChangeListener()}.
+     *
+     * @internal
+     */
+    addChangeListenerWithSignalNext(query: string, onChange: ChangeHandlerWithSignalNext, onError?: ErrorHandler, queryArgs?: QueryArguments): ExperimentalChangeListener;
+    /**
+     * Registers a URL to be called whenever the given query observes changes.
+     *
+     * This API will stay internal-only as it is only used in the portal.
+     *
+     * @internal
+     * @returns a promise for a document id that acts as a webhook id
+     */
+    addChangeListenerWebhook(query: string, url: string, queryArgs?: QueryArguments): Promise<DocumentID>;
+    /**
+     * Run the provided query on the device of connected peers and send the
+     * results of the query back to the local peer's data store.
+     *
+     * The returned {@link ExperimentalReplicationSubscription} object must be kept in scope
+     * for as long as you want to keep receiving updates.
+     *
+     * @internal
+     * @param query a Ditto Query Language query string of the form SELECT * FROM
+     * collection WHERE expression
+     * @returns {@link ExperimentalReplicationSubscription} object
+     */
+    addReplicationSubscription(query: string): ExperimentalReplicationSubscription;
     /** @internal */
     close(): void;
     /**
@@ -2757,20 +3019,7 @@ declare class ExperimentalStore {
      * @returns a promise for an array of Ditto documents matching the query
      */
     execute(query: string): Promise<Document[]>;
-    /**
-     * Subscribes the device to updates specified by a DQL query to collections
-     * that other devices know about.
-     *
-     * The returned {@link ExperimentalSubscription} object must be kept in scope
-     * for as long as you want to keep receiving updates.
-     *
-     * @internal
-     * @param query a Ditto Query Language query string of the form SELECT * FROM
-     * collection WHERE expression
-     * @returns {@link ExperimentalSubscription} object
-     */
-    subscribe(query: string): ExperimentalSubscription;
-    private subscriptionManager;
+    private replicationSubscriptionManager;
 }
 
 /**
@@ -2948,6 +3197,11 @@ declare class Store {
      * Returns the collection for the given name. If the collection doesn't
      * exist yet, it will be created automatically as soon as the first
      * entry is inserted.
+     * A collection name is valid if:
+     * * its length is less than 100
+     * * it is not empty
+     * * it does not contain the char '\0'
+     * * it does not begin with "$TS_"
      */
     collection(name: string): Collection;
     /**
@@ -3166,5 +3420,5 @@ declare class CBOR {
     static decode(data: Uint8Array): any;
 }
 
-export { Address, Attachment, AttachmentFetchEvent, AttachmentFetchEventCompleted, AttachmentFetchEventDeleted, AttachmentFetchEventProgress, AttachmentFetchEventType, AttachmentFetcher, AttachmentToken, AuthenticationHandler, AuthenticationStatus, Authenticator, BasePendingCursorOperation, BasePendingIDSpecificOperation, CBOR, Collection, CollectionInterface, CollectionsEvent, CollectionsEventParams, CollectionsObservationHandler, ConditionSource, Connection, ConnectionType, Counter, CustomLogCallback, Ditto, Document, DocumentID, DocumentIDValue, DocumentPath, DocumentValue, ExperimentalStore, ExperimentalSubscription, ExperimentalSubscriptionContextInfo, ExperimentalSubscriptionManager, Identity, IdentityManual, IdentityOfflinePlayground, IdentityOnlinePlayground, IdentityOnlineWithAuthentication, IdentitySharedKey, IdentityTypesRequiringOfflineLicenseToken, InitOptions, KeepAlive, LiveQuery, LiveQueryEvent, LiveQueryEventInitial, LiveQueryEventUpdate, LiveQueryEventUpdateParams, LiveQueryMove, LogLevel, Logger, MutableCounter, MutableDocument, MutableDocumentPath, MutableRegister, NotAvailableAuthenticator, Observer, ObserverOptions, OnlineAuthenticator, Peer, PendingCollectionsOperation, PendingCursorOperation, PendingIDSpecificOperation, Presence, PresenceConnectionType, PresenceGraph, QueryArguments, QueryObservationHandler, Register, RemotePeer, SingleDocumentLiveQueryEvent, SingleObservationHandler, SortDirection, Store, Subscription, TransportCondition, TransportConfig, TransportConfigConnect, TransportConfigGlobal, TransportConfigLan, TransportConfigListen, TransportConfigListenHTTP, TransportConfigListenTCP, TransportConfigPeerToPeer, UpdateResult, UpdateResultType, UpdateResultsMap, UpsertOptions, Value, WebAssemblyModule, WriteStrategy, WriteTransaction, WriteTransactionCollection, WriteTransactionPendingCursorOperation, WriteTransactionPendingIDSpecificOperation, WriteTransactionResult, addressToString, checkAPIs, disableDeadlockTimeoutWhenDebugging, getBridgeLoad, init, validateDocumentIDCBOR, validateDocumentIDValue };
+export { Address, Attachment, AttachmentFetchEvent, AttachmentFetchEventCompleted, AttachmentFetchEventDeleted, AttachmentFetchEventProgress, AttachmentFetchEventType, AttachmentFetcher, AttachmentToken, AuthenticationHandler, AuthenticationStatus, Authenticator, BasePendingCursorOperation, BasePendingIDSpecificOperation, CBOR, ChangeHandler, ChangeHandlerWithSignalNext, Collection, CollectionInterface, CollectionsEvent, CollectionsEventParams, CollectionsObservationHandler, ConditionSource, Connection, ConnectionType, Counter, CustomLogCallback, Ditto, Document, DocumentID, DocumentIDValue, DocumentPath, DocumentValue, ErrorHandler, ExperimentalChangeListener, ExperimentalChangeListenerManager, ExperimentalChangeListenerStatus, ExperimentalReplicationSubscription, ExperimentalReplicationSubscriptionContextInfo, ExperimentalReplicationSubscriptionManager, ExperimentalStore, Identity, IdentityManual, IdentityOfflinePlayground, IdentityOnlinePlayground, IdentityOnlineWithAuthentication, IdentitySharedKey, IdentityTypesRequiringOfflineLicenseToken, InitOptions, KeepAlive, LiveQuery, LiveQueryEvent, LiveQueryEventInitial, LiveQueryEventUpdate, LiveQueryEventUpdateParams, LiveQueryMove, LogLevel, Logger, MutableCounter, MutableDocument, MutableDocumentPath, MutableRegister, NotAvailableAuthenticator, Observer, ObserverOptions, OnlineAuthenticator, Peer, PendingCollectionsOperation, PendingCursorOperation, PendingIDSpecificOperation, Presence, PresenceConnectionType, PresenceGraph, QueryArguments, QueryObservationHandler, Register, RemotePeer, SingleDocumentLiveQueryEvent, SingleObservationHandler, SortDirection, Store, Subscription, TransportCondition, TransportConfig, TransportConfigConnect, TransportConfigGlobal, TransportConfigLan, TransportConfigListen, TransportConfigListenHTTP, TransportConfigListenTCP, TransportConfigPeerToPeer, UpdateResult, UpdateResultType, UpdateResultsMap, UpsertOptions, Value, WebAssemblyModule, WriteStrategy, WriteTransaction, WriteTransactionCollection, WriteTransactionPendingCursorOperation, WriteTransactionPendingIDSpecificOperation, WriteTransactionResult, addressToString, checkAPIs, disableDeadlockTimeoutWhenDebugging, getBridgeLoad, init, transportConfigFromDeserializable, transportConfigToSerializable, validateDocumentIDCBOR, validateDocumentIDValue };
 //# sourceMappingURL=ditto.d.ts.map