@dittolive/ditto 4.4.5 → 4.5.1-experimental.aarch64-linux.1.aarch64

package/types/ditto.d.ts

@@ -72,8 +72,8 @@ declare class ObserverManager {
 
 /** @internal */
 interface ObserverManaging {
-    hasObserver(token: ObserverToken): any;
-    removeObserver(token: ObserverToken): any;
+    hasObserver(token: ObserverToken): boolean;
+    removeObserver(token: ObserverToken): void;
 }
 /** @internal */
 type ObserverOptions = {
@@ -89,7 +89,7 @@ declare class Observer {
     /** @internal */
     readonly observerManager: ObserverManaging;
     /** @internal */
-    readonly token?: ObserverToken;
+    get token(): ObserverToken | undefined;
     /** @internal */
     readonly options?: ObserverOptions;
     /** @internal */
@@ -104,9 +104,91 @@ declare class Observer {
      */
     stop(): void;
     private static finalizationRegistry;
+    private _token?;
     private static finalize;
 }
 
+/** Represents a unique identifier for a {@link Document}. */
+type DocumentIDValue = any;
+/** Represents a unique identifier for a {@link Document}. */
+declare class DocumentID {
+    /**
+     * Returns the value of the receiver, lazily decoded from its CBOR
+     * representation if needed.
+     */
+    get value(): any;
+    /**
+     * Returns `false` if validation has been skipped at construction time,
+     * otherwise returns `true`. This is mostly for internal use only, you
+     * shouldn't need this in client code.
+     */
+    readonly isValidated: boolean;
+    /**
+     * Creates a new `DocumentID`.
+     *
+     * A document ID can be created from any of the following:
+     *
+     * - `string`
+     * - `number` (integer)
+     * - `boolean`
+     * - `null`
+     * - raw data in the form of a JS [Typed Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays)
+     * - `Array` (containing any of the items in this list)
+     * - Map (a raw JS `object`, where the keys must be strings and the values
+     *   can be made up of any of the items in this list)
+     *
+     * Note that you cannot use floats or other custom types to create a document
+     * ID.
+     *
+     * Document IDs are also limited in size, based on their serialized
+     * representation, to 256 bytes. You will receive an error if you try to
+     * create a document ID that exceeds the size limit.
+     *
+     * @param value The value that represents the document identifier.
+     * @param skipCBOREncoding If `true, skips CBOR encoding and assumes
+     * the passed in `value` is already CBOR encoded. You shouldn't need to ever
+     * pass this parameter, it's only used internally for certain edge cases.
+     * @param skipValidation If `true, skips validation of the passed in value or
+     * CBOR. You shouldn't need to ever pass this parameter, it's only used
+     * internally for certain edge cases.
+     */
+    constructor(value: any, skipCBOREncoding?: boolean, skipValidation?: boolean);
+    /**
+     * Returns `true` if passed in `documentID` is equal to the receiver,
+     * otherwise returns `false`.
+     */
+    equals(documentID: DocumentID): boolean;
+    /**
+     * Returns a string representation of the receiver.
+     *
+     * If you need a string representation to be used directly in a query,
+     * please use `toQueryCompatibleString()` instead.
+     */
+    toString(): string;
+    /**
+     * Returns a byte representation of the document ID value as base64 string.
+     */
+    toBase64String(): string;
+    /**
+     * Returns a query compatible string representation of the receiver.
+     *
+     * The returned string can be used directly in queries that you use with
+     * other Ditto functions. For example you could create a query that was like
+     * this:
+     *
+     *  ``` TypeScript
+     *  collection.find(`_id == ${documentID.toQueryCompatibleString()}`)
+     *  ```
+     */
+    toQueryCompatibleString(): string;
+    /** @internal */
+    toCBOR(): Uint8Array;
+}
+/** @internal */
+declare function validateDocumentIDValue(id: DocumentIDValue): DocumentIDValue;
+/** @internal */
+declare function validateDocumentIDCBOR(idCBOR: Uint8Array): Uint8Array;
+
 /**
  * Describes the direction when sorting a query.
  */
@@ -139,13 +221,19 @@ type WriteStrategy = 'merge' | 'insertIfAbsent' | 'insertDefaultIfAbsent';
 type QueryArguments = {
     [key: string]: any;
 };
-
-/** @internal */
-declare class Value {
-    readonly value: unknown;
-    readonly isDefault: boolean;
-    constructor(value: unknown, options?: unknown);
-}
+/**
+ * Values to be incorporated into a query, keyed by the placeholder used within
+ * that query.
+ */
+type DQLQueryArguments = {
+    [key: string]: DQLQueryArgumentValue | undefined;
+};
+/**
+ * Individual value in a {@link DQLQueryArguments} object.
+ */
+type DQLQueryArgumentValue = string | number | boolean | Uint8Array | null | DocumentID | DQLQueryArgumentValue[] | {
+    [key: string]: DQLQueryArgumentValue;
+};
 
 /**
  * Represents a CRDT counter that can be upserted as part of a document or
@@ -153,15 +241,16 @@ declare class Value {
  */
 declare class Counter {
     /** The value of the counter. */
-    readonly value: number;
+    get value(): number;
     /**
      * Creates a new counter that can be used as part of a document's content.
      */
     constructor();
     /** @internal */
     static '@ditto.create'(mutDoc: any, path: any, value: any): any;
-    private mutDoc;
-    private path;
+    protected mutDoc: any;
+    protected path: any;
+    protected _value: number;
 }
 /**
  * Represents a mutable CRDT counter that can be incremented by a specific
@@ -181,7 +270,7 @@ declare class MutableCounter extends Counter {
      */
     increment(amount: number): void;
     /** @internal */
-    constructor();
+    protected constructor();
 }
 
 /**
@@ -255,6 +344,8 @@ type Pointer<Type> = {
     addr: string;
 };
 /** @internal */
+type FFIDqlResponse = 'CDqlResponse_t';
+/** @internal */
 type FFIWriteTransaction = 'CWriteTransaction_t';
 /** @internal */
 type OrderBy = {
@@ -301,7 +392,7 @@ declare class Logger {
      * Registers a file path where logs will be written to, whenever Ditto wants
      * to issue a log (on _top_ of emitting the log to the console).
      */
-    static readonly logFile?: string;
+    static get logFile(): string | undefined;
     /**
      * On Node, registers a file path where logs will be written to, whenever
      * Ditto wants to issue a log (on _top_ of emitting the log to the console).
@@ -350,13 +441,15 @@ declare class Logger {
      * {@link setCustomLogCallback | setCustomLogCallback()} for a detailed
      * description.
      */
-    static readonly customLogCallback?: CustomLogCallback;
+    static get customLogCallback(): CustomLogCallback | undefined;
     /**
      * Registers a custom callback that will be called to report each log entry.
      *
      * @param callback function called for each log entry. `undefined` will
      * unregister any previous callback and stop reporting log entries through
      * callbacks.
+     *
+     * @throws {Error} if called in a React Native environment.
      */
     static setCustomLogCallback(callback: CustomLogCallback | undefined): Promise<void>;
     /**
@@ -394,90 +487,11 @@ declare class Logger {
      * {@link LogLevel} `Verbose`.
      */
     static verbose(message: string): void;
+    private static _logFile?;
+    private static _customLogCallback?;
     private constructor();
 }
 
-/** Represents a unique identifier for a {@link Document}. */
-type DocumentIDValue = any;
-/** Represents a unique identifier for a {@link Document}. */
-declare class DocumentID {
-    /**
-     * Returns the value of the receiver, lazily decoded from its CBOR
-     * representation if needed.
-     */
-    get value(): any;
-    /**
-     * Returns `false` if validation has been skipped at construction time,
-     * otherwise returns `true`. This is mostly for internal use only, you
-     * shouldn't need this in client code.
-     */
-    readonly isValidated: boolean;
-    /**
-     * Creates a new `DocumentID`.
-     *
-     * A document ID can be created from any of the following:
-     *
-     * - `string`
-     * - `number` (integer)
-     * - `boolean`
-     * - `null`
-     * - raw data in the form of a JS [Typed Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays)
-     * - `Array` (containing any of the items in this list)
-     * - Map (a raw JS `object`, where the keys must be strings and the values
-     *   can be made up of any of the items in this list)
-     *
-     * Note that you cannot use floats or other custom types to create a document
-     * ID.
-     *
-     * Document IDs are also limited in size, based on their serialized
-     * representation, to 256 bytes. You will receive an error if you try to
-     * create a document ID that exceeds the size limit.
-     *
-     * @param value The value that represents the document identifier.
-     * @param skipCBOREncoding If `true, skips CBOR encoding and assumes
-     * the passed in `value` is already CBOR encoded. You shouldn't need to ever
-     * pass this parameter, it's only used internally for certain edge cases.
-     * @param skipValidation If `true, skips validation of the passed in value or
-     * CBOR. You shouldn't need to ever pass this parameter, it's only used
-     * internally for certain edge cases.
-     */
-    constructor(value: any, skipCBOREncoding?: boolean, skipValidation?: boolean);
-    /**
-     * Returns `true` if passed in `documentID` is equal to the receiver,
-     * otherwise returns `false`.
-     */
-    equals(documentID: DocumentID): boolean;
-    /**
-     * Returns a string representation of the receiver.
-     *
-     * If you need a string representation to be used directly in a query,
-     * please use `toQueryCompatibleString()` instead.
-     */
-    toString(): string;
-    /**
-     * Returns a byte representation of the document ID value as base64 string.
-     */
-    toBase64String(): string;
-    /**
-     * Returns a query compatible string representation of the receiver.
-     *
-     * The returned string can be used directly in queries that you use with
-     * other Ditto functions. For example you could create a query that was like
-     * this:
-     *
-     *  ``` TypeScript
-     *  collection.find(`_id == ${documentID.toQueryCompatibleString()}`)
-     *  ```
-     */
-    toQueryCompatibleString(): string;
-    /** @internal */
-    toCBOR(): Uint8Array;
-}
-/** @internal */
-declare function validateDocumentIDValue(id: DocumentIDValue): DocumentIDValue;
-/** @internal */
-declare function validateDocumentIDCBOR(idCBOR: Uint8Array): Uint8Array;
-
 /**
  * Represents a portion of the document at a specific key-path.
  *
@@ -805,6 +819,9 @@ interface TransportConfigPeerToPeer {
 interface TransportConfigLan {
     isEnabled: boolean;
     isMdnsEnabled: boolean;
+    /**
+     * @deprecated Multicast is deprecated. Please use mDNS instead.
+     */
     isMulticastEnabled: boolean;
 }
 /**
@@ -915,7 +932,7 @@ declare class TransportConfig {
      * Returns `true` if the transport configuration is frozen, otherwise
      * returns `false`.
      */
-    readonly isFrozen: boolean;
+    get isFrozen(): boolean;
     /**
      * (Deep) freezes the receiver such that it can't be modified anymore.
      */
@@ -934,6 +951,7 @@ declare class TransportConfig {
      * returns `false`.
      */
     static areListenHTTPsEqual(left: TransportConfigListenHTTP, right: TransportConfigListenHTTP): boolean;
+    private _isFrozen;
 }
 
 /**
@@ -988,7 +1006,7 @@ interface AuthenticationHandler {
  */
 declare class Authenticator {
     /**
-     * Returns `true` if authentication is avaiable and the login methods can be
+     * Returns `true` if authentication is available and the login methods can be
      * used, otherwise returns `false`. Currently, authentication is only
      * available if Ditto was initialized with an identity of type
      * {@link IdentityOnlineWithAuthentication | 'onlineWithAuthentication'}.
@@ -997,7 +1015,7 @@ declare class Authenticator {
     /**
      Returns the current authentication status.
      */
-    readonly status: AuthenticationStatus;
+    get status(): AuthenticationStatus;
     /**
      * Log in to Ditto with a third-party token. Throws if authentication is not
      * available, which can be checked with {@link loginSupported}.
@@ -1027,7 +1045,7 @@ declare class Authenticator {
      * [Ditto] instance as the sole argument that allows you to perform any
      * required cleanup of the store as part of the logout process.
      */
-    logout(cleanupFn?: (Ditto: any) => void): Promise<void>;
+    logout(cleanupFn?: (ditto: Ditto) => void): Promise<void>;
     observeStatus(callback: (authenticationStatus: AuthenticationStatus) => void): Observer;
     /** @internal */
     constructor(keepAlive: KeepAlive);
@@ -1041,12 +1059,15 @@ declare class Authenticator {
     protected keepAlive: KeepAlive;
     /** @internal */
     protected observerManager: ObserverManager;
+    /** @internal */
+    protected _status: AuthenticationStatus;
 }
 /** @internal */
 declare class OnlineAuthenticator extends Authenticator {
+    readonly loginSupported: boolean;
     loginWithToken(token: string, provider: string): Promise<void>;
     loginWithUsernameAndPassword(username: string, password: string, provider: string): Promise<void>;
-    logout(cleanupFn?: (Ditto: any) => void): Promise<void>;
+    logout(cleanupFn?: (ditto: Ditto) => void): Promise<void>;
     readonly authenticationHandler: AuthenticationHandler;
     private ditto;
     constructor(keepAlive: KeepAlive, ditto: Ditto, authenticationHandler: AuthenticationHandler);
@@ -1056,194 +1077,57 @@ declare class OnlineAuthenticator extends Authenticator {
 }
 /** @internal */
 declare class NotAvailableAuthenticator extends Authenticator {
-    loginWithToken(token: string, provider: string): Promise<void>;
-    loginWithUsernameAndPassword(username: string, password: string, provider: string): Promise<void>;
-    logout(cleanupFn?: (Ditto: any) => void): Promise<void>;
-    '@ditto.authenticationExpiring'(secondsRemaining: any): void;
-    '@ditto.authClientValidityChanged'(isWebValid: boolean, isX509Valid: boolean): void;
+    loginWithToken(token: string, provider: string): Promise<never>;
+    loginWithUsernameAndPassword(username: string, password: string, provider: string): Promise<never>;
+    logout(cleanupFn?: (ditto: Ditto) => void): Promise<never>;
+    '@ditto.authenticationExpiring'(secondsRemaining: number): never;
+    '@ditto.authClientValidityChanged'(isWebValid: boolean, isX509Valid: boolean): never;
 }
 
+/** Types of connections that can be established between two peers. */
+type ConnectionType = 'P2PWiFi' | 'WebSocket' | 'AccessPoint' | 'Bluetooth';
 /**
- * An identity to be used while in development when you want to control the app
- * name and the site ID of the peer.
+ * An opaque address uniquely identifying another peer on the Ditto mesh
+ * network.
+ *
+ * IMPORTANT: You should not rely on the individual components of the address,
+ * those can change at any time. Please use
+ * {@link addressToString | addressToString()} to compare individual addresses
+ * with each other.
  */
-interface IdentityOfflinePlayground {
-    type: 'offlinePlayground';
-    /**
-     * The app ID for the Ditto instance.
-     */
-    appID: string;
-    /**
-     * The `siteID` needs to be an unsigned 64 bit integer >= 0, i.e. either a
-     * regular non-fractional `number` or a `BigInt` in the range between 0 and
-     * 2^64 - 1 (inclusive). If `siteID` is `0`, Ditto will generate an
-     * appropriate site ID and persist it when needed. Default is `0`.
-     */
-    siteID?: number | BigInt;
-}
+type Address = {
+    siteId: number | BigInt;
+    pubkey: Uint8Array;
+};
 /**
- * An identity with intermediate level of security where all users and devices
- * are trusted and a single shared secret (key) between all peers satisfies the
- * security requirements.
- *
- * **NOTE**: This identity type is only supported for Node environments, using
- * this to create a Ditto instance in the web browser will throw an exception.
+ * Returns a string representation of the given address. Use this function
+ * to compare multiple addresses or whenever you need the address to be a key
+ * in a hash object.
  */
-interface IdentitySharedKey {
-    type: 'sharedKey';
-    /**
-     * The app ID for the Ditto instance.
+declare function addressToString(address: Address): string;
+/** Represents a connection between two peers on the Ditto mesh network. */
+type 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"
      */
-    appID: string;
+    id: string;
+    /** Type of transport enabling this connection. */
+    connectionType: ConnectionType;
     /**
-     * The `siteID` needs to be an unsigned 64 bit integer >= 0, i.e. either a
-     * regular non-fractional `number` or a `BigInt` in the range between 0 and
-     * 2^64 - 1 (inclusive). If `siteID` is `0`, Ditto will generate an
-     * appropriate site ID and persist it when needed. Default is `0`.
+     * Peer key of the peer at one end of the connection.
+     *
+     * This peer key is lexicographically smaller than `peer2`.
      */
-    siteID?: number | BigInt;
+    peer1: Uint8Array;
     /**
-     * A base64 encoded DER representation of a private key, which is shared
-     * between devices for a single app.
-     */
-    sharedKey: string;
-}
-/**
- * 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';
-    certificate: string;
-}
-/**
- * Test a Ditto Cloud app with weak shared token authentication ("Playground
- * mode"). This mode is not secure and must only be used for development.
- */
-interface IdentityOnlinePlayground {
-    type: 'onlinePlayground';
-    /**
-     * An ID identifying this app registration on the Ditto portal, which can be
-     * found at https://portal.ditto.live.
-     */
-    appID: string;
-    /**
-     * A shared token used to set up the OnlinePlayground session. This token is
-     * provided by the Ditto Portal when setting up the application.
-     */
-    token: string;
-    /** If true, auto-configure sync with Ditto Cloud. Default is `true`. */
-    enableDittoCloudSync?: boolean;
-    /**
-     * If specified, use a custom authentication service instead of Ditto Cloud.
-     * @internal
-     */
-    customAuthURL?: string;
-    /**
-     * A custom Ditto Cloud URL.
-     * @internal
-     */
-    customDittoCloudURL?: string;
-}
-/**
- * Run Ditto in secure production mode, logging on to Ditto Cloud or an
- * on-premises authentication server. User permissions are centrally managed.
- * Sync will not work until a successful login has occurred.
- *
- * The only required configuration is the application's UUID, which can be found
- * on the Ditto portal where the app is registered.
- *
- * By default cloud sync is enabled. This means the SDK will sync to a Big Peer
- * in Ditto's cloud when an internet connection is available. This is controlled
- * by the `enableCloudSync` parameter. If `true` (default), a suitable wss://
- * URL will be added to the `TransportConfig`. To prevent cloud sync, or to
- * specify your own URL later, pass `false`.
- *
- * Authentication requests are handled by Ditto's cloud by default, configured
- * in the portal at https://portal.ditto.live.
- *
- * To use a different or on-premises authentication service, pass a custom HTTPS
- * base URL as the `customAuthUrl` parameter.
- */
-interface IdentityOnlineWithAuthentication {
-    type: 'onlineWithAuthentication';
-    /**
-     * An ID identifying this app registration on the Ditto portal, which can be
-     * found at https://portal.ditto.live.
-     */
-    appID: string;
-    /**
-     * If true, auto-configure sync with Ditto Cloud. Default is `true`.
-     */
-    enableDittoCloudSync?: boolean;
-    /**
-     * A handler for when Ditto requires (re)authentication.
-     */
-    authHandler: AuthenticationHandler;
-    /**
-     * If specified, use a custom authentication service instead of Ditto Cloud.
-     */
-    customAuthURL?: string;
-    /**
-     * A custom Ditto Cloud URL.
-     * @internal
-     */
-    customDittoCloudURL?: string;
-}
-/**
- * The various identity configurations that you can use when initializing a
- * `Ditto` instance.
- */
-type Identity = IdentityOfflinePlayground | IdentitySharedKey | IdentityManual | IdentityOnlinePlayground | IdentityOnlineWithAuthentication;
-/** The list of identity types that require activation through an offlineLicenseToken */
-declare const IdentityTypesRequiringOfflineLicenseToken: string[];
-
-/** Types of connections that can be established between two peers. */
-type ConnectionType = 'P2PWiFi' | 'WebSocket' | 'AccessPoint' | 'Bluetooth';
-/**
- * An opaque address uniquely identifying another peer on the Ditto mesh
- * network.
- *
- * IMPORTANT: You should not rely on the individual components of the address,
- * those can change at any time. Please use
- * {@link addressToString | addressToString()} to compare individual addresses
- * with each other.
- */
-type Address = {
-    siteId: number | BigInt;
-    pubkey: Uint8Array;
-};
-/**
- * Returns a string representation of the given address. Use this function
- * to compare multiple addresses or whenever you need the address to be a key
- * in a hash object.
- */
-declare function addressToString(address: Address): string;
-/** Represents a connection between two peers on the Ditto mesh network. */
-type 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. */
-    connectionType: ConnectionType;
-    /**
-     * Peer key of the peer at one end of the connection.
-     *
-     * This peer key is lexicographically smaller than `peer2`.
-     */
-    peer1: Uint8Array;
-    /**
-     * Peer key of the peer at the other end of the connection.
-     *
-     * This peer key is lexicographically larger than `peer1`.
+     * Peer key of the peer at the other end of the connection.
+     *
+     * This peer key is lexicographically larger than `peer1`.
      */
     peer2: Uint8Array;
     approximateDistanceInMeters?: number;
@@ -1400,7 +1284,7 @@ declare class Subscription {
      * Returns `true` if subscription has been explicitly cancelled, `false`
      * otherwise.
      */
-    readonly isCancelled = false;
+    get isCancelled(): boolean;
     /**
      * The name of the collection that the subscription is based on.
      */
@@ -1416,8 +1300,6 @@ declare class Subscription {
      * @internal Because not exposed in any of the other SDKs (yet?).
      */
     readonly collection: Collection;
-    /** @internal */
-    private readonly manager;
     /**
      * The corresponding named arguments for {@link query}, if any.
      * @internal Because not exposed in any of the other SDKs (yet?).
@@ -1425,6 +1307,8 @@ declare class Subscription {
     readonly queryArgsCBOR: Uint8Array | null;
     /** @internal */
     readonly contextInfo: SubscriptionContextInfo;
+    private readonly manager;
+    private _isCancelled;
 }
 
 /**
@@ -1711,14 +1595,19 @@ declare class LiveQuery {
     readonly collection: Collection;
     /** @internal */
     readonly handler: QueryObservationHandler;
-    /** @internal */
+    /**
+     * This field is only populated while a live query is active and set to null
+     * when the live query is stopped.
+     *
+     * @internal
+     */
     liveQueryManager: LiveQueryManager | null;
-    /** @internal */
-    readonly liveQueryID: number;
+    get liveQueryID(): number;
     /** @internal */
     constructor(query: string, queryArgs: QueryArguments | null, queryArgsCBOR: Uint8Array | null, orderBys: OrderBy[], limit: number, offset: number, collection: Collection, handler: QueryObservationHandler);
     /** @internal */
     signalNext(): Promise<void>;
+    private _liveQueryID;
 }
 
 /** @internal */
@@ -1740,128 +1629,417 @@ declare class LiveQueryManager {
 }
 
 /**
- * The types of attachment fetch events that can be delivered to an attachment
- * fetcher's `callback`.
- */
-type AttachmentFetchEventType = 'Completed' | 'Progress' | 'Deleted';
-/**
- * An attachment fetch event used when the attachment's download has completed.
- */
-type AttachmentFetchEventCompleted = {
-    type: 'Completed';
-    attachment: Attachment;
-};
-/**
- * An attachment fetch event used when the attachment's download progressed but
- * is not yet complete.
- */
-type AttachmentFetchEventProgress = {
-    type: 'Progress';
-    totalBytes: number | BigInt;
-    downloadedBytes: number | BigInt;
-};
-/**
- * An attachment fetch event used when the attachment is deleted.
- */
-type AttachmentFetchEventDeleted = {
-    type: 'Deleted';
-};
-/**
- * A representation of the events that can occur in relation to an attachment
- * fetch.
- *
- * There are three different attachment fetch events: `Completed`, `Progress`,
- * or `Deleted`.
+ * A sync subscription configures Ditto to receive updates from remote peers
+ * about documents matching the subscription's query.
  *
- * There will be at most one `Completed` or `Deleted` event per attachment
- * fetch. There can be many `Progress` events delivered for each attachment
- * fetch.
+ * The sync subscription will remain active until it is
+ * {@link SyncSubscription.cancel | cancelled}, or the Ditto instance managing
+ * the subscription has been {@link Ditto.close | closed}.
  *
- * Updates relating to an attachment fetch are delivered by registering an
- * {@link AttachmentFetcher} through a call to
- * {@link Collection.fetchAttachment | fetchAttachment()} on a
- * {@link Collection} instance.
- */
-type AttachmentFetchEvent = AttachmentFetchEventCompleted | AttachmentFetchEventProgress | AttachmentFetchEventDeleted;
-
-/**
- * These objects are returned by calls to
- * {@link Collection.fetchAttachment | fetchAttachment()} on {@link Collection}
- * and allow you to stop an in-flight attachment fetch.
+ * Create a sync subscription by calling
+ * {@link Sync.registerSubscription | `ditto.sync.registerSubscription()`}.
  */
-declare class AttachmentFetcher implements PromiseLike<Attachment | null> {
+declare class SyncSubscription {
     /**
-     * Returns a promise for the attachment that you can `await`. The promise
-     * resolves to either an attachment or `null` if the attachment has been
-     * deleted meanwhile. The promise is rejected if an error occurs during
-     * the fetch. Note that the `AttachmentFetcher` itself implementes
-     * `PromiseLike`, so you can `await` it directly.
+     * Documents matching this query will be included in the sync subscription.
      */
-    readonly attachment: Promise<Attachment | null>;
+    readonly queryString: string;
     /**
-     * Stops fetching the associated attachment and cleans up any associated
-     * resources.
-     *
-     * Note that you are not required to call `stop()` once your attachment fetch
-     * operation has finished. The method primarily exists to allow you to cancel
-     * an attachment fetch request while it is ongoing if you no longer wish for
-     * the attachment to be made available locally to the device.
+     * The query arguments of the sync subscription (as passed when
+     * adding it to the store).
      */
-    stop(): void;
-    /** @internal */
-    readonly cancelTokenPromise: Promise<unknown | null> | null;
-    /** @internal */
-    readonly ditto: Ditto;
-    /** @internal */
-    readonly id: string;
-    /** @internal */
-    readonly manager: AttachmentFetcherManager;
-    /** @internal */
-    readonly token: AttachmentToken;
-    /** @internal */
-    then<TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): PromiseLike<TResult1 | TResult2>;
-    /** @internal */
-    constructor(ditto: Ditto, token: AttachmentToken, manager: AttachmentFetcherManager, eventHandler?: (attachmentFetchEvent: AttachmentFetchEvent) => void);
+    readonly queryArguments?: Readonly<DQLQueryArguments>;
     /**
-     * This function is defined while a fetch is in progress and is used to reject
-     * the promise `this.attachment` when the fetch is canceled.
-     *
-     * @internal
+     * The {@link Ditto} instance this sync subscription belongs to.
      */
-    private rejectPendingFetch;
-}
-
-/**
- * Manages attachment fetchers to make sure we free all resources when the
- * fetcher is garbage collected and to allow us to wait for freeing of
- * ressources to be finished before the ditto instance is closed.
- *
- * @internal */
-declare class AttachmentFetcherManager {
     readonly ditto: Ditto;
-    /** @internal */
-    constructor(ditto: Ditto);
     /**
-     * Start an attachment fetcher.
-     *
-     * @internal */
-    startAttachmentFetcher(token: AttachmentToken, eventHandler?: (attachmentFetchEvent: AttachmentFetchEvent) => void): AttachmentFetcher;
+     * `true` when the sync subscription has been cancelled or the {@link Ditto}
+     * instance managing this subscription has been closed.
+     */
+    get isCancelled(): boolean;
     /**
-     * Stop an attachment fetcher and wait for it to be stopped.
-     *
-     * @internal */
-    stopAttachmentFetcher(attachmentFetcher: AttachmentFetcher): Promise<void>;
+     * Cancels the sync subscription and unregisters it. No-op
+     * if the sync subscription has already been cancelled or the {@link Ditto}
+     * instance managing this subscription has been closed.
+     */
+    cancel(): void;
+    /** @internal */
+    constructor(ditto: Ditto, query: string, queryArguments: DQLQueryArguments | null, queryArgumentsCBOR: Uint8Array | null);
     /**
-     * Closing the manager will cancel all attachment fetchers.
+     * The CBOR-encoded query arguments, or `null` if no query arguments were
+     * passed in.
      *
      * @internal
      */
-    close(): void;
-    private contextInfoByID;
-    private finalizationRegistry;
+    readonly queryArgumentsCBOR: Uint8Array | null;
     /**
-     * Stop the attachment fetcher without unregistering it from the finalization
-     * registry.
+     * `true` when the ssync ubscription has been cancelled.
+     *
+     * We mark the sync subscription as cancelled here as an optimization to avoid
+     * a scan of all subscriptions in the store whenever the `isCancelled`
+     * property is checked.
+     */
+    private _isCancelled;
+}
+
+/**
+ * An identity to be used while in development when you want to control the app
+ * name and the site ID of the peer.
+ */
+interface IdentityOfflinePlayground {
+    type: 'offlinePlayground';
+    /**
+     * The app ID for the Ditto instance.
+     */
+    appID: string;
+    /**
+     * The `siteID` needs to be an unsigned 64 bit integer >= 0, i.e. either a
+     * regular non-fractional `number` or a `BigInt` in the range between 0 and
+     * 2^64 - 1 (inclusive). If `siteID` is `0`, Ditto will generate an
+     * appropriate site ID and persist it when needed. Default is `0`.
+     */
+    siteID?: number | BigInt;
+}
+/**
+ * An identity with intermediate level of security where all users and devices
+ * are trusted and a single shared secret (key) between all peers satisfies the
+ * security requirements.
+ *
+ * **NOTE**: This identity type is only supported for Node environments, using
+ * this to create a Ditto instance in the web browser will throw an exception.
+ */
+interface IdentitySharedKey {
+    type: 'sharedKey';
+    /**
+     * The app ID for the Ditto instance.
+     */
+    appID: string;
+    /**
+     * The `siteID` needs to be an unsigned 64 bit integer >= 0, i.e. either a
+     * regular non-fractional `number` or a `BigInt` in the range between 0 and
+     * 2^64 - 1 (inclusive). If `siteID` is `0`, Ditto will generate an
+     * appropriate site ID and persist it when needed. Default is `0`.
+     */
+    siteID?: number | BigInt;
+    /**
+     * A base64 encoded DER representation of a private key, which is shared
+     * between devices for a single app.
+     */
+    sharedKey: string;
+}
+/**
+ * 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';
+    certificate: string;
+}
+/**
+ * Test a Ditto Cloud app with weak shared token authentication ("Playground
+ * mode"). This mode is not secure and must only be used for development.
+ */
+interface IdentityOnlinePlayground {
+    type: 'onlinePlayground';
+    /**
+     * An ID identifying this app registration on the Ditto portal, which can be
+     * found at https://portal.ditto.live.
+     */
+    appID: string;
+    /**
+     * A shared token used to set up the OnlinePlayground session. This token is
+     * provided by the Ditto Portal when setting up the application.
+     */
+    token: string;
+    /** If true, auto-configure sync with Ditto Cloud. Default is `true`. */
+    enableDittoCloudSync?: boolean;
+    /**
+     * If specified, use a custom authentication service instead of Ditto Cloud.
+     * @internal
+     */
+    customAuthURL?: string;
+    /**
+     * A custom Ditto Cloud URL.
+     * @internal
+     */
+    customDittoCloudURL?: string;
+}
+/**
+ * Run Ditto in secure production mode, logging on to Ditto Cloud or an
+ * on-premises authentication server. User permissions are centrally managed.
+ * Sync will not work until a successful login has occurred.
+ *
+ * The only required configuration is the application's UUID, which can be found
+ * on the Ditto portal where the app is registered.
+ *
+ * By default cloud sync is enabled. This means the SDK will sync to a Big Peer
+ * in Ditto's cloud when an internet connection is available. This is controlled
+ * by the `enableCloudSync` parameter. If `true` (default), a suitable wss://
+ * URL will be added to the `TransportConfig`. To prevent cloud sync, or to
+ * specify your own URL later, pass `false`.
+ *
+ * Authentication requests are handled by Ditto's cloud by default, configured
+ * in the portal at https://portal.ditto.live.
+ *
+ * To use a different or on-premises authentication service, pass a custom HTTPS
+ * base URL as the `customAuthUrl` parameter.
+ */
+interface IdentityOnlineWithAuthentication {
+    type: 'onlineWithAuthentication';
+    /**
+     * An ID identifying this app registration on the Ditto portal, which can be
+     * found at https://portal.ditto.live.
+     */
+    appID: string;
+    /**
+     * If true, auto-configure sync with Ditto Cloud. Default is `true`.
+     */
+    enableDittoCloudSync?: boolean;
+    /**
+     * A handler for when Ditto requires (re)authentication.
+     */
+    authHandler: AuthenticationHandler;
+    /**
+     * If specified, use a custom authentication service instead of Ditto Cloud.
+     */
+    customAuthURL?: string;
+    /**
+     * A custom Ditto Cloud URL.
+     * @internal
+     */
+    customDittoCloudURL?: string;
+}
+/**
+ * The various identity configurations that you can use when initializing a
+ * `Ditto` instance.
+ */
+type Identity = IdentityOfflinePlayground | IdentitySharedKey | IdentityManual | IdentityOnlinePlayground | IdentityOnlineWithAuthentication;
+/** The list of identity types that require activation through an offlineLicenseToken */
+declare const IdentityTypesRequiringOfflineLicenseToken: string[];
+
+/** @internal */
+type SyncParameters = {
+    readonly isSyncActive: boolean;
+    readonly isX509Valid: boolean;
+    readonly isWebValid: boolean;
+    readonly ditto: Ditto;
+    readonly identity: Identity;
+    readonly transportConfig: TransportConfig;
+};
+/** @internal */
+type SyncState = {
+    readonly underlyingSyncParameters: SyncParameters;
+    readonly effectiveTransportConfig: TransportConfig;
+};
+/**
+ * Provides access to sync related functionality of Ditto.
+ *
+ * Access this object via {@link Ditto.sync | Ditto.sync} on any Ditto instance.
+ */
+declare class Sync {
+    /**
+     * The {@link Ditto} instance managed by this sync object.
+     */
+    readonly ditto: Ditto;
+    /**
+     * All currently active sync subscriptions.
+     *
+     * **Note:** Manage sync subscriptions using
+     * {@link registerSubscription | registerSubscription()} to register a new
+     * sync subscription and
+     * {@link SyncSubscription.cancel | SyncSubscription.cancel()} to remove an
+     * existing sync subscription.
+     */
+    readonly subscriptions: Readonly<Array<SyncSubscription>>;
+    /**
+     * Installs and returns a sync subscription for a query, configuring Ditto to
+     * receive updates from other peers for documents matching that query. The
+     * passed in query must be a `SELECT` query, otherwise an error is thrown.
+     *
+     * @param query a string containing a valid query expressed in DQL.
+     * @param queryArguments an object containing the arguments for the query.
+     * Example: `{mileage: 123}` for a query with `:mileage` placeholder.
+     * @returns An active `SyncSubscription` for the passed in query and
+     * arguments. It will remain active until it is
+     * {@link SyncSubscription.cancel | cancelled} or the {@link Ditto} instance
+     * managing the sync subscription has been closed.
+     * @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} `query/unsupported`: if the query is not a
+     * `SELECT` query.
+     * @throws {@link DittoError} may throw other errors.
+     */
+    registerSubscription(query: string, queryArguments?: DQLQueryArguments): SyncSubscription;
+    /** @internal */
+    get parameters(): SyncParameters;
+    /** @internal */
+    constructor(ditto: Ditto);
+    /**
+     * Removes the passed in `syncSubscription`, configuring Ditto to not receive
+     * updates for documents matching the corresponding query anymore. No-op if
+     * the passed in `syncSubscription` has already been removed.
+     *
+     * This must only be called by the sync subscription itself.
+     *
+     * @param syncSubscription the sync subscription to remove
+     * @returns `true` if the passed in sync subscription could be found and has
+     * been removed, otherwise returns `false`.
+     * @throws {@link DittoError} `internal`: if the replication subscription does not
+     * belong to this store
+     * @throws {@link DittoError} `internal`: if the replication subscription has not
+     * been cancelled yet
+     * @internal
+     */
+    unregisterSubscription(syncSubscription: SyncSubscription): boolean;
+    /** @internal */
+    update(parameters: SyncParameters): void;
+    /** @internal */
+    close(): void;
+    private state;
+    private bluetoothLETransportPointer;
+    private awdlTransportPointer;
+    private lanTransportPointer;
+    private mdnsClientTransportPointer;
+    private mdnsServerAdvertiserPointer;
+    private updatePeerToPeerBluetoothLE;
+    private updatePeerToPeerAWDL;
+    private updatePeerToPeerLAN;
+    private updateListenTCP;
+    private updateListenHTTP;
+    private updateConnectTCPServers;
+    private updateConnectWebsocketURLs;
+    private updateGlobal;
+    private updateConnectRetryInterval;
+}
+
+/**
+ * The types of attachment fetch events that can be delivered to an attachment
+ * fetcher's `callback`.
+ */
+type AttachmentFetchEventType = 'Completed' | 'Progress' | 'Deleted';
+/**
+ * An attachment fetch event used when the attachment's download has completed.
+ */
+type AttachmentFetchEventCompleted = {
+    type: 'Completed';
+    attachment: Attachment;
+};
+/**
+ * An attachment fetch event used when the attachment's download progressed but
+ * is not yet complete.
+ */
+type AttachmentFetchEventProgress = {
+    type: 'Progress';
+    totalBytes: number | BigInt;
+    downloadedBytes: number | BigInt;
+};
+/**
+ * An attachment fetch event used when the attachment is deleted.
+ */
+type AttachmentFetchEventDeleted = {
+    type: 'Deleted';
+};
+/**
+ * A representation of the events that can occur in relation to an attachment
+ * fetch.
+ *
+ * There are three different attachment fetch events: `Completed`, `Progress`,
+ * or `Deleted`.
+ *
+ * There will be at most one `Completed` or `Deleted` event per attachment
+ * fetch. There can be many `Progress` events delivered for each attachment
+ * fetch.
+ *
+ * Updates relating to an attachment fetch are delivered by registering an
+ * {@link AttachmentFetcher} through a call to
+ * {@link Collection.fetchAttachment | fetchAttachment()} on a
+ * {@link Collection} instance.
+ */
+type AttachmentFetchEvent = AttachmentFetchEventCompleted | AttachmentFetchEventProgress | AttachmentFetchEventDeleted;
+
+/**
+ * These objects are returned by calls to
+ * {@link Collection.fetchAttachment | fetchAttachment()} on {@link Collection}
+ * and allow you to stop an in-flight attachment fetch.
+ */
+declare class AttachmentFetcher implements PromiseLike<Attachment | null> {
+    /**
+     * Returns a promise for the attachment that you can `await`. The promise
+     * resolves to either an attachment or `null` if the attachment has been
+     * deleted meanwhile. The promise is rejected if an error occurs during
+     * the fetch. Note that the `AttachmentFetcher` itself implementes
+     * `PromiseLike`, so you can `await` it directly.
+     */
+    readonly attachment: Promise<Attachment | null>;
+    /**
+     * Stops fetching the associated attachment and cleans up any associated
+     * resources.
+     *
+     * Note that you are not required to call `stop()` once your attachment fetch
+     * operation has finished. The method primarily exists to allow you to cancel
+     * an attachment fetch request while it is ongoing if you no longer wish for
+     * the attachment to be made available locally to the device.
+     */
+    stop(): void;
+    /** @internal */
+    readonly cancelTokenPromise: Promise<unknown | null> | null;
+    /** @internal */
+    readonly ditto: Ditto;
+    /** @internal */
+    readonly id: string;
+    /** @internal */
+    readonly manager: AttachmentFetcherManager;
+    /** @internal */
+    readonly token: AttachmentToken;
+    /** @internal */
+    then<TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): PromiseLike<TResult1 | TResult2>;
+    /** @internal */
+    constructor(ditto: Ditto, token: AttachmentToken, manager: AttachmentFetcherManager, eventHandler?: (attachmentFetchEvent: AttachmentFetchEvent) => void);
+    /**
+     * This function is defined while a fetch is in progress and is used to reject
+     * the promise `this.attachment` when the fetch is canceled.
+     *
+     * @internal
+     */
+    private rejectPendingFetch;
+}
+
+/**
+ * Manages attachment fetchers to make sure we free all resources when the
+ * fetcher is garbage collected and to allow us to wait for freeing of
+ * ressources to be finished before the ditto instance is closed.
+ *
+ * @internal */
+declare class AttachmentFetcherManager {
+    readonly ditto: Ditto;
+    /** @internal */
+    constructor(ditto: Ditto);
+    /**
+     * Start an attachment fetcher.
+     *
+     * @internal */
+    startAttachmentFetcher(token: AttachmentToken, eventHandler?: (attachmentFetchEvent: AttachmentFetchEvent) => void): AttachmentFetcher;
+    /**
+     * Stop an attachment fetcher and wait for it to be stopped.
+     *
+     * @internal */
+    stopAttachmentFetcher(attachmentFetcher: AttachmentFetcher): Promise<void>;
+    /**
+     * Closing the manager will cancel all attachment fetchers.
+     *
+     * @internal
+     */
+    close(): void;
+    private contextInfoByID;
+    private finalizationRegistry;
+    /**
+     * Stop the attachment fetcher without unregistering it from the finalization
+     * registry.
      */
     private stopWithContextInfo;
 }
@@ -1876,19 +2054,21 @@ declare class AttachmentFetcherManager {
  */
 type SmallPeerInfoSyncScope = 'LocalPeerOnly' | 'BigPeerOnly';
 /**
- * The entrypoint for small peer user info collection. Small peer info consists of information
- * gathered into a system collection on a regular interval and optionally synced to the Big Peer
- * for device dashboard and debugging purposes.
+ * The entrypoint for small peer user info collection. Small peer info consists
+ * of information gathered into a system collection on a regular interval and
+ * optionally synced to the Big Peer for device dashboard and debugging
+ * purposes.
  *
- * You don't create this class directly, but can access it from a particular `Ditto`
- * instance via its {@link Ditto.smallPeerInfo | `smallPeerInfo`} property.
+ * An instance of this class is available on each `Ditto` instance via its
+ * {@link Ditto.smallPeerInfo | `smallPeerInfo`} property. Instantiating this
+ * class directly is not supported.
  */
 declare class SmallPeerInfo {
     /**
      * Indicates whether small peer info collection is currently enabled, defaults
      * to `false`.
      *
-     * Note: whether the background ingestion process is enabled or not is a
+     * **Note**: whether the background ingestion process is enabled or not is a
      * separate decision to whether this information is allowed to sync to other
      * peers (including the big peer). This is controlled by
      * {@link getSyncScope | getSyncScope()} and
@@ -1901,6 +2081,60 @@ declare class SmallPeerInfo {
      * @throws when set to a non-boolean value.
      */
     set isEnabled(newValue: boolean);
+    /**
+     * The metadata associated with the small peer info.
+     *
+     * Small peer info metadata is a free-form, user-provided JSON object that
+     * is inserted into the small peer info system document at each collection
+     * interval.
+     */
+    get metadata(): Record<string, any>;
+    /**
+     * Set the metadata associated with the small peer info.
+     *
+     * The metadata must be a JSON-serializable object that conforms to the
+     * following constraints:
+     *
+     * - Must be a JSON object (not an array, string, number, etc.)
+     * - The size when encoded as JSON must be less than 128 KB
+     * - May only be nested up to 2 levels deep
+     *
+     * @example <caption>Valid metadata</caption>
+     * ditto.smallPeerInfo.metadata = {
+     *  "foo": "bar",
+     *  "nested": {
+     *    "inner": "value"
+     *   }
+     * }
+     *
+     * @example <caption>Invalid metadata</caption>
+     * // This is invalid and results in an error.
+     * ditto.smallPeerInfo.metadata = {
+     *   "foo": "bar",
+     *   "nested": {
+     *     "illegal": {
+     *       "inner": "value"
+     *     }
+     *   }
+     * }
+     *
+     * @throws when set to a value that violates any of the constraints listed
+     * above.
+     */
+    set metadata(metadata: Record<string, any>);
+    /**
+     * The metadata associated with the small peer info, as a JSON string.
+     */
+    get metadataJSONString(): string;
+    /**
+     * Set the metadata associated with the small peer info, as a JSON string.
+     *
+     * @see {@link SmallPeerInfo.metadata | `metadata`} for more information on
+     * valid values.
+     * @throws when set to a value that violates any of the constraints listed in
+     * {@link SmallPeerInfo.metadata | `metadata`}.
+     */
+    set metadataJSONString(metadata: string);
     /**
      * Determines which "kind" of peers the small peer info will be
      * replicated to.
@@ -1947,6 +2181,10 @@ type RemotePeer = {
  * Ditto is the entry point for accessing Ditto-related functionality.
  */
 declare class Ditto {
+    /**
+     * A string containing the semantic version of the Ditto SDK. Example: 4.4.3
+     */
+    static get VERSION(): string;
     /**
      * Configure a custom identifier for the current device.
      *
@@ -1982,6 +2220,10 @@ declare class Ditto {
      * Provides access to the SDK's store functionality.
      */
     readonly store: Store;
+    /**
+     * Provides access to the SDK's sync functionality.
+     */
+    readonly sync: Sync;
     /**
      * Provides access to the SDK's presence functionality.
      */
@@ -2003,18 +2245,18 @@ declare class Ditto {
      *
      * @see {@link setOfflineOnlyLicenseToken | setOfflineOnlyLicenseToken()}
      */
-    readonly isActivated: boolean;
+    get isActivated(): boolean;
     /**
      * `true` once {@link close | Ditto.close()} has been called, otherwise
      * `false`.
      */
-    readonly isClosed: boolean;
+    get isClosed(): boolean;
     /**
      * Returns `true` if sync is active, otherwise returns `false`. Use
      * {@link startSync | startSync()} to activate and
      * {@link stopSync | stopSync()} to deactivate sync.
      */
-    readonly isSyncActive: boolean;
+    get isSyncActive(): boolean;
     /**
      * Application ID associated with the {@link Identity | identity} used by this
      * Ditto instance.
@@ -2036,6 +2278,9 @@ declare class Ditto {
      *
      * @see {@link Ditto.identity}
      * @see {@link Ditto.persistenceDirectory}
+     * @throws {Error} when the current environment is not supported by this SDK.
+     * @throws {Error} for other failures during initialization of Ditto and
+     * validation of the provided identity.
      */
     constructor(identity?: Identity, persistenceDirectory?: string);
     /**
@@ -2102,6 +2347,8 @@ declare class Ditto {
      *
      * @param licenseToken the license token to activate the `Ditto` instance
      * with. You can find yours on the [Ditto portal](https://portal.ditto.live).
+     *
+     * @throws {Error} if called in a React Native environment.
      */
     setOfflineOnlyLicenseToken(licenseToken: string): void;
     /**
@@ -2115,7 +2362,7 @@ declare class Ditto {
      * @see {@link setTransportConfig | setTransportConfig()}
      * @see {@link updateTransportConfig | updateTransportConfig()}
      */
-    readonly transportConfig: TransportConfig;
+    get transportConfig(): TransportConfig;
     /**
      * Assigns a new transports configuration. By default peer-to-peer transports
      * (Bluetooth, WiFi, and AWDL) are enabled. You may use this method to alter
@@ -2212,6 +2459,8 @@ declare class Ditto {
      * peers using SDKs in the v4 (or higher) series of releases. Note that this
      * disabling of sync spreads to peers that sync with a peer that has disabled,
      * or has (transitively) had disabled, syncing with v3 SDK peers.
+     *
+     * @throws {Error} if called in a React Native environment.
      */
     disableSyncWithV3(): void;
     /**
@@ -2256,12 +2505,14 @@ declare class Ditto {
      * @throws if the Ditto instance was closed before calling this method.
      * @internal */
     deferCloseAsync<T>(closure: () => Promise<T>): Promise<T>;
-    private sync;
     private deferCloseAllowed;
     private isWebValid;
     private isX509Valid;
     private presenceManager;
     private transportConditionsManager;
+    private _isActivated;
+    private _isSyncActive;
+    private _isClosed;
     /** Set of pending operations that need to complete before the Ditto instance can be closed in a safe manner. */
     private pendingOperations;
     private authClientValidityChanged;
@@ -2277,7 +2528,7 @@ declare class Ditto {
  * @returns `true` iff all required APIs exist on `global`.
  * @internal
  */
-declare const checkAPIs: (_globalObject?: Window | typeof globalThis) => boolean;
+declare const checkAPIs: (_globalObject?: typeof globalThis) => boolean;
 /**
  * Disable deadlock timeout when Node.js is running with `--inspect` parameter.
  *
@@ -2585,503 +2836,362 @@ declare class Collection implements CollectionInterface {
     findByIDCBOR(idCBOR: Uint8Array): PendingIDSpecificOperation;
 }
 
-/** @internal */
-interface CollectionsEventParams {
-    isInitial: boolean;
-    collections: Collection[];
-    oldCollections: Collection[];
-    insertions: number[];
-    deletions: number[];
-    updates: number[];
-    moves: LiveQueryMove[];
-}
 /**
- * Provides information about the changes that have occurred in relation to an
- * event delivered when observing the collections in a {@link Store}.
+ * Represents a single match of a DQL query, similar to a “row” in SQL terms.
+ * It’s a reference type serving as a “cursor”, allowing for efficient access of
+ * the underlying data in various formats.
  *
- * It contains information about the collections that are known about as well as
- * the collections that were previously known about in the previous event, along
- * with information about what collections have been inserted, deleted, updated,
- * or moved since the last event.
+ * The {@link QueryResultItem.value | value } property is lazily
+ * materialized and kept in memory until it goes out of scope. To reduce the
+ * memory footprint, structure your code such that items can be processed as a
+ * stream, i.e. one by one (or in batches) and
+ * {@link QueryResultItem.dematerialize | dematerialize() } them
+ * right after use.
  */
-declare class CollectionsEvent {
-    /**
-     * Indicates whether or not this is the first event to be delivered when
-     * observing collections in the store.
-     */
-    readonly isInitial: boolean;
+declare class QueryResultItem {
     /**
-     * A list of all of the known collections.
+     * Returns the content as a materialized object.
+     *
+     * The item's value is
+     * {@link QueryResultItem.materialize | materialized() } on first access
+     * and subsequently on each access after performing
+     * {@link QueryResultItem.dematerialize | dematerialize() }. Once
+     * materialized, the value is kept in memory until explicitly
+     * {@link QueryResultItem.dematerialize | dematerialize() }-ed or the item
+     * goes out of scope.
+     *
+     * Note: This property is very similar to {@link Document.value}.
      */
-    readonly collections: Collection[];
+    get value(): any;
     /**
-     * A list of all of the known collections at the time the previous event was
-     * delivered.
+     * Returns `true` if value is currently held materialized in memory, otherwise
+     * returns `false`.
+     *
+     * See {@link QueryResultItem.materialize | materialize()} and
+     * {@link QueryResultItem.dematerialize | dematerialize()}.
      */
-    readonly oldCollections: Collection[];
+    get isMaterialized(): boolean;
     /**
-     * A list of the indexes in the list of currently known about collections at
-     * which new collections have been inserted.
+     * Loads the CBOR representation of the item's content, decodes it as an
+     * object so it can be accessed via {@link QueryResultItem.value | value }.
+     * Keeps the object in memory until
+     * {@link QueryResultItem.dematerialize | dematerialize() } is called. No-op
+     * if {@link QueryResultItem.value | value } is already materialized.
      */
-    readonly insertions: number[];
+    materialize(): void;
     /**
-     * A list of the indexes in the list of previously known about collections at
-     * which collections have been removed.
+     * Releases the materialized value from memory. No-op if item is not
+     * materialized.
      */
-    readonly deletions: number[];
+    dematerialize(): void;
     /**
-     * A list of the indexes in the list of currently known about collections at
-     * which pre-existing collections have been updated.
+     * Returns the content of the item as CBOR data.
+     *
+     * Important: The returned CBOR data is not cached, make sure to call this
+     * method once and keep it for as long as needed.
      */
-    readonly updates: number[];
+    cborData(): Uint8Array;
     /**
-     * A list of the tuples that provides the indexes, in relation to the list of
-     * previously known about collections, that already known about collections
-     * have moved from and the indexes, in relation to the list of currently known
-     * about collections, that the collections have moved to.
+     * Returns the content of the item as a JSON string.
+     *
+     * Important: The returned JSON string is not cached, make sure to call this
+     * method once and keep it for as long as needed.
      */
-    readonly moves: LiveQueryMove[];
-    /** @internal */
-    static initial(collections: Collection[]): CollectionsEvent;
+    jsonString(): string;
+    private materializedValue;
     /** @internal */
-    constructor(params: CollectionsEventParams);
+    constructor();
 }
 
 /**
- * The closure that is called whenever the collections covered by a live query
- * change.
- */
-type CollectionsObservationHandler = (event: CollectionsEvent, signalNext?: () => void) => void | Promise<void>;
-/**
- * These objects are returned when calling
- * {@link Store.collections | collections()} on {@link Store}.
- *
- * They allow chaining of further collections-related functions. You can either
- * call {@link exec | exec()} on the object to get an array of
- * {@link Collection}s as an immediate return value, or you can establish either
- * a live query or a subscription, which both work over time.
- *
- * A live query, established by calling
- * {@link PendingCollectionsOperation.observeLocal | observeLocal()}, will
- * notify you every time there's a change in the collections that the device
- * knows about.
+ * Represents results returned when executing a DQL query containing a
+ * {@link QueryResultItem} for each match.
  *
- * A subscription, established by calling {@link subscribe | subscribe()}, will
- * act as a signal to other peers that the device connects to that you would
- * like to receive updates from them about the collections that they know about.
+ * More info, such as metrics, will be provided in the near future.
  */
-declare class PendingCollectionsOperation implements PromiseLike<Collection[]> {
-    /**
-     * Sort the collections based on a property of the collection.
-     *
-     * @param propertyPath The property path specifies the logic to be used when
-     * sorting the matching collections.
-     *
-     * @param direction Specify whether you want the sorting order to be
-     * `Ascending` or `Descending`.
-     *
-     * @return A {@link PendingCollectionsOperation} that you can chain further
-     * function calls to.
-     */
-    sort(propertyPath: string, direction?: SortDirection): PendingCollectionsOperation;
-    /**
-     * Offset the resulting set of collections.
-     *
-     * This is useful if you aren't interested in the first N collections for one
-     * reason or another. For example, you might already have obtained the first
-     * 20 collections and so you might want to get the next 20 collections, and
-     * that is when you would use {@link offset | offset()}.
-     *
-     * @param offset The number of collections that you want the eventual
-     * resulting set of collections to be offset by (and thus not include).
-     *
-     * @return A {@link PendingCollectionsOperation} that you can chain further
-     * function calls to.
-     */
-    offset(offset: number): PendingCollectionsOperation;
-    /**
-     * Limit the number of collections that get returned.
-     *
-     * @param limit The maximum number of collections that will be returned.
-     *
-     * @return A {@link PendingCollectionsOperation} that you can chain further
-     * function calls to.
-     */
-    limit(limit: number): PendingCollectionsOperation;
-    /**
-     * Subscribes the device to updates about collections that other devices know
-     * about.
-     *
-     * The returned {@link Subscription} object must be kept in scope for as long
-     * as you want to keep receiving updates.
-     *
-     * @return A {@link Subscription} object that must be kept in scope for as
-     * long as you want to keep receiving updates from other devices about the
-     * collections that they know about.
-     */
-    subscribe(): Subscription;
+declare class QueryResult {
     /**
-     * Enables you to listen for changes that occur in relation to the collections
-     * that are known about locally.
-     *
-     * The returned {@link LiveQuery} object must be kept in scope for as long as
-     * you want the provided `handler` to be called when an update occurs.
-     *
-     * This won't subscribe to receive updates from other devices and so it will
-     * only fire when a local change to the known about collections occurs. If
-     * you want to receive remote updates as well, then create a subscription via
-     * {@link PendingCollectionsOperation.subscribe | subscribe()}.
-     *
-     * @param handler A closure that will be called every time there is an update
-     * about the list of known about collections.
-     *
-     * @return A {@link LiveQuery} object that must be kept in scope for as long
-     * as you want to keep receiving updates.
+     * Individual items matching a DQL query.
      */
-    observeLocal(handler: CollectionsObservationHandler): LiveQuery;
+    readonly items: QueryResultItem[];
     /**
-     * Enables you to listen for changes that occur in relation to the collections
-     * that are known about locally.
+     * IDs of documents that were mutated _locally_ by a _mutating_ DQL query
+     * passed to {@link Store.execute | `execute()`}. Empty array if no documents
+     * have been mutated.
      *
-     * The returned {@link LiveQuery} object must be kept in scope for as long as
-     * you want the provided `handler` to be called when an update occurs.
-     *
-     * This won't subscribe to receive updates from other devices and so it will
-     * only fire when a local change to the known about collections occurs. If
-     * you want to receive remote updates as well, then create a subscription via
-     * {@link PendingCollectionsOperation.subscribe | subscribe()}.
-     *
-     * @param handler A closure that will be called every time there is an update
-     * about the list of known about collections.
+     * **Note: Query results received from a {@link StoreObserver} never contain
+     * mutated document IDs because a store observer is always registered using a
+     * non-mutating `SELECT` query.
      *
-     * @return A {@link LiveQuery} object that must be kept in scope for as long
-     * as you want to keep receiving updates.
-     */
-    observeLocalWithNextSignal(handler: CollectionsObservationHandler): LiveQuery;
-    /**
-     * Return the list of collections requested based on the preceding function
-     * chaining.
+     * **Important:** The returned document IDs are not cached, make sure to call
+     * this method once and keep the return value for as long as needed.
      *
-     * @return A list of {@link Collection}s based on the preceding function
-     * chaining.
+     * @returns an array of document IDs
      */
-    exec(): Promise<Collection[]>;
-    /** @internal */
-    readonly store: Store;
-    /** @internal */
-    constructor(store: Store);
+    mutatedDocumentIDs(): DocumentID[];
     /** @internal */
-    then<TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): PromiseLike<TResult1 | TResult2>;
-    /** @internal */
-    _observe(handler: CollectionsObservationHandler, waitForNextSignal: boolean): LiveQuery;
-    private readonly pendingCursorOperation;
+    constructor(responsePointer: Pointer<FFIDqlResponse>);
 }
 
 /**
- * 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.
+ * A store observation handler is called whenever an active store observer
+ * receives new results.
+ */
+type StoreObservationHandler = (queryResult: QueryResult) => void;
+/**
+ * A store observation handler is called whenever an active store observer
+ * receives new results.
  *
- * @internal
+ * Call `signalNext()` to signal that the handler is ready to receive the next
+ * callback from the store observer.
  */
-type ExperimentalChangeListenerStatus = 'active' | 'stopped';
+type StoreObservationHandlerWithSignalNext = (queryResult: QueryResult, signalNext: () => void) => void;
 /**
- * A change listener invokes a change handler whenever results for its query
+ * A store observer invokes a given handler whenever results for its query
  * change.
  *
- * Create a listener by calling
- * {@link ExperimentalStore.addChangeListener | `ditto.store.experimental.addChangeListener()`}.
+ * The store observer will remain active until it is {@link cancel | cancelled},
+ * or the Ditto instance managing the observer has been
+ * {@link Ditto.close | closed}.
  *
- * @internal
+ * Create a store observer by calling
+ * {@link Store.registerObserver | `ditto.store.registerObserver()`}.
  */
-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;
+declare class StoreObserver {
     /**
-     * Stops the listener from receiving any more updates.
+     * The Ditto instance this store observer is registered with.
      */
-    stop(): void;
+    readonly ditto: Ditto;
     /**
-     * The ID of this listener's live query.
-     *
-     * @internal
+     * The query string of the store observer (as passed when registering it).
      */
-    readonly liveQueryID: number;
-    /**
-     * Closes the listener, preventing it from receiving any more updates.
-     *
-     * @internal
-     * */
-    close(): void;
-    private store;
-    private _status;
+    readonly queryString: string;
     /**
-     * Signals to Ditto Core that the listener is ready for the next event.
+     * The query arguments of the store observer (as passed when registering it).
      */
-    private signalNext;
+    readonly queryArguments?: Readonly<DQLQueryArguments>;
     /**
-     * Creates bridged arguments for the user's change handler from the raw C callback arguments.
+     * Convenience property, returns `true` once the store observer has been
+     * cancelled.
      */
-    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);
+    get isCancelled(): boolean;
     /**
-     * Register and start a change listener in core, also registering it in the listener manager.
-     *
-     * @internal
+     * Cancels the store observer and unregisters it. No-op if the
+     * store observer has already been cancelled.
      */
-    addChangeListener(listener: ExperimentalChangeListener): void;
+    cancel(): void;
     /**
-     * Mark all change listeners as closed while deferring the closing of Ditto.
+     * The ID of this observer's live query.
      *
      * @internal
      */
-    close(): void;
+    readonly liveQueryID: number;
+    /** @internal */
+    constructor(ditto: Ditto, query: string, queryArguments: DQLQueryArguments | null, observationHandler: StoreObservationHandlerWithSignalNext);
     /**
-     * Remove a change listener from the listener manager and stop it in core.
+     * `true` when the store observer has been cancelled.
      *
-     * @internal
-     * @param listener The change listener to remove.
+     * We mark the store observer as cancelled here as an optimization to avoid a
+     * scan of all store observers in the store whenever the `isCancelled`
+     * property is checked.
      */
-    removeChangeListener(listener: ExperimentalChangeListener): void;
-    private readonly ditto;
-    private readonly keepAlive;
-    private readonly listenersById;
+    private _isCancelled;
     /**
-     * Keeps track of change listeners by live query ID.
+     * Signals to Ditto Core that the observer is ready for the next event.
      */
-    private readonly finalizationRegistry;
-    /**
-     * Remove a change listener without unregistering it from the finalization registry.
-     */
-    private stopLiveQuery;
+    private signalNext;
 }
 
+/** @internal */
+interface CollectionsEventParams {
+    isInitial: boolean;
+    collections: Collection[];
+    oldCollections: Collection[];
+    insertions: number[];
+    deletions: number[];
+    updates: number[];
+    moves: LiveQueryMove[];
+}
 /**
- * Manages `ExperimentalReplicationSubscription` instances and removes them when Ditto is
- * closed.
+ * Provides information about the changes that have occurred in relation to an
+ * event delivered when observing the collections in a {@link Store}.
  *
- * @internal
+ * It contains information about the collections that are known about as well as
+ * the collections that were previously known about in the previous event, along
+ * with information about what collections have been inserted, deleted, updated,
+ * or moved since the last event.
  */
-declare class ExperimentalReplicationSubscriptionManager {
-    constructor(ditto: Ditto);
-    /**
-     * Begin tracking a replication subscription instance and start it.
-     *
-     * @internal
-     */
-    addSubscription(subscription: ExperimentalReplicationSubscription): void;
+declare class CollectionsEvent {
     /**
-     * Stop tracking a replication subscription instance and cancel it.
-     *
-     * @internal
+     * Indicates whether or not this is the first event to be delivered when
+     * observing collections in the store.
      */
-    removeSubscription(subscription: ExperimentalReplicationSubscription): void;
+    readonly isInitial: boolean;
     /**
-     * Stop tracking all replication subscriptions and cancel them.
-     *
-     * @internal
+     * A list of all of the known collections.
      */
-    close(): void;
-    private readonly ditto;
-    private subscriptions;
-    private finalizationRegistry;
+    readonly collections: Collection[];
     /**
-     * Remove tracked replication subscription without unregistering from
-     * finalization registry.
+     * A list of all of the known collections at the time the previous event was
+     * delivered.
      */
-    private removeWithContextInfo;
-}
-
-/**
- * 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 ExperimentalReplicationSubscriptionContextInfo = {
-    /** Unique ID per `ExperimentalSubscription` instance. */
-    id: string;
-    query: string;
-    queryArgsCBOR: Uint8Array | null;
-};
-/**
- * Create a replication subscription to receive updates from remote peers about
- * documents matching the replication subscription's query.
- *
- * 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 ExperimentalReplicationSubscription {
+    readonly oldCollections: Collection[];
     /**
-     * Documents matching this query will be included in the replication subscription.
+     * A list of the indexes in the list of currently known about collections at
+     * which new collections have been inserted.
      */
-    readonly query: string;
+    readonly insertions: number[];
     /**
-     * `true` when {@link cancel | cancel()} has been called or the Ditto instance
-     * managing this replication subscription has been closed.
+     * A list of the indexes in the list of previously known about collections at
+     * which collections have been removed.
      */
-    readonly isCancelled = false;
+    readonly deletions: number[];
     /**
-     * Cancels a replication subscription and releases all associated resources.
+     * A list of the indexes in the list of currently known about collections at
+     * which pre-existing collections have been updated.
      */
-    cancel(): void;
-    /** @internal */
-    constructor(manager: ExperimentalReplicationSubscriptionManager, query: string, queryArgsCBOR: Uint8Array | null);
-    /** @internal */
-    contextInfo: ExperimentalReplicationSubscriptionContextInfo;
+    readonly updates: number[];
     /**
-     * The corresponding named arguments for {@link query}, if any.
-     *
-     * @internal
+     * A list of the tuples that provides the indexes, in relation to the list of
+     * previously known about collections, that already known about collections
+     * have moved from and the indexes, in relation to the list of currently known
+     * about collections, that the collections have moved to.
      */
-    readonly queryArgsCBOR: Uint8Array | null;
+    readonly moves: LiveQueryMove[];
     /** @internal */
-    private manager;
+    static initial(collections: Collection[]): CollectionsEvent;
+    /** @internal */
+    constructor(params: CollectionsEventParams);
 }
 
 /**
- * An addon for the Ditto store that contains experimental features. Accessible
- * on `ditto.store.experimental`.
+ * The closure that is called whenever the collections covered by a live query
+ * change.
+ */
+type CollectionsObservationHandler = (event: CollectionsEvent, signalNext?: () => void) => void | Promise<void>;
+/**
+ * These objects are returned when calling
+ * {@link Store.collections | collections()} on {@link Store}.
  *
- * @internal
+ * They allow chaining of further collections-related functions. You can either
+ * call {@link exec | exec()} on the object to get an array of
+ * {@link Collection}s as an immediate return value, or you can establish either
+ * a live query or a subscription, which both work over time.
+ *
+ * A live query, established by calling
+ * {@link PendingCollectionsOperation.observeLocal | observeLocal()}, will
+ * notify you every time there's a change in the collections that the device
+ * knows about.
+ *
+ * A subscription, established by calling {@link subscribe | subscribe()}, will
+ * act as a signal to other peers that the device connects to that you would
+ * like to receive updates from them about the collections that they know about.
  */
-declare class ExperimentalStore {
-    /**
-     * The {@link Ditto} instance this store belongs to.
-     * @internal
-     * */
-    readonly ditto: Ditto;
-    /** @internal */
-    readonly listenerManager: ExperimentalChangeListenerManager;
-    /** @internal */
-    constructor(ditto: Ditto);
+declare class PendingCollectionsOperation implements PromiseLike<Collection[]> {
     /**
-     * Register a handler to be called whenever a query's results change in the
-     * local store.
+     * Sort the collections based on a property of the collection.
+     *
+     * @param propertyPath The property path specifies the logic to be used when
+     * sorting the matching collections.
      *
-     * The returned {@link ExperimentalChangeListener} must be kept in scope for
-     * as long as the change handler should be called with new change events.
+     * @param direction Specify whether you want the sorting order to be
+     * `Ascending` or `Descending`.
      *
-     * The given query may not modify any documents and must be a valid Ditto
-     * Query Language query.
+     * @return A {@link PendingCollectionsOperation} that you can chain further
+     * function calls to.
+     */
+    sort(propertyPath: string, direction?: SortDirection): PendingCollectionsOperation;
+    /**
+     * Offset the resulting set of collections.
      *
-     * If no `onError` argument is provided, errors that are thrown in the
-     * provided change handler will be logged to the console.
+     * This is useful if you aren't interested in the first N collections for one
+     * reason or another. For example, you might already have obtained the first
+     * 20 collections and so you might want to get the next 20 collections, and
+     * that is when you would use {@link offset | offset()}.
      *
-     * 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.
+     * @param offset The number of collections that you want the eventual
+     * resulting set of collections to be offset by (and thus not include).
      *
-     * @internal
+     * @return A {@link PendingCollectionsOperation} that you can chain further
+     * function calls to.
      */
-    addChangeListener(query: string, onChange: ChangeHandler, onError?: ErrorHandler, queryArgs?: QueryArguments): ExperimentalChangeListener;
+    offset(offset: number): PendingCollectionsOperation;
     /**
-     * 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.
+     * Limit the number of collections that get returned.
      *
-     * Otherwise identical to
-     * {@link ExperimentalStore.addChangeListener | addChangeListener()}.
+     * @param limit The maximum number of collections that will be returned.
      *
-     * @internal
+     * @return A {@link PendingCollectionsOperation} that you can chain further
+     * function calls to.
      */
-    addChangeListenerWithSignalNext(query: string, onChange: ChangeHandlerWithSignalNext, onError?: ErrorHandler, queryArgs?: QueryArguments): ExperimentalChangeListener;
+    limit(limit: number): PendingCollectionsOperation;
     /**
-     * Registers a URL to be called whenever the given query observes changes.
+     * Subscribes the device to updates about collections that other devices know
+     * about.
      *
-     * This API will stay internal-only as it is only used in the portal.
+     * The returned {@link Subscription} object must be kept in scope for as long
+     * as you want to keep receiving updates.
      *
-     * @internal
-     * @returns a promise for a document id that acts as a webhook id
+     * @return A {@link Subscription} object that must be kept in scope for as
+     * long as you want to keep receiving updates from other devices about the
+     * collections that they know about.
      */
-    addChangeListenerWebhook(query: string, url: string, queryArgs?: QueryArguments): Promise<DocumentID>;
+    subscribe(): Subscription;
     /**
-     * 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.
+     * Enables you to listen for changes that occur in relation to the collections
+     * that are known about locally.
      *
-     * The returned {@link ExperimentalReplicationSubscription} object must be kept in scope
-     * for as long as you want to keep receiving updates.
+     * The returned {@link LiveQuery} object must be kept in scope for as long as
+     * you want the provided `handler` to be called when an update occurs.
      *
-     * @internal
-     * @param query a Ditto Query Language query string of the form SELECT * FROM
-     * collection WHERE expression
-     * @returns {@link ExperimentalReplicationSubscription} object
+     * This won't subscribe to receive updates from other devices and so it will
+     * only fire when a local change to the known about collections occurs. If
+     * you want to receive remote updates as well, then create a subscription via
+     * {@link PendingCollectionsOperation.subscribe | subscribe()}.
+     *
+     * @param handler A closure that will be called every time there is an update
+     * about the list of known about collections.
+     *
+     * @return A {@link LiveQuery} object that must be kept in scope for as long
+     * as you want to keep receiving updates.
      */
-    addReplicationSubscription(query: string): ExperimentalReplicationSubscription;
-    /** @internal */
-    close(): void;
+    observeLocal(handler: CollectionsObservationHandler): LiveQuery;
     /**
-     * Executes the given query in the local store and returns the result.
+     * Enables you to listen for changes that occur in relation to the collections
+     * that are known about locally.
+     *
+     * The returned {@link LiveQuery} object must be kept in scope for as long as
+     * you want the provided `handler` to be called when an update occurs.
      *
-     * Limitations:
+     * This won't subscribe to receive updates from other devices and so it will
+     * only fire when a local change to the known about collections occurs. If
+     * you want to receive remote updates as well, then create a subscription via
+     * {@link PendingCollectionsOperation.subscribe | subscribe()}.
      *
-     * - Supports `SELECT * FROM <collection name>` with optional `WHERE
-     *   <expression>`
-     * - No query parameters as function arguments yet
-     * - No transactions
+     * @param handler A closure that will be called every time there is an update
+     * about the list of known about collections.
      *
-     * @internal
-     * @param query a Ditto Query Language query string
-     * @returns a promise for an array of Ditto documents matching the query
+     * @return A {@link LiveQuery} object that must be kept in scope for as long
+     * as you want to keep receiving updates.
+     */
+    observeLocalWithNextSignal(handler: CollectionsObservationHandler): LiveQuery;
+    /**
+     * Return the list of collections requested based on the preceding function
+     * chaining.
+     *
+     * @return A list of {@link Collection}s based on the preceding function
+     * chaining.
      */
-    execute(query: string): Promise<Document[]>;
-    private replicationSubscriptionManager;
+    exec(): Promise<Collection[]>;
+    /** @internal */
+    readonly store: Store;
+    /** @internal */
+    constructor(store: Store);
+    /** @internal */
+    then<TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): PromiseLike<TResult1 | TResult2>;
+    /** @internal */
+    _observe(handler: CollectionsObservationHandler, waitForNextSignal: boolean): LiveQuery;
+    private readonly pendingCursorOperation;
 }
 
 /**
@@ -3253,8 +3363,77 @@ declare class WriteTransaction {
 declare class Store {
     /** The {@link Ditto} instance this store belongs to. */
     readonly ditto: Ditto;
-    /** @internal */
-    readonly experimental: ExperimentalStore;
+    /**
+     * All currently active store observers.
+     *
+     * **Note:** Manage store observers using
+     * {@link registerObserver | registerObserver()} to register a new store
+     * observer and {@link StoreObserver.cancel | StoreObserver.cancel()} to
+     * remove an existing store observer.
+     */
+    readonly observers: Readonly<Array<StoreObserver>>;
+    /**
+     * Register a handler to be called whenever a query's results change in the
+     * local store.
+     *
+     * Convenience method, same as
+     * {@link registerObserverWithSignalNext | registerObserverWithSignalNext()},
+     * except that here, the next invocation of the observation handler is
+     * triggered automatically instead of having to call the passed in
+     * `signalNext` function.
+     *
+     * @param query a string containing a valid query expressed in DQL.
+     * @param observationHandler a function that is called whenever the query's results
+     * change. The function is passed a {@link QueryResult} containing a
+     * {@link QueryResultItem} for each match.
+     * @param queryArguments an object of values keyed by the placeholder name
+     * without the leading `:`. Example: `{ "name": "Joanna" }` for a query like
+     * `SELECT * FROM people WHERE name = :name`.
+     * @returns a {@link StoreObserver} that can be used to cancel the
+     * observation.
+     * @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} `query/unsupported`: if the query is not a
+     * `SELECT` query.
+     * @throws {@link DittoError} may throw other errors.
+     */
+    registerObserver(query: string, observationHandler: StoreObservationHandler, queryArguments?: DQLQueryArguments): StoreObserver;
+    /**
+     * Registers and returns a store observer for a query, configuring Ditto to
+     * trigger the passed in observation handler whenever documents in the local
+     * store change such that the result of the matching query changes. The passed
+     * in query must be a `SELECT` query.
+     *
+     * Here, a function is passed as an additional argument to the observation
+     * handler. Call this function as soon as the observation handler is ready to
+     * process the the next change event. This allows the observation handler to
+     * control how frequently it is called. See
+     * {@link registerObserver | registerObserver()} for a convenience method that
+     * automatically signals the next invocation.
+     *
+     * The first invocation of `observationHandler` will always happen after this
+     * method has returned.
+     *
+     * @param query a string containing a valid query expressed in DQL.
+     * @param observationHandler an observation handler function that is called
+     * whenever the query's results change. The function is passed a
+     * {@link QueryResult} containing a {@link QueryResultItem} for each match.
+     * @param queryArguments an object of values keyed by the placeholder name
+     * without the leading `:`. Example: `{ "name": "Joanna" }` for a query like
+     * `SELECT * FROM people WHERE name = :name`.
+     * @returns a {@link StoreObserver} that can be used to cancel the
+     * observation.
+     * @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} `query/unsupported`: if the query is not a
+     * `SELECT` query.
+     * @throws {@link DittoError} may throw other errors.
+     */
+    registerObserverWithSignalNext(query: string, observationHandler: StoreObservationHandlerWithSignalNext, queryArguments?: DQLQueryArguments): StoreObserver;
     /**
      * Returns the collection for the given name. If the collection doesn't
      * exist yet, it will be created automatically as soon as the first
@@ -3279,6 +3458,22 @@ declare class Store {
      * related {@link Ditto} instance.
      */
     collectionNames(): Promise<string[]>;
+    /**
+     * Executes a DQL query and returns matching items as a query result.
+     *
+     * @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`.
+     * @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(query: string, queryArguments?: DQLQueryArguments): Promise<QueryResult>;
     /**
      * Initiate a write transaction in a callback.
      *
@@ -3290,6 +3485,40 @@ declare class Store {
     write(callback: (transaction: WriteTransaction) => Promise<void>): Promise<WriteTransactionResult[]>;
     /** @internal */
     constructor(ditto: Ditto);
+    /**
+     * Registers a URL to be called whenever the given `SELECT` query observes
+     * changes.
+     *
+     * No validation is performed on the URL, so it is up to the caller to ensure
+     * that the URL is valid and can be reached.
+     *
+     * @internal
+     * @returns a promise for a document id that acts as a webhook id
+     * @throws {@link DittoError} `store/query-invalid`: if the query is invalid
+     * @throws {@link DittoError} `store/query-arguments-invalid`: if the query arguments
+     * are invalid
+     * @throws {@link DittoError} `store/query-unsupported`: if the query is not a
+     * `SELECT` query
+     * @throws {@link DittoError} for any other error that occurs during query execution
+     */
+    registerObserverWebhook(query: string, url: string, queryArguments?: DQLQueryArguments): Promise<DocumentID>;
+    /**
+     * Unregister a store observer. No-op if the change observer has already
+     * been removed.
+     *
+     * This must only be called by the store observer itself.
+     *
+     * @param changeObserver the store observer to unregister
+     * @returns true if the store observer was found and removed, false otherwise
+     * @throws {@link DittoError} `internal`: if the store observer does not belong to
+     * this store
+     * @throws {@link DittoError} `internal`: if the store observer has not been
+     * cancelled yet
+     * @throws {@link DittoError} `internal`: for any other error that occurs while
+     * trying to unregister the store observer
+     * @internal
+     */
+    unregisterObserver(storeObserver: StoreObserver): boolean;
     /** @internal */
     close(): void;
     /**
@@ -3462,6 +3691,200 @@ declare abstract class BasePendingCursorOperation implements PromiseLike<Documen
     protected orderBys: OrderBy[];
 }
 
+type ErrorCode = keyof typeof ERROR_CODES;
+/**
+ * Error code and default error message for all Ditto error messages.
+ *
+ * Keys of this object define _error codes_ with each value containing the
+ * accompanying error description that is set as the default error message for
+ * errors instantiated with this code.
+ *
+ * Error codes may start with an error domain and a slash to group categories of
+ * errors together.
+ */
+declare const ERROR_CODES: {
+    /** Internal error for unexpected system states */
+    readonly internal: "An unexpected internal error occured. Please get in touch with Ditto customer service to report this incident.";
+    /** Internal error with an unknown error cause **/
+    readonly 'internal/unknown-error': "An unexpected internal error occured. Please get in touch with Ditto customer service to report this incident.";
+    /** Error for invalid DQL query arguments. */
+    readonly 'query/arguments-invalid': "The query arguments were invalid.";
+    /** Errors that occur during execution of a query */
+    readonly 'query/execution': "The query could not be executed.";
+    /** Error for an invalid DQL query. */
+    readonly 'query/invalid': "The query was invalid.";
+    /** Error for a query that uses DQL features not supported in this version or not supported by the currently used API. */
+    readonly 'query/unsupported': "The query contains unsupported features.";
+    /** Error in the storage backend. */
+    readonly 'store/backend': "An error occurred with the storage backend.";
+    /** Error for an invalid CRDT. */
+    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 codes for FFI result.
+ *
+ * @internal
+ */
+type FFIResultErrorCode = 'StoreDocumentNotFound' | 'StoreDatabase' | 'StoreQuery' | 'Crdt' | 'JsFloatingStoreOperation' | 'DqlQueryCompilation' | 'DqlInvalidQueryArgs' | 'DqlUnsupported';
+/**
+ * Represents an exception that occurred during a call into the Ditto FFI.
+ *
+ * Use the {@link throwOnErrorStatus | throwOnErrorStatus()} helper to
+ * automatically throw this error when an FFI call returns with a non-zero
+ * return value.
+ *
+ * @internal
+ */
+declare class DittoFFIError extends Error {
+    /**
+     * The code identifying this error.
+     *
+     * May be a numerical status code returned by an FFI call or an
+     * {@link FFIResultErrorCode} for errors returned on FFI result objects.
+     *
+     * @see {@link throwOnErrorStatus | throwOnErrorStatus()}
+     */
+    readonly code: number | FFIResultErrorCode;
+    /**
+     * Only call this constructor after having called `FFI.ensureInitialized()`
+     * and `FFI.trace()`.
+     *
+     * @param code numerical status code returned by an FFI call or an
+     * {@link FFIResultErrorCode} for errors returned on FFI result objects
+     * @param messageOverride overrides the thread-local error message set in
+     * Ditto core
+     * @param messageFallback fallback message to use if the thread-local error
+     * message is empty
+     */
+    constructor(code: number | FFIResultErrorCode, messageOverride?: string, messageFallback?: string);
+}
+
+/**
+ * Additional data, which provides context to the error and may help with
+ * debugging.
+ *
+ * **Warning:** The contents of this object may change in future versions of
+ * the SDK.
+ */
+type ErrorContext = Record<string, any>;
+/**
+ * `DittoError` is a subclass of the default Javascript `Error`. You can
+ * identify specific errors programatically using the
+ * {@link DittoError.code | code} property.
+ *
+ * Please reference {@link ERROR_CODES} for a comprehensive list of
+ * possible error codes in this SDK version.
+ */
+declare class DittoError extends Error {
+    /**
+     * Use the error code to identify a specific error programatically.
+     *
+     * @see {@link ERROR_CODES} for a comprehensive list of possible
+     * error codes in this SDK version.
+     */
+    readonly code: ErrorCode;
+    /** Some environments provide a stack trace that is attached to any error. */
+    readonly stack?: string;
+    /**
+     * Additional data, which provides context to the error and may help with
+     * debugging.
+     *
+     * **Warning:** The contents of this object may change in future versions of
+     * the SDK.
+     */
+    readonly context: Readonly<ErrorContext>;
+    /**
+     * @internal
+     * @param code string error code, see {@link ERROR_CODES}
+     * @param message optional error message that replace's the message for the given error code
+     * @param context optional object containing data that can help debug this error
+     * @throws {@link DittoError} `internal`: when supplied with an invalid error code
+     */
+    constructor(code: ErrorCode, message?: string | null, context?: ErrorContext);
+    /**
+     * Create a {@link DittoError} from a {@link DittoFFIError}.
+     *
+     * The error message will be set to the optional `messageOverride` parameter
+     * if supplied, otherwise it will be taken from the `message` property of the
+     * given {@link DittoFFIError}. In any case, the details of the underlying FFI
+     * error are made available in the error context of the returned {@link DittoError}.
+     *
+     * @internal
+     * @param code string error code from {@link ERROR_CODES}
+     * @param messageOverride optional string that will be used as the error
+     * message even if a thread-local error message has been retrieved from the
+     * FFI
+     * @param context optional object containing data that can help debug this error
+     * @returns {@link DittoError}
+     */
+    static fromFFIError(ffiError: DittoFFIError, code: ErrorCode, messageOverride?: string, context?: ErrorContext): DittoError;
+}
+/**
+ * Wraps the given function to catch any {@link DittoFFIError} and rethrow it as
+ * a {@link DittoError}, mapping status codes of the {@link DittoFFIError} to
+ * error codes of the {@link DittoError} using the given `statusCodeMapping`.
+ *
+ * Use either this function or {@link mapFFIErrorsAsync} to wrap all calls into
+ * the FFI that can fail.
+ *
+ * If the given status code mapping contains error messages, they will replace
+ * any error message that is returned by the FFI.
+ *
+ * @internal
+ * @param closure function that can throw a {@link DittoFFIError}
+ * @param statusCodeMapping optional mapping of status codes of the
+ * {@link DittoFFIError} to error codes of the {@link DittoError}
+ * @param context optional object containing data that can help debug this error
+ * @throws {@link DittoError} when the wrapped function throws a {@link DittoFFIError}
+ */
+declare function mapFFIErrors<T>(closure: () => T, statusCodeMapping?: FFIErrorMapping, context?: ErrorContext): T;
+/**
+ * Wraps the given async function to catch any {@link DittoFFIError} and rethrow
+ * it as a {@link DittoError}, mapping status codes of the {@link DittoFFIError}
+ * to error codes of the {@link DittoError} using the given `statusCodeMapping`.
+ *
+ * Use either this function or {@link mapFFIErrors} to wrap any calls into the
+ * FFI that can fail.
+ *
+ * If the given status code mapping contains error messages, they will replace
+ * any error message that is returned by the FFI.
+ *
+ * @internal
+ * @param closure async function that can throw a {@link DittoFFIError}
+ * @param statusCodeMapping optional mapping of status codes of the
+ * {@link DittoFFIError} to error codes of the {@link DittoError}.
+ * @param context optional object containing data that can help debug this error
+ * @throws {@link DittoError} when the wrapped function throws a {@link DittoFFIError}
+ */
+declare function mapFFIErrorsAsync<T>(closure: () => Promise<T>, statusCodeMapping?: FFIErrorMapping, context?: ErrorContext): Promise<T>;
+/**
+ * Defines which status code of an FFI response should be mapped to which error
+ * code of a {@link DittoError}.
+ *
+ * The second element of the tuple is an optional string that will be used as
+ * the error message of the {@link DittoError} instead of the FFI error message
+ * if defined.
+ *
+ * If a key `default` is present, it will be used as the error code if no
+ * mapping for a given status code is found.
+ *
+ * @example
+ * ```typescript
+ * const statusCodeMapping: FFIErrorMapping = {
+ *  '1': ['activation/failed', 'It just didn\'t work out'],
+ *  'default': ['sdk/environment-incompatible']
+ * }
+ * ```
+ *
+ * @internal
+ */
+type FFIErrorMapping = {
+    [statusCode: string]: [ErrorCode, string?];
+};
+
 /**
  * Get a count of bridged objects binned by bridge type.
  *
@@ -3477,10 +3900,17 @@ declare function getBridgeLoad(): {
 /** @internal */
 declare class CBOR {
     /** @internal */
-    static encode(data: any): Uint8Array;
+    static encode(data: any, replacer?: (key: any, value: any) => any): Uint8Array;
     /** @internal */
-    static decode(data: Uint8Array): any;
+    static decode(data: Uint8Array, reviver?: (key: any, value: any) => any): any;
 }
+/**
+ * Custom replacer that converts `DocumentID` instances to their string
+ * representation.
+ *
+ * @internal
+ */
+declare function documentIDReplacer(key: any, value: any): any;
 
-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, SmallPeerInfo, SmallPeerInfoSyncScope, 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 };
+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, DQLQueryArgumentValue, DQLQueryArguments, Ditto, DittoError, Document, DocumentID, DocumentIDValue, DocumentPath, DocumentValue, ERROR_CODES, ErrorCode, ErrorContext, 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, QueryResult, QueryResultItem, Register, RemotePeer, SingleDocumentLiveQueryEvent, SingleObservationHandler, SmallPeerInfo, SmallPeerInfoSyncScope, SortDirection, Store, StoreObservationHandler, StoreObservationHandlerWithSignalNext, StoreObserver, Subscription, Sync, SyncParameters, SyncState, SyncSubscription, TransportCondition, TransportConfig, TransportConfigConnect, TransportConfigGlobal, TransportConfigLan, TransportConfigListen, TransportConfigListenHTTP, TransportConfigListenTCP, TransportConfigPeerToPeer, UpdateResult, UpdateResultType, UpdateResultsMap, UpsertOptions, WebAssemblyModule, WriteStrategy, WriteTransaction, WriteTransactionCollection, WriteTransactionPendingCursorOperation, WriteTransactionPendingIDSpecificOperation, WriteTransactionResult, addressToString, checkAPIs, disableDeadlockTimeoutWhenDebugging, documentIDReplacer, getBridgeLoad, init, mapFFIErrors, mapFFIErrorsAsync, transportConfigFromDeserializable, transportConfigToSerializable, validateDocumentIDCBOR, validateDocumentIDValue };
 //# sourceMappingURL=ditto.d.ts.map