@dittolive/ditto 4.10.2 → 4.11.0-preview.2

package/react-native/ios/DittoRNSDK.mm

@@ -1,9 +1,7 @@
 #import <React/RCTBridge+Private.h>
 #import <ReactCommon/CallInvoker.h>
 #import "DittoRNSDK.h"
-#import "TypedArray.hpp"
 #import "main.h"
-#import "YeetJSIUtils.h"
 
 using namespace facebook::jsi;
 
@@ -41,7 +39,7 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
   return @true;
 }
 
-static void install(jsi::Runtime &jsiRuntime) {
+static void install(Runtime &jsiRuntime) {
   auto defaultDeviceName = Function::createFromHostFunction(jsiRuntime,
                                                             PropNameID::forAscii(jsiRuntime,
                                                                                  "defaultDeviceName"),
@@ -51,7 +49,7 @@ static void install(jsi::Runtime &jsiRuntime) {
                                                                const Value *arguments,
                                                                size_t count) -> Value {
 
-    return convertNSStringToJSIString(runtime, [[UIDevice currentDevice] name]);
+    return String::createFromUtf8(runtime, [[[UIDevice currentDevice] name] UTF8String]);
   });
 
   jsiRuntime.global().setProperty(jsiRuntime, "defaultDeviceName", std::move(defaultDeviceName));

package/types/ditto.d.ts

@@ -115,7 +115,7 @@ declare class Observer {
  *
  * @internal
  */
-type FFIResultErrorCode = 'ActivationLicenseTokenExpired' | 'ActivationLicenseTokenInvalid' | 'ActivationLicenseUnsupportedFutureVersion' | 'ActivationNotActivated' | 'ActivationUnnecessary' | 'Base64Invalid' | 'CborInvalid' | 'CborUnsupported' | 'Crdt' | 'DqlEvaluationError' | 'DqlInvalidQueryArgs' | 'DqlQueryCompilation' | 'DqlUnsupported' | 'IoAlreadyExists' | 'IoNotFound' | 'IoOperationFailed' | 'IoPermissionDenied' | 'JsFloatingStoreOperation' | 'LockedDittoWorkingDirectory' | 'ParameterQuery' | 'StoreDatabase' | 'StoreDocumentId' | 'StoreDocumentNotFound' | 'StoreQuery' | 'Transport' | 'Unknown' | 'Unsupported' | 'ValidationDepthLimitExceeded' | 'ValidationInvalidCbor' | 'ValidationInvalidJson' | 'ValidationNotAMap' | 'ValidationInvalidTransportConfig' | 'ValidationSizeLimitExceeded';
+type FFIResultErrorCode = 'ActivationLicenseTokenExpired' | 'ActivationLicenseTokenInvalid' | 'ActivationLicenseUnsupportedFutureVersion' | 'ActivationNotActivated' | 'ActivationUnnecessary' | 'Base64Invalid' | 'CborInvalid' | 'CborUnsupported' | 'Crdt' | 'DifferIdentityKeyPathInvalid' | 'DqlEvaluationError' | 'DqlInvalidQueryArgs' | 'DqlQueryCompilation' | 'DqlUnsupported' | 'IoAlreadyExists' | 'IoNotFound' | 'IoOperationFailed' | 'IoPermissionDenied' | 'JsFloatingStoreOperation' | 'LockedDittoWorkingDirectory' | 'EncryptionExtraneousPassphraseGiven' | 'ParameterQuery' | 'StoreDatabase' | 'StoreDocumentId' | 'StoreDocumentNotFound' | 'StoreTransactionReadOnly' | 'StoreQuery' | 'Transport' | 'Unknown' | 'Unsupported' | 'ValidationDepthLimitExceeded' | 'ValidationInvalidCbor' | 'ValidationInvalidJson' | 'ValidationNotAMap' | 'ValidationInvalidTransportConfig' | 'ValidationSizeLimitExceeded';
 /**
  * Represents an exception that occurred during a call into the Ditto FFI.
  *
@@ -159,8 +159,12 @@ declare const DittoCRDTTypeKey = "_ditto_internal_type_jkb12973t4b";
 /** @internal */
 type FFIAuthenticationStatus = 'dittoffi_authentication_status_t';
 /** @internal */
+type FFIQueryResultItem = 'dittoffi_query_result_item_t';
+/** @internal */
 type FFIQueryResult = 'dittoffi_query_result_t';
 /** @internal */
+type FFIDiffer = 'dittoffi_differ_t';
+/** @internal */
 type FFIWriteTransaction = 'CWriteTransaction_t';
 /** @internal */
 type FFIDitto = 'CDitto_t';
@@ -2117,6 +2121,10 @@ declare class QueryResultItem<T = any> {
     private materializedValue;
     /** @internal */
     constructor();
+    /** @internal */
+    static fromJSON(jsonData: string): QueryResultItem<any>;
+    /** @internal */
+    deref(): Pointer<FFIQueryResultItem>;
 }
 
 /**
@@ -2439,6 +2447,103 @@ declare class PendingCollectionsOperation implements PromiseLike<Collection[]> {
     private readonly pendingCursorOperation;
 }
 
+/**
+ * Defines the interface for executing DQL queries. Implemented by
+ * {@link Store | Store} and {@link Transaction | Transaction}.
+ */
+interface QueryExecuting {
+    /**
+     * Executes a DQL query and returns matching items as a query result.
+     *
+     * **Note:** only returns results from the local store without waiting for any
+     * {@link SyncSubscription | sync subscriptions} to have caught up with the
+     * latest changes. Only use this method if your program must proceed with
+     * immediate results. Use a {@link StoreObserver | store observer} to receive
+     * updates to query results as soon as they have been synced to this peer.
+     *
+     * @param query A string containing a valid query expressed in DQL.
+     * @param args An object of values keyed by the placeholder name
+     * without the leading `:`. Example: `{ "name": "John" }` for a query like
+     * `SELECT * FROM people WHERE name = :name`.
+     * @template T The type of items returned by the query. This is a convenience
+     * type that is neither inferred from the `query` parameter nor validated
+     * against it.
+     * @template U The type of the query arguments
+     * @returns A promise for a {@link QueryResult} containing a
+     * {@link QueryResultItem} for each match.
+     * @throws {@link DittoError} `query/invalid`: if `query` argument is not a
+     * string or not valid DQL.
+     * @throws {@link DittoError} `query/arguments-invalid`: if `args`
+     * argument is invalid (e.g. contains unsupported types).
+     * @throws {@link DittoError} `transaction-read-only`: if a mutating DQL query
+     * was attempted using a read-only transaction. (only for
+     * the `transaction.execute()` API).
+     * @throws {@link DittoError} may throw other errors.
+     */
+    execute<T = any, U extends DQLQueryArguments = DQLQueryArguments>(query: string, args?: U): Promise<QueryResult<T>>;
+}
+
+/**  Encapsulates information about a transaction.
+ *
+ * @see {@link Store.transaction | ditto.store.transaction()}
+ */
+declare class TransactionInfo {
+    /**  A globally unique ID of the transaction. */
+    id: string;
+    /**
+     * The user hint passed when creating the transaction, useful
+     * for debugging and testing.
+     */
+    hint?: string;
+    /**
+     * Indicates whether mutating DQL statements can be executed in the
+     * transaction. Defaults to `false`.
+     */
+    isReadOnly: boolean;
+    constructor(id: string, isReadOnly: boolean, hint?: string);
+}
+/**
+ * Represents an action that completes a transaction, by either committing it or
+ * rolling it back.
+ */
+type TransactionCompletionAction = 'commit' | 'rollback';
+/**
+ * Represents a transaction in the Ditto store.
+ *
+ * A `Transaction` groups multiple operations into a single atomic unit,
+ * ensuring that all operations within the transaction are either fully applied
+ * or not applied at all, thereby maintaining data integrity.
+ *
+ * For more information on creating and using transactions, refer to the
+ * {@link Store.transaction | ditto.store.transaction()} method. For a comprehensive guide on
+ * transactions, please visit the
+ * [Ditto documentation](https://docs.ditto.live/sdk/latest/crud/transactions).
+ */
+declare class Transaction implements QueryExecuting {
+    /**  The store this transaction belongs to. */
+    readonly store: Store;
+    constructor(store: Store);
+    /** Provides information about the current transaction. */
+    get info(): TransactionInfo;
+    execute<T = any, U extends DQLQueryArguments = DQLQueryArguments>(query: string, queryArguments?: U): Promise<QueryResult<T>>;
+    /** @internal */
+    complete(action: TransactionCompletionAction): Promise<TransactionCompletionAction>;
+}
+
+/**
+ * Interface representing options for a transaction.
+ */
+type TransactionOptions = {
+    /**
+     * Indicates whether the transaction is read-only. Defaults to `false`.
+     */
+    isReadOnly?: boolean;
+    /**
+     * A hint for the transaction, useful for debugging and testing.
+     * Defaults to `null`.
+     */
+    hint?: string;
+};
 /**
  * The entrypoint for all actions that relate to data stored by Ditto. Provides
  * access to collections, a write transaction API, and a query hash API.
@@ -2446,7 +2551,7 @@ declare class PendingCollectionsOperation implements PromiseLike<Collection[]> {
  * You don't create one directly but can access it from a particular
  * {@link Ditto} instance via its {@link Ditto.store | store} property.
  */
-declare class Store {
+declare class Store implements QueryExecuting {
     /** The {@link Ditto} instance this store belongs to. */
     readonly ditto: Ditto;
     /**
@@ -2467,6 +2572,8 @@ declare class Store {
      * an existing attachment fetch.
      */
     readonly attachmentFetchers: Readonly<Array<AttachmentFetcher>>;
+    /** @internal */
+    get transactions(): TransactionInfo[];
     /**
      * Register a handler to be called whenever a query's results change in the
      * local store.
@@ -2567,31 +2674,6 @@ declare class Store {
      * @throws {Error} when called in a React Native environment.
      */
     collectionNames(): Promise<string[]>;
-    /**
-     * Executes a DQL query and returns matching items as a query result.
-     *
-     * **Note:** only returns results from the local store without waiting for any
-     * {@link SyncSubscription | sync subscriptions} to have caught up with the
-     * latest changes. Only use this method if your program must proceed with
-     * immediate results. Use a {@link StoreObserver | store observer} to receive
-     * updates to query results as soon as they have been synced to this peer.
-     *
-     * @param query A string containing a valid query expressed in DQL.
-     * @param queryArguments An object of values keyed by the placeholder name
-     * without the leading `:`. Example: `{ "name": "John" }` for a query like
-     * `SELECT * FROM people WHERE name = :name`.
-     * @template T The type of items returned by the query. This is a convenience
-     * type that is neither inferred from the `query` parameter nor validated
-     * against it.
-     * @template U The type of the query arguments
-     * @returns A promise for a {@link QueryResult} containing a
-     * {@link QueryResultItem} for each match.
-     * @throws {@link DittoError} `query/invalid`: if `query` argument is not a
-     * string or not valid DQL.
-     * @throws {@link DittoError} `query/arguments-invalid`: if `queryArguments`
-     * argument is invalid (e.g. contains unsupported types).
-     * @throws {@link DittoError} may throw other errors.
-     */
     execute<T = any, U extends DQLQueryArguments = DQLQueryArguments>(query: string, queryArguments?: U): Promise<QueryResult<T>>;
     /**
      * Initiate a write transaction in a callback.
@@ -2759,13 +2841,91 @@ declare class Store {
      * @internal
      */
     removeAttachmentFetcher(attachmentFetcher: AttachmentFetcher): boolean;
-    /** @internal */
-    close(): void;
     /**
-     * Private method, used only by the Portal https://github.com/getditto/ditto/pull/3652
-     * @internal
+     * Executes multiple DQL queries within a single atomic transaction.
+     *
+     * This ensures that either all statements are executed successfully, or none
+     * are executed at all, providing strong consistency guarantees. Certain mesh
+     * configurations may impose limitations on these guarantees. For more
+     * details, refer to the [Ditto
+     * documentation](https://docs.ditto.live/sdk/latest/crud/transactions).
+     *
+     * Transactions are initiated as read-write by default, and only one
+     * read-write transaction can be executed at any given time. Any other
+     * read-write transaction started concurrently will wait until the current
+     * transaction has been committed or rolled back. Therefore, it is crucial to
+     * ensure a transaction finishes as early as possible to prevent blocking
+     * other read-write transactions.
+     *
+     * A transaction can also be configured to be read-only using the `isReadOnly`
+     * parameter. Multiple read-only transactions can be executed concurrently.
+     * However, executing a mutating DQL statement in a read-only transaction will
+     * throw an error.
+     *
+     * If errors occur in an `execute()` call within a transaction block and the
+     * error is caught and handled within the block, the transaction will continue
+     * to run and not be rolled back. When an error is thrown at any point inside
+     * the transaction block or while committing the transaction, the transaction
+     * is implicitly rolled back, and the error is propagated to the caller.
+     *
+     * When a Ditto instance goes out of scope, it will drive all pending
+     * transactions to completion before being shut down.
+     *
+     * **Warning:** Calling `ditto.store.execute()` or creating a nested
+     * transaction within a transaction may lead to a deadlock.
+     *
+     * The transaction closure provided here can either return a
+     * {@link TransactionCompletionAction} or an arbitrary value, either of which
+     * will then also be returned by the call to this method itself. If one of the
+     * {@link TransactionCompletionAction} values `'commit'` or `'rollback'` is
+     * returned from the closure, that action is applied. If any other value,
+     * including `null`, is returned, the transaction is committed unless an error
+     * is thrown from the closure.
+     *
+     * Example usage (explicit completion):
+     *
+     * ```ts
+     * await store.transaction(async (transaction) => {
+     *   // ...
+     *   return 'commit'
+     * })
+     * ```
+     *
+     * Example usage (returning a custom type):
+     *
+     * ```ts
+     * interface UserData {
+     *   id: string
+     *   name: string
+     * }
+     *
+     * const user: UserData = await store.transaction<UserData>(async (transaction) => {
+     *   // ...
+     *   return { id: 'u1', name: 'Alice' }
+     * })
+     * ```
+     *
+     * @template T The type of the value returned from the `scope` function.
+     * Defaults to `TransactionCompletionAction`.
+     * @param {Function} scope A function that provides access to a transaction
+     * object to execute DQL queries.
+     * @param {TransactionOptions} [options] Optional settings for the
+     * transaction.
+     * @returns {Promise<T>} A promise that resolves to the value returned by the
+     * scope function. If that value is a {@link TransactionCompletionAction}, the
+     * transaction is completed with the same action.
+     * @throws {DittoError} Throws `DittoError` of `store/transaction-read-only`
+     * if a mutating query is executed in a read-only transaction.
+     * @throws {DittoError} May throw other `DittoError`s.
+     * @throws Will rethrow any error thrown within the `scope` function.
+     * @see {@link Transaction}
+     * @see {@link TransactionOptions}
      */
-    registerLiveQueryWebhook(collectionName: string, query: string, url: string): Promise<DocumentID>;
+    transaction<T = TransactionCompletionAction>(scope: (transaction: Transaction) => Promise<T>, options?: TransactionOptions): Promise<T>;
+    /** @internal */
+    beginTransaction(options?: TransactionOptions): Promise<Transaction>;
+    /** @internal */
+    close(): void;
 }
 
 /**
@@ -3338,12 +3498,24 @@ declare class SmallPeerInfo {
      * {@link SmallPeerInfo.metadata | `metadata`}.
      */
     set metadataJSONString(metadata: string);
+    /**
+     * Determines which "kind" of peers the small peer info will be replicated to.
+     *
+     * Defaults to `LocalPeerOnly`, which means no replication. Set this to
+     * `BigPeerOnly` to replicate collected info to the Big Peer.
+     *
+     * @throws when set to a value other than `BigPeerOnly` or `LocalPeerOnly`.
+     */
+    get syncScope(): SmallPeerInfoSyncScope;
+    set syncScope(syncScope: SmallPeerInfoSyncScope);
     /**
      * Determines which "kind" of peers the small peer info will be
      * replicated to.
      *
      * Defaults to `LocalPeerOnly`, which means no replication. Set this to
      * `BigPeerOnly` to replicate collected info to the Big Peer.
+     *
+     * @deprecated use {@link SmallPeerInfo.syncScope} instead.
      */
     getSyncScope(): Promise<SmallPeerInfoSyncScope>;
     /**
@@ -3353,6 +3525,7 @@ declare class SmallPeerInfo {
      *
      * @param syncScope the new sync scope.
      * @throws when set to a value other than `BigPeerOnly` or `LocalPeerOnly`.
+     * @deprecated use {@link SmallPeerInfo.syncScope} instead.
      */
     setSyncScope(syncScope: SmallPeerInfoSyncScope): Promise<void>;
     private ditto;
@@ -3593,8 +3766,12 @@ declare const ERROR_CODES: {
     readonly 'store/crdt': "An error occurred processing a CRDT.";
     /** Error for a document not found. */
     readonly 'store/document-not-found': "The document with the provided ID could not be found.";
+    /** Error for writing to a read-only transaction. */
+    readonly 'store/transaction-read-only': "A mutating DQL query was attempted using a read-only transaction.";
     /** Error for an invalid document ID. */
     readonly 'store/document-id': "The document ID is invalid.";
+    /** Error when the chosen persistence directory is already in use by another Ditto instance. */
+    readonly 'store/persistence-directory-locked': "The chosen persistence directory is already in use by another Ditto instance.";
     /** Permission has been denied for a file operation when working with attachments. */
     readonly 'store/attachment-file-permission-denied': "Permission has been denied for a file operation when working with attachments.";
     /** The source file for an attachment does not exist. */
@@ -3631,6 +3808,15 @@ declare const ERROR_CODES: {
     readonly 'validation/not-json-compatible': "Value is not serializable as JSON.";
     /** A validation error where a size limit was exceeded. */
     readonly 'validation/size-limit-exceeded': "The size limit has been exceeded.";
+    /**
+     * Error when a passphrase was provided but the store is not encrypted.
+     *
+     * This error is not in use for the JavaScript SDK, which currently does not
+     * support encrypted stores.
+     */
+    readonly 'encryption/extraneous-passphrase-given': "Unexpected passphrase provided for the currently unencrypted store.";
+    /** */
+    readonly 'differ/identity-key-path-invalid': "A provided identity key path is invalid.";
 };
 
 /**
@@ -3945,6 +4131,54 @@ declare class NotAvailableAuthenticator extends Authenticator {
     '@ditto.authenticationExpiring'(secondsRemaining: number): never;
 }
 
+/**
+ * Represents a diff between two arrays.
+ *
+ * Create a diff between arrays of {@link QueryResultItem} using a {@link Differ}.
+ */
+declare class Diff {
+    /** The set of indexes in the _new_ array at which new items have been inserted. */
+    readonly insertions: number[];
+    /** The set of indexes in the _old_ array at which old items have been deleted. */
+    readonly deletions: number[];
+    /** The set of indexes in the _new_ array at which items have been updated. */
+    readonly updates: number[];
+    /**
+     * A set of tuples each representing a move of an item `from` a particular
+     * index in the _old_ array `to` a particular index in the _new_ array.
+     */
+    readonly moves: {
+        from: number;
+        to: number;
+    }[];
+    constructor(cborData: Uint8Array);
+}
+/**
+ * Calculates diffs between arrays of {@link QueryResultItem}.
+ *
+ * Use a {@link Differ} with a {@link StoreObserver} to get the diff between
+ * subsequent query results delivered by the store observer.
+ */
+declare class Differ {
+    /** Create a new differ. */
+    constructor();
+    /**
+     * Calculate the diff of the provided items against the last set of items that
+     * were passed to this differ.
+     *
+     * The returned {@link Diff} identifies changes from the old array of items
+     * to the new array of items using indices into both arrays.
+     *
+     * Initially, the differ has no items, so the first call to this method will
+     * always return a diff showing all items as insertions.
+     *
+     * The identity of items is determined by their `_id` field.
+     */
+    diff(items: QueryResultItem<any>[]): Diff;
+    /** @internal */
+    deref(): Pointer<FFIDiffer>;
+}
+
 /**
  * A JavaScript class that identifies a bridge's type and may be  used to create
  * new instances.
@@ -4161,6 +4395,10 @@ declare class Bridge<T extends object, FFIType> {
     /** @internal */
     static readonly queryResultItem: Bridge<QueryResultItem<any>, "dittoffi_query_result_item_t">;
     /** @internal */
+    static readonly transaction: Bridge<Transaction, "dittoffi_transaction_t">;
+    /** @internal */
+    static readonly differ: Bridge<Differ, "dittoffi_differ_t">;
+    /** @internal */
     static readonly ditto: Bridge<Ditto, "CDitto_t">;
     private internalType;
     /**
@@ -5047,5 +5285,5 @@ declare class CBOR {
     static decode(data: Uint8Array, reviver?: (key: any, value: any) => any): any;
 }
 
-export { type Address, Attachment, type AttachmentFetchEvent, type AttachmentFetchEventCompleted, type AttachmentFetchEventDeleted, type AttachmentFetchEventProgress, type AttachmentFetchEventType, AttachmentFetcher, type AttachmentMetadata, AttachmentToken, type AuthenticationHandler, AuthenticationStatus, Authenticator, BasePendingCursorOperation, BasePendingIDSpecificOperation, CBOR, Collection, type CollectionInterface, CollectionsEvent, type CollectionsEventParams, type CollectionsObservationHandler, type ConditionSource, type Connection, ConnectionRequest, type ConnectionRequestAuthorization, type ConnectionRequestHandler, type ConnectionType, Counter, type CustomLogCallback, type DQLQueryArgumentValue, type DQLQueryArguments, Ditto, DittoError, Document, DocumentID, type DocumentIDValue, DocumentPath, type DocumentValue, ERROR_CODES, type ErrorCode, type ErrorContext, type Identity, type IdentityManual, type IdentityOfflinePlayground, type IdentityOnlinePlayground, type IdentityOnlineWithAuthentication, type IdentitySharedKey, IdentityTypesRequiringOfflineLicenseToken, type InitOptions, KeepAlive, LiveQuery, type LiveQueryEvent, LiveQueryEventInitial, LiveQueryEventUpdate, type LiveQueryEventUpdateParams, type LiveQueryMove, type LogLevel, Logger, type LoginResult, MutableCounter, MutableDocument, MutableDocumentPath, MutableRegister, NotAvailableAuthenticator, Observer, type ObserverOptions, OnlineAuthenticator, type Peer, PendingCollectionsOperation, PendingCursorOperation, PendingIDSpecificOperation, Presence, type PresenceConnectionType, type PresenceGraph, type QueryArguments, type QueryObservationHandler, QueryResult, QueryResultItem, Register, type RemotePeer, SingleDocumentLiveQueryEvent, type SingleObservationHandler, SmallPeerInfo, type SmallPeerInfoSyncScope, type SortDirection, Store, type StoreObservationHandler, type StoreObservationHandlerWithSignalNext, StoreObserver, Subscription, Sync, SyncSubscription, type TransportCondition, TransportConfig, type TransportConfigConnect, type TransportConfigGlobal, type TransportConfigLan, type TransportConfigListen, type TransportConfigListenHTTP, type TransportConfigListenTCP, type TransportConfigPeerToPeer, type TypedAttachmentToken, type UntypedAttachmentToken, UpdateResult, type UpdateResultType, UpdateResultsMap, type UpsertOptions, type WebAssemblyModule, type WriteStrategy, WriteTransaction, WriteTransactionCollection, WriteTransactionPendingCursorOperation, WriteTransactionPendingIDSpecificOperation, type WriteTransactionResult, addressToString, checkAPIs, disableDeadlockTimeoutWhenDebugging, getBridgeLoad, init, mapFFIErrors, mapFFIErrorsAsync, transportConfigFromDeserializable, transportConfigToSerializable, validateAttachmentMetadata, validateDocumentIDCBOR, validateDocumentIDValue };
+export { type Address, Attachment, type AttachmentFetchEvent, type AttachmentFetchEventCompleted, type AttachmentFetchEventDeleted, type AttachmentFetchEventProgress, type AttachmentFetchEventType, AttachmentFetcher, type AttachmentMetadata, AttachmentToken, type AuthenticationHandler, AuthenticationStatus, Authenticator, BasePendingCursorOperation, BasePendingIDSpecificOperation, CBOR, Collection, type CollectionInterface, CollectionsEvent, type CollectionsEventParams, type CollectionsObservationHandler, type ConditionSource, type Connection, ConnectionRequest, type ConnectionRequestAuthorization, type ConnectionRequestHandler, type ConnectionType, Counter, type CustomLogCallback, type DQLQueryArgumentValue, type DQLQueryArguments, Diff, Differ, Ditto, DittoError, Document, DocumentID, type DocumentIDValue, DocumentPath, type DocumentValue, ERROR_CODES, type ErrorCode, type ErrorContext, type Identity, type IdentityManual, type IdentityOfflinePlayground, type IdentityOnlinePlayground, type IdentityOnlineWithAuthentication, type IdentitySharedKey, IdentityTypesRequiringOfflineLicenseToken, type InitOptions, KeepAlive, LiveQuery, type LiveQueryEvent, LiveQueryEventInitial, LiveQueryEventUpdate, type LiveQueryEventUpdateParams, type LiveQueryMove, type LogLevel, Logger, type LoginResult, MutableCounter, MutableDocument, MutableDocumentPath, MutableRegister, NotAvailableAuthenticator, Observer, type ObserverOptions, OnlineAuthenticator, type Peer, PendingCollectionsOperation, PendingCursorOperation, PendingIDSpecificOperation, Presence, type PresenceConnectionType, type PresenceGraph, type QueryArguments, type QueryExecuting, type QueryObservationHandler, QueryResult, QueryResultItem, Register, type RemotePeer, SingleDocumentLiveQueryEvent, type SingleObservationHandler, SmallPeerInfo, type SmallPeerInfoSyncScope, type SortDirection, Store, type StoreObservationHandler, type StoreObservationHandlerWithSignalNext, StoreObserver, Subscription, Sync, SyncSubscription, Transaction, type TransactionCompletionAction, TransactionInfo, type TransactionOptions, type TransportCondition, TransportConfig, type TransportConfigConnect, type TransportConfigGlobal, type TransportConfigLan, type TransportConfigListen, type TransportConfigListenHTTP, type TransportConfigListenTCP, type TransportConfigPeerToPeer, type TypedAttachmentToken, type UntypedAttachmentToken, UpdateResult, type UpdateResultType, UpdateResultsMap, type UpsertOptions, type WebAssemblyModule, type WriteStrategy, WriteTransaction, WriteTransactionCollection, WriteTransactionPendingCursorOperation, WriteTransactionPendingIDSpecificOperation, type WriteTransactionResult, addressToString, checkAPIs, disableDeadlockTimeoutWhenDebugging, getBridgeLoad, init, mapFFIErrors, mapFFIErrorsAsync, transportConfigFromDeserializable, transportConfigToSerializable, validateAttachmentMetadata, validateDocumentIDCBOR, validateDocumentIDValue };
 //# sourceMappingURL=ditto.d.ts.map