@dittolive/ditto 4.0.1 → 4.0.2-experimental.shutdown-support.2.darwin-arm64

package/types/ditto.d.ts

@@ -1,102 +1,152 @@
 /** @internal */
-type Pointer<Type> = {
-    type: Type;
-    addr: string;
-};
-/** @internal */
-type FFIWriteTransaction = 'CWriteTransaction_t';
+declare class KeepAlive {
+    /** @internal */
+    get isActive(): boolean;
+    /** @internal */
+    constructor();
+    /** @internal */
+    retain(id: string): void;
+    /** @internal */
+    release(id: string): void;
+    /** @internal */
+    currentIDs(): string[];
+    /** @internal */
+    countForID(id: string): number | null;
+    private static finalizationRegistry;
+    private intervalID;
+    private countsByID;
+}
+
 /** @internal */
-type FFIAuthClient = 'CAuthClient_t';
+type ObserverToken = string;
 /** @internal */
-type OrderBy = {
-    query: string;
-    direction: 'Ascending' | 'Descending';
+type ObserverManagerConstructorOptions = {
+    keepAlive?: KeepAlive;
+    register?: (callback: (...args: any[]) => void) => void;
+    unregister?: () => void;
+    process?: (...args: any[]) => any[];
 };
 /** @internal */
-type PathAccessorType = 'String' | 'Number' | 'Int' | 'UInt' | 'Float' | 'Double' | 'Bool' | 'Null' | 'Object' | 'Array' | 'Any' | 'Counter' | 'Register' | 'Attachment' | 'Rga' | 'RWMap';
-/** Various options to pass the web assembly module to Ditto. */
-type WebAssemblyModule = RequestInfo | URL | Response | BufferSource | WebAssembly.Module | string | null;
-
-/** 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;
+declare class ObserverManager {
+    /** @internal */
+    readonly id: string;
+    /** @internal */
+    readonly keepAlive: KeepAlive | null;
+    /** @internal */
+    constructor(id: string, options?: ObserverManagerConstructorOptions);
+    /** @internal */
+    addObserver(callback: any): ObserverToken;
+    /** @internal */
+    removeObserver(token: ObserverToken): void;
+    hasObserver(token: ObserverToken): boolean;
+    /** @internal */
+    notify(...args: any[]): void;
+    /** @internal */
+    close(): void;
     /**
-     * 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.
+     * Can be injected and replaced via constructor options.
      *
-     * @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.
+     * @abstract
      */
-    constructor(value: any, skipCBOREncoding?: boolean, skipValidation?: boolean);
+    protected register(callback: (...args: any[]) => void): void;
     /**
-     * Returns `true` if passed in `documentID` is equal to the receiver,
-     * otherwise returns `false`.
+     * Can be injected and replaced via constructor options.
+     *
+     * @abstract
      */
-    equals(documentID: DocumentID): boolean;
+    protected unregister(): void;
     /**
-     * Returns a string representation of the receiver.
+     * Can be injected and replaced via constructor options.
      *
-     * If you need a string representation to be used directly in a query,
-     * please use `toQueryCompatibleString()` instead.
+     * @abstract
      */
-    toString(): string;
+    protected process(...args: any[]): any[];
+    private isClosed;
+    private isRegistered;
+    private callbacksByToken;
+    private constructorOptions;
+    private hasObservers;
+    private registerIfNeeded;
+    private unregisterIfNeeded;
+    private finalize;
+}
+
+/** @internal */
+interface ObserverManaging {
+    hasObserver(token: ObserverToken): any;
+    removeObserver(token: ObserverToken): any;
+}
+/** @internal */
+type ObserverOptions = {
+    stopsWhenFinalized?: boolean;
+};
+/**
+ * Generic observer handle returned by various observation APIs. The observation
+ * remains active until the {@link stop | stop()} method is called explicitly or
+ * the observer instance is garbage collected. Therefore, to keep the observation
+ * alive, you have to keep a reference to the corresponding observer.
+ */
+declare class Observer {
+    /** @internal */
+    readonly observerManager: ObserverManaging;
+    /** @internal */
+    readonly token?: ObserverToken;
+    /** @internal */
+    readonly options?: ObserverOptions;
+    /** @internal */
+    constructor(observerManager: ObserverManaging, token: any, options?: ObserverOptions);
     /**
-     * Returns a byte representation of the document ID value as base64 string.
+     * Returns `true` if the observer has been explicitly stopped via the `stop()`
+     * method. Otherwise returns `false`.
      */
-    toBase64String(): string;
+    get isStopped(): boolean;
     /**
-     * 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()}`)
-     *  ```
+     * Stops the observation. Calling this method multiple times has no effect.
      */
-    toQueryCompatibleString(): string;
-    /** @internal */
-    toCBOR(): Uint8Array;
+    stop(): void;
+    private static finalizationRegistry;
+    private static finalize;
 }
+
+/**
+ * Describes the direction when sorting a query.
+ */
+type SortDirection = 'ascending' | 'descending';
+/**
+ * Defines the various strategies available when inserting a document into a
+ * collection.
+ *
+ * - `merge`: the existing document will be merged with the document being
+ *    inserted, if there is a pre-existing document.
+ *
+ * - `insertIfAbsent`: insert the document only if there is not already a
+ *    document with the same ID in the store. If there is already a document in
+ *    the store with the same ID then this will be a no-op.
+ *
+ * - `insertDefaultIfAbsent`: insert the document, with its contents treated as
+ *    default data, only if there is not already a document with the same ID in
+ *    the store. If there is already a document in the store with the same ID
+ *    then this will be a no-op. Use this strategy if you want to insert default
+ *    data for a given document ID, which you want to treat as common initial
+ *    data amongst all peers and that you expect to be mutated or overwritten in
+ *    due course.
+ */
+type WriteStrategy = 'merge' | 'insertIfAbsent' | 'insertDefaultIfAbsent';
+/**
+ * Represents a dictionary of values to be incorporated into a query keyed
+ * by the placeholder used within that query. See method
+ * {@link Collection.find | find()} of {@link Collection} for more info.
+ */
+type QueryArguments = {
+    [key: string]: any;
+};
+
 /** @internal */
-declare function validateDocumentIDValue(id: DocumentIDValue): DocumentIDValue;
-/** @internal */
-declare function validateDocumentIDCBOR(idCBOR: Uint8Array): Uint8Array;
+declare class Value {
+    readonly value: unknown;
+    readonly isDefault: boolean;
+    constructor(value: unknown, options?: unknown);
+}
 
 /**
  * Represents a CRDT counter that can be upserted as part of a document or
@@ -200,41 +250,272 @@ declare class AttachmentToken {
     constructor(jsObj: object);
 }
 
+/** @internal */
+type Pointer<Type> = {
+    type: Type;
+    addr: string;
+};
+/** @internal */
+type FFIWriteTransaction = 'CWriteTransaction_t';
+/** @internal */
+type FFIAuthClient = 'CAuthClient_t';
+/** @internal */
+type OrderBy = {
+    query: string;
+    direction: 'Ascending' | 'Descending';
+};
+/** @internal */
+type PathAccessorType = 'String' | 'Number' | 'Int' | 'UInt' | 'Float' | 'Double' | 'Bool' | 'Null' | 'Object' | 'Array' | 'Any' | 'Counter' | 'Register' | 'Attachment' | 'Rga' | 'RWMap';
+/** Various options to pass the web assembly module to Ditto. */
+type WebAssemblyModule = RequestInfo | URL | Response | BufferSource | WebAssembly.Module | string | null;
+
 /**
- * Represents a portion of the document at a specific key-path.
- *
- * Provides an interface to specify a path to a key in a document that you can
- * then call a function on to get the value at the specified key as a specific
- * type. You don't create a `DocumentPath` directly but obtain one via the
- * {@link Document.path | path} property or the {@link Document.at | at()}
- * method of {@link Document}.
+ * Available options for {@link init | init()}.
  */
-declare class DocumentPath {
-    /** The document this path belongs to. */
-    readonly document: Document;
-    /** The full document path so far. */
-    readonly path: string;
+type InitOptions = {
     /**
-     * Returns a new document path instance with the passed in key-path or
-     * index appended.
-     *
-     * A key-path can be a single property name or multiple property names
-     * separated by a dot. Indexes can also be specified as part of the key
-     * path using the square bracket syntax. The empty string returns a document
-     * path representing the same portion of the document as the receiver. If a
-     * key-path starts with a property name and is prefixed by a dot, the dot is
-     * ignored.
-     *
-     * Examples:
-     *
-     *    - `documentPath.at('mileage')`
-     *    - `documentPath.at('driver.name')`
-     *    - `documentPath.at('passengers[2]')`
-     *    - `documentPath.at('passengers[2].belongings[1].kind')`
-     *    - `documentPath.at('.mileage')`
+     * You can explicitly pass the WebAssembly module or its location via the
+     * `webAssemblyModule` option. By default, Ditto tries to load the WebAssembly
+     * module from the same path where this JavaScript is served.
      */
-    at(keyPathOrIndex: string | number): DocumentPath;
-    /**
+    webAssemblyModule?: WebAssemblyModule;
+};
+/**
+ * Initializes the whole Ditto module. Needs to be called and complete before
+ * any of the Ditto API is used.
+ *
+ * @param options - Dictionary with global {@link InitOptions | initialization options}.
+ */
+declare function init(options?: InitOptions): Promise<void>;
+
+/** The log levels supported by Ditto. */
+type LogLevel = 'Error' | 'Warning' | 'Info' | 'Debug' | 'Verbose';
+/**
+ * Closure that {@link Logger.setCustomLogCallback} can be set as a custom
+ * log callback on {@link Logger}.
+ */
+type CustomLogCallback = (logLevel: LogLevel, message: string) => void;
+/**
+ * Class with static methods to customize the logging behavior from Ditto and
+ * log messages with the Ditto logging infrastructure.
+ */
+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;
+    /**
+     * 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).
+     * In the browser, this method has no effect.
+     *
+     * @param path can be `null`, in which case the current logging file, if any,
+     * is unregistered, otherwise, the file path must be within an already
+     * existing directory.
+     */
+    static setLogFile(path: string | null): void;
+    /**
+     * Convenience method, takes the path part of the URL and calls
+     * {@link setLogFile | setLogFile()} with it.
+     */
+    static setLogFileURL(url: URL | undefined): void;
+    /** Whether the logger is currently enabled. */
+    static get enabled(): boolean;
+    /** Enables or disables logging. */
+    static set enabled(enabled: boolean);
+    /**
+     * Represents whether or not emojis should be used as the log level
+     * indicator in the logs.
+     */
+    static get emojiLogLevelHeadingsEnabled(): boolean;
+    /**
+     * Represents whether or not emojis should be used as the log level
+     * indicator in the logs.
+     */
+    static set emojiLogLevelHeadingsEnabled(emojiLogLevelHeadingsEnabled: boolean);
+    /**
+     * The minimum log level at which logs will be logged.
+     *
+     * For example if this is set to `Warning`, then only logs that are logged
+     * with the `Warning` or `Error` log levels will be shown.
+     */
+    static get minimumLogLevel(): LogLevel;
+    /**
+     * The minimum log level at which logs will be logged.
+     *
+     * For example if this is set to `Warning`, then only logs that are logged
+     * with the `Warning` or `Error` log levels will be shown.
+     */
+    static set minimumLogLevel(minimumLogLevel: LogLevel);
+    /**
+     * Returns the current custom log callback, `undefined` by default. See
+     * {@link setCustomLogCallback | setCustomLogCallback()} for a detailed
+     * description.
+     */
+    static readonly customLogCallback?: CustomLogCallback;
+    /**
+     * 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.
+     */
+    static setCustomLogCallback(callback: CustomLogCallback | undefined): Promise<void>;
+    /**
+     * Logs the message for the given `level`.
+     *
+     * @see {@link error | error()}
+     * @see {@link warning | warning()}
+     * @see {@link info | info()}
+     * @see {@link debug | debug()}
+     * @see {@link verbose | verbose()}
+     */
+    static log(level: LogLevel, message: string): void;
+    /**
+     * Convenience method, same as calling {@link log | log()} with
+     * {@link LogLevel} `Error`.
+     */
+    static error(message: string): void;
+    /**
+     * Convenience method, same as calling {@link log | log()} with
+     * {@link LogLevel} `Warning`.
+     */
+    static warning(message: string): void;
+    /**
+     * Convenience method, same as calling {@link log | log()} with
+     * {@link LogLevel} `Info`.
+     */
+    static info(message: string): void;
+    /**
+     * Convenience method, same as calling {@link log | log()} with
+     * {@link LogLevel} `Debug`.
+     */
+    static debug(message: string): void;
+    /**
+     * Convenience method, same as calling {@link log | log()} with
+     * {@link LogLevel} `Verbose`.
+     */
+    static verbose(message: string): void;
+    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.
+ *
+ * Provides an interface to specify a path to a key in a document that you can
+ * then call a function on to get the value at the specified key as a specific
+ * type. You don't create a `DocumentPath` directly but obtain one via the
+ * {@link Document.path | path} property or the {@link Document.at | at()}
+ * method of {@link Document}.
+ */
+declare class DocumentPath {
+    /** The document this path belongs to. */
+    readonly document: Document;
+    /** The full document path so far. */
+    readonly path: string;
+    /**
+     * Returns a new document path instance with the passed in key-path or
+     * index appended.
+     *
+     * A key-path can be a single property name or multiple property names
+     * separated by a dot. Indexes can also be specified as part of the key
+     * path using the square bracket syntax. The empty string returns a document
+     * path representing the same portion of the document as the receiver. If a
+     * key-path starts with a property name and is prefixed by a dot, the dot is
+     * ignored.
+     *
+     * Examples:
+     *
+     *    - `documentPath.at('mileage')`
+     *    - `documentPath.at('driver.name')`
+     *    - `documentPath.at('passengers[2]')`
+     *    - `documentPath.at('passengers[2].belongings[1].kind')`
+     *    - `documentPath.at('.mileage')`
+     */
+    at(keyPathOrIndex: string | number): DocumentPath;
+    /**
      * Traverses the document with the key-path represented by the receiver and
      * returns the corresponding object or value.
      */
@@ -450,21 +731,44 @@ declare class MutableDocument {
 }
 
 /**
- * Part of {@link TransportConfig} type, configuration for listening for TCP
- * connections.
- */
-interface TransportConfigListenTCP {
-    isEnabled: boolean;
-    interfaceIP: string;
-    port: number;
-}
-/**
- * Part of {@link TransportConfig} type, configuration for listening for HTTP,
- * including Websocket, connections.
+ * Maps a {@link DocumentID} to an array of
+ * {@link UpdateResult | update results}. This is the data structure you get
+ * when {@link PendingCursorOperation.update | updating} a set of documents
+ * with detailed info about the performed updates.
  */
-interface TransportConfigListenHTTP {
-    isEnabled: boolean;
-    interfaceIP: string;
+declare class UpdateResultsMap {
+    /**
+     * Returns an array of {@link UpdateResult | update results} associated with
+     * the `documentID` or undefined if not found.
+     */
+    get(documentIDOrValue: DocumentID | DocumentIDValue): UpdateResult[] | undefined;
+    /**
+     * Returns all contained keys, i.e. {@link DocumentID | document IDs}
+     * contained in this map.
+     */
+    keys(): DocumentID[];
+    /** @internal */
+    constructor(documentIDs: DocumentID[], updateResultsByDocumentIDString: object);
+    private documentIDs;
+    private updateResultsByDocumentIDString;
+}
+
+/**
+ * Part of {@link TransportConfig} type, configuration for listening for TCP
+ * connections.
+ */
+interface TransportConfigListenTCP {
+    isEnabled: boolean;
+    interfaceIP: string;
+    port: number;
+}
+/**
+ * Part of {@link TransportConfig} type, configuration for listening for HTTP,
+ * including Websocket, connections.
+ */
+interface TransportConfigListenHTTP {
+    isEnabled: boolean;
+    interfaceIP: string;
     port: number;
     staticContentPath?: string;
     websocketSync: boolean;
@@ -620,111 +924,6 @@ declare class TransportConfig {
     static areListenHTTPsEqual(left: TransportConfigListenHTTP, right: TransportConfigListenHTTP): boolean;
 }
 
-/** @internal */
-interface ObserverRemoving {
-    removeObserver(token: any): any;
-}
-/** @internal */
-type ObserverOptions = {
-    stopsWhenFinalized?: boolean;
-};
-/**
- * Generic observer handle returned by various observation APIs. The observation
- * remains active until the {@link stop | stop()} method is called explicitly or
- * the observer instance is garbage collected. Therefore, to keep the observation
- * alive, you have to keep a reference to the corresponding observer.
- */
-declare class Observer {
-    /** @internal */
-    readonly observerManager: ObserverRemoving;
-    /** @internal */
-    readonly token?: any;
-    /** @internal */
-    readonly options?: ObserverOptions;
-    /** @internal */
-    constructor(observerManager: ObserverRemoving, token: any, options?: ObserverOptions);
-    /**
-     * Returns `true` if the observer has been explicitly stopped via the `stop()`
-     * method. Otherwise returns `false`.
-     */
-    get isStopped(): boolean;
-    /**
-     * Stops the observation. Calling this method multiple times has no effect.
-     */
-    stop(): void;
-    private static finalizationRegistry;
-    private static finalize;
-}
-
-/** @internal */
-declare class KeepAlive {
-    /** @internal */
-    get isActive(): boolean;
-    /** @internal */
-    constructor();
-    /** @internal */
-    retain(id: string): void;
-    /** @internal */
-    release(id: string): void;
-    /** @internal */
-    currentIDs(): string[];
-    /** @internal */
-    countForID(id: string): number | null;
-    private static finalizationRegistry;
-    private intervalID;
-    private countsByID;
-}
-
-/** @internal */
-type ObserverToken = string;
-/** @internal */
-type ObserverManagerConstructorOptions = {
-    keepAlive?: KeepAlive;
-    register?: (callback: (...args: any[]) => void) => void;
-    unregister?: () => void;
-    process?: (...args: any[]) => any[];
-};
-/** @internal */
-declare class ObserverManager {
-    /** @internal */
-    readonly id: string;
-    /** @internal */
-    readonly keepAlive: KeepAlive | null;
-    /** @internal */
-    constructor(id: string, options?: ObserverManagerConstructorOptions);
-    /** @internal */
-    addObserver(callback: any): ObserverToken;
-    /** @internal */
-    removeObserver(token: ObserverToken): void;
-    /** @internal */
-    notify(...args: any[]): void;
-    /**
-     * Can be injected and replaced via constructor options.
-     *
-     * @abstract
-     */
-    protected register(callback: (...args: any[]) => void): void;
-    /**
-     * Can be injected and replaced via constructor options.
-     *
-     * @abstract
-     */
-    protected unregister(): void;
-    /**
-     * Can be injected and replaced via constructor options.
-     *
-     * @abstract
-     */
-    protected process(...args: any[]): any[];
-    private isRegistered;
-    private callbacksByToken;
-    private constructorOptions;
-    private hasObservers;
-    private registerIfNeeded;
-    private unregisterIfNeeded;
-    private finalize;
-}
-
 /**
  * Provides info about the authentication status.
  */
@@ -825,6 +1024,8 @@ declare class Authenticator {
     /** @internal */
     '@ditto.authClientValidityChanged'(isWebValid: boolean, isX509Valid: boolean): void;
     /** @internal */
+    close(): void;
+    /** @internal */
     protected keepAlive: KeepAlive;
     /** @internal */
     protected observerManager: ObserverManager;
@@ -834,6 +1035,7 @@ declare class OnlineAuthenticator 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>;
+    close(): void;
     readonly authClientPointer: Pointer<FFIAuthClient>;
     readonly authenticationHandler: AuthenticationHandler;
     private ditto;
@@ -988,474 +1190,633 @@ type Identity = IdentityOfflinePlayground | IdentitySharedKey | IdentityManual |
 /** 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';
 /**
- * Describes the direction when sorting a query.
- */
-type SortDirection = 'ascending' | 'descending';
-/**
- * Defines the various strategies available when inserting a document into a
- * collection.
- *
- * - `merge`: the existing document will be merged with the document being
- *    inserted, if there is a pre-existing document.
- *
- * - `insertIfAbsent`: insert the document only if there is not already a
- *    document with the same ID in the store. If there is already a document in
- *    the store with the same ID then this will be a no-op.
+ * An opaque address uniquely identifying another peer on the Ditto mesh
+ * network.
  *
- * - `insertDefaultIfAbsent`: insert the document, with its contents treated as
- *    default data, only if there is not already a document with the same ID in
- *    the store. If there is already a document in the store with the same ID
- *    then this will be a no-op. Use this strategy if you want to insert default
- *    data for a given document ID, which you want to treat as common initial
- *    data amongst all peers and that you expect to be mutated or overwritten in
- *    due course.
- */
-type WriteStrategy = 'merge' | 'insertIfAbsent' | 'insertDefaultIfAbsent';
-/**
- * Represents a dictionary of values to be incorporated into a query keyed
- * by the placeholder used within that query. See method
- * {@link Collection.find | find()} of {@link Collection} for more info.
- */
-type QueryArguments = {
-    [key: string]: any;
-};
-
-/**
- * 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.
+ * 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 AttachmentFetchEventProgress = {
-    type: 'Progress';
-    totalBytes: number | BigInt;
-    downloadedBytes: number | BigInt;
+type Address = {
+    siteId: string;
+    pubkey: Uint8Array;
 };
 /**
- * An attachment fetch event used when the attachment is deleted.
+ * 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.
  */
-type AttachmentFetchEventDeleted = {
-    type: 'Deleted';
+declare function addressToString(address: Address): string;
+/** Represents a connection between two peers on the Ditto mesh network. */
+type Connection = {
+    /** Unique identifier for the connection. */
+    id: string;
+    /** Type of transport enabling this connection. */
+    type: ConnectionType;
+    /** The peer key of the peer at one end of the connection. */
+    peer1: Uint8Array;
+    /** The peer key of the peer at one end of the connection. */
+    peer2: Uint8Array;
+    approximateDistanceInMeters?: number;
 };
-/**
- * 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> {
+/** An instance of Ditto taking part in the Ditto mesh network. */
+type Peer = {
     /**
-     * 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.
+     * Address to contact this peer via Ditto Bus, unique with a Ditto mesh
+     * network.
      */
-    readonly attachment: Promise<Attachment | null>;
+    address: Address;
     /**
-     * Stops fetching the associated attachment and cleans up any associated
-     * resources.
+     * The peer key is a unique identifier for a given peer, equal to or derived
+     * from the cryptographic public key used to authenticate it.
      *
-     * 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.
+     * NOTE: This will be be empty when a peer is not updated to the latest
+     * version of the SDK.
      */
-    stop(): void;
-    /** @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 */
-    readonly ditto: Ditto;
-    /** @internal */
-    readonly token: AttachmentToken;
-    /** @internal */
-    readonly eventHandler: (attachmentFetchEvent: AttachmentFetchEvent) => void | null;
-    /** @internal */
-    constructor(ditto: Ditto, token: AttachmentToken, eventHandler?: (attachmentFetchEvent: AttachmentFetchEvent) => void);
-    private cancelTokenPromise;
-    private static finalizationRegistry;
-    private static stopWithContextInfo;
-}
-
-/**
- * Used to subscribe to receive updates from remote peers about matching
- * documents.
- *
- * While {@link Subscription} objects remain in scope they ensure that
- * documents in the collection specified and that match the query provided will
- * try to be kept up-to-date with the latest changes from remote peers.
- */
-declare class Subscription {
+    peerKey: Uint8Array;
     /**
-     * The query that the subscription is based on.
+     * The human-readable device name of the peer. This defaults to the hostname
+     * but can be manually set by the application developer of the other peer.
+     * It is not necessarily unique.
      */
-    readonly query: string;
+    deviceName: string;
     /**
-     * Returns `true` if subscription has been explicitly cancelled, `false`
-     * otherwise.
+     * Currently active connections of the peer.
      */
-    readonly isCancelled = false;
+    connections: Connection[];
     /**
-     * The name of the collection that the subscription is based on.
+     * Indicates whether the peer is connected to Ditto Cloud.
      */
-    get collectionName(): string;
+    isConnectedToDittoCloud: boolean;
+    /** The operating system the peer is running on, `undefined` if (yet) unknown. */
+    os?: string;
+    /** The Ditto SDK version the peer is running with, `undefined` if (yet) unknown. */
+    dittoSDKVersion?: string;
+};
+/**
+ * Represents the Ditto mesh network of peers and their connections between each
+ * other. The `localPeer` is the entry point, all others are remote peers known
+ * by the local peer (either directly or via other remote peers).
+ */
+type PresenceGraph = {
     /**
-     * Cancels a subscription and releases all associated resources.
+     * Returns the local peer (usually the peer that is represented by the
+     * currently running Ditto instance). The `localPeer` is the entry point, all
+     * others are remote peers known by the local peer (either directly or via
+     * other remote peers).
      */
-    cancel(): void;
-    /** @internal */
-    constructor(collection: Collection, query: string, queryArgsCBOR: Uint8Array | null, orderBys: OrderBy[], limit: number, offset: number);
+    localPeer: Peer;
     /**
-     * The collection this subscription belongs to.
-     * @internal Because not exposed in any of the other SDKs (yet?).
+     * Returns all remote peers known by the `localPeer`, either directly or via
+     * other remote peers.
      */
-    readonly collection: Collection;
+    remotePeers: Peer[];
     /**
-     * The corresponding named arguments for {@link query}, if any.
-     * @internal Because not exposed in any of the other SDKs (yet?).
+     * Returns the underlying CBOR data if the presence graph has been initialized
+     * with CBOR. All of Ditto API returning a presence graph has this property
+     * set.
      */
-    readonly queryArgsCBOR: Uint8Array | null;
-    private static finalizationRegistry;
-    private static add;
-    private static remove;
-    private contextInfo;
-}
-
+    underlyingCBOR?: Uint8Array;
+};
 /**
- * The type that is returned when calling
- * {@link PendingCursorOperation.observeLocal | observeLocal()} on a
- * {@link PendingCursorOperation} object. It handles the logic for calling the
- * event handler that is provided to `observeLocal()` calls.
- *
- * Ditto will prevent the process from exiting as long as there are active live
- * queries (not relevant when running in the browser).
+ * The entrypoint for all actions that relate presence of other peers known by
+ * the current peer, either directly or through other peers.
  *
- * `LiveQuery` objects must be kept in scope for as long as you wish to have
- * your event handler be called when there is an update to a document matching
- * the query you provide. When you no longer want to receive updates about
- * documents matching a query then you must call {@link stop | stop()}.
+ * You don't create one directly but can access it from a particular `Ditto`
+ * instance via its `presence` property.
  */
-declare class LiveQuery {
-    /** The query that the live query is based on. */
-    readonly query: string;
-    /** The arguments belonging to {@link query}. */
-    readonly queryArgs: QueryArguments | null;
-    /** The name of the collection that the live query is based on. */
-    get collectionName(): string;
-    /** Returns true if the receiver has been stopped. */
-    get isStopped(): boolean;
+declare class Presence {
+    /** The Ditto instance this object belongs to. */
+    readonly ditto: Ditto;
     /**
-     * Stop the live query from delivering updates.
+     * Returns the current presence graph capturing all known peers and
+     * connections between them.
      */
-    stop(): void;
-    /** @internal */
-    readonly limit: number;
-    /** @internal */
-    readonly offset: number;
-    /** @internal */
-    readonly collection: Collection;
-    /** @internal */
-    readonly subscription?: Subscription;
-    /** @internal */
-    readonly handler: QueryObservationHandler;
+    get graph(): PresenceGraph;
+    /**
+     * Request information about Ditto peers in range of this device.
+     *
+     * This method returns an observer which should be held as long as updates are
+     * required. A newly registered observer will have a peers update delivered to
+     * it immediately. From then on it will be invoked repeatedly when Ditto
+     * devices come and go, or the active connections to them change.
+     */
+    observe(didChangeHandler: (presenceGraph: PresenceGraph) => void): Observer;
     /** @internal */
-    constructor(query: string, queryArgs: QueryArguments | null, queryArgsCBOR: Uint8Array | null, orderBys: OrderBy[], limit: number, offset: number, collection: Collection, subscription: Subscription | null, handler: QueryObservationHandler);
+    constructor(ditto: Ditto);
     /** @internal */
-    signalNext(): Promise<void>;
-    private orderBys;
-    private queryArgsCBOR;
-    private liveQueryID;
+    close(): void;
+    private observerManager;
 }
 
+/** Types of connections that can be established between two peers. */
+type TransportCondition = 'Unknown' | 'OK' | 'GenericFailure' | 'AppInBackground' | 'MDNSFailure' | 'TCPListenFailure' | 'NoBLECentralPermission' | 'NoBLEPeripheralPermission' | 'CannotEstablishConnection' | 'BLEDisabled' | 'NoBLEHardware' | 'WiFiDisabled' | 'TemporarilyUnavailable';
+/** The source for a transport condition. */
+type ConditionSource = 'BLE' | 'TCP' | 'AWDL' | 'MDNS';
 /**
- * Maps a {@link DocumentID} to an array of
- * {@link UpdateResult | update results}. This is the data structure you get
- * when {@link PendingCursorOperation.update | updating} a set of documents
- * with detailed info about the performed updates.
+ * Types of connections that can be established between two peers.
+ * @deprecated replaced by {@link ConnectionType}.
  */
-declare class UpdateResultsMap {
-    /**
-     * Returns an array of {@link UpdateResult | update results} associated with
-     * the `documentID` or undefined if not found.
-     */
-    get(documentIDOrValue: DocumentID | DocumentIDValue): UpdateResult[] | undefined;
-    /**
-     * Returns all contained keys, i.e. {@link DocumentID | document IDs}
-     * contained in this map.
-     */
-    keys(): DocumentID[];
-    /** @internal */
-    constructor(documentIDs: DocumentID[], updateResultsByDocumentIDString: object);
-    private documentIDs;
-    private updateResultsByDocumentIDString;
-}
-
+type PresenceConnectionType = 'WiFi' | 'WebSocket' | 'AWDL' | 'BLE';
 /**
- * These objects are returned when using
- * {@link Collection.findByID | findByID()} functionality on
- * {@link Collection | collections}.
- *
- * You can either call {@link exec | exec()} on the  object to get an immediate
- * return value, or chain calls to update, evict or remove the document.
- *
- * Live queries and subscriptions are only available outside of a transaction.
+ * A peer object with information about an observed peer.
+ * @deprecated replaced by {@link Peer}.
  */
-declare abstract class BasePendingIDSpecificOperation implements PromiseLike<Document | undefined> {
+type RemotePeer = {
+    networkID: string;
+    deviceName: string;
+    rssi?: number;
+    approximateDistanceInMeters?: number;
+    connections: PresenceConnectionType[];
+};
+/**
+ * Ditto is the entry point for accessing Ditto-related functionality.
+ */
+declare class Ditto {
     /**
-     * Removes the document with the matching ID.
+     * Configure a custom identifier for the current device.
      *
-     * @returns `true` promise if the document was found and removed. `false`
-     * promise if the document wasn't found and therefore wasn't removed.
+     * When using {@link Presence.observe | presence.observe()}, each remote peer is
+     * represented by a short UTF-8 "device name". By default this will be a
+     * truncated version of the device's hostname. It does not need to be unique
+     * among peers. Configure the device name before calling
+     * {@link startSync | startSync()}. If it is too long it may be truncated.
      */
-    abstract remove(): Promise<boolean>;
+    deviceName: string;
+    /** Returns a string identifying the version of the Ditto SDK. */
+    get sdkVersion(): string;
     /**
-     * Evicts the document with the matching ID.
-     *
-     * @returns `true` promise if the document was found and evicted. `false`
-     * promise if the document wasn't found and therefore wasn't evicted.
+     * The (validated) identity this Ditto instance was initialized with.
      */
-    abstract evict(): Promise<boolean>;
+    readonly identity: Identity;
     /**
-     * Updates the document with the matching ID.
-     *
-     * @param closure A closure that gets called with the document matching the
-     * ID. If found, the document is a {@link MutableDocument}, so you can call
-     * update-related functions on it. If the document is not found then the value
-     * provided to the closure will be `undefined`.
-     *
-     * @return An array promise of {@link UpdateResult | update results} that
-     * describe the updates that were performed on the document.
+     * The path this Ditto instance was initialized with, if no path was given at
+     * construction time, the default value is returned (see constructor).
      */
-    abstract update(closure: (document: MutableDocument) => void): Promise<UpdateResult[]>;
-    /** The ID of the document this operation operates on. */
-    readonly documentID: DocumentID;
-    /** The collection the receiver is operating on. */
-    readonly collection: CollectionInterface;
+    readonly path: string;
     /**
-     * Executes the find operation to return the document with the matching ID.
-     *
-     * @returns The {@link Document} promise with the ID provided in the
-     * {@link Collection.findByID | findByID()} call or `undefined` if the document was
-     * not found.
+     * Provides access to the SDK's store functionality.
      */
-    exec(): Promise<Document | undefined>;
-    /** @internal */
-    constructor(documentID: DocumentID, collection: CollectionInterface);
-    /** @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 */
-    get query(): string;
-    protected documentIDCBOR: Uint8Array;
-}
-
-type UpsertOptions = {
-    writeStrategy?: WriteStrategy;
-};
-interface CollectionInterface {
-    /** The name of the collection. */
-    readonly name: string;
+    readonly store: Store;
     /**
-     * The store this collection belongs to.
-     * @internal
+     * Provides access to the SDK's presence functionality.
      */
-    readonly store: Store;
+    readonly presence: Presence;
     /**
-     * Search for documents in this collection using the provided query string.
+     * Provides access to authentication methods for logging on to Ditto Cloud.
+     */
+    readonly auth: Authenticator;
+    /**
+     * The site ID that the instance of `Ditto` is using as part of its identity.
+     */
+    readonly siteID: number | BigInt;
+    /**
+     * Returns `true` if an offline license token has been set, otherwise returns `false`.
      *
-     * @param query The query to run against the collection.
-     * @param queryArgs These arguments replace placeholders in the provided
-     * query.
+     * @see {@link setOfflineOnlyLicenseToken | setOfflineOnlyLicenseToken()}
      */
-    find(query: string, queryArgs?: QueryArguments): BasePendingCursorOperation;
+    readonly isActivated: boolean;
     /**
-     * Convenience method, equivalent to calling {@link find | find()} and passing
-     * the query `"true"`.
+     * `true` once {@link close | Ditto.close()} has been called, otherwise
+     * `false`.
      */
-    findAll(): BasePendingCursorOperation;
+    get isClosed(): boolean;
     /**
-     * Find documents given a specific ID.
+     * 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;
+    /**
+     * Initializes a new `Ditto` instance.
      *
-     * Use the returned cursor instance to chain operations on the search result.
+     * **NOTE**: The `sharedKey` identity is only supported for Node environments,
+     * using this to create a Ditto instance in the web browser will throw an
+     * exception.
      *
-     * @param id The document's identifier
+     * @param identity - Identity for the new Ditto instance, defaults to
+     * `offlinePlayground` with `appID` being the empty string `''`.
+     *
+     * @param path - On Node, `path` corresponds to a real directory
+     * on the file system (intermediate directories are created if needed). In the
+     * browser, `path` is used as an internal namespace for the in-memory storage.
+     * Defaults to `"ditto"`.
+     *
+     * @see {@link Ditto.identity}
+     * @see {@link Ditto.path}
      */
-    findByID(id: DocumentID | DocumentIDValue): BasePendingIDSpecificOperation;
+    constructor(identity?: Identity, path?: string);
     /**
-     * TEMPORARY: helper to deal with non-canonical IDs.
+     * Check if the current environment supports running Ditto.
      *
-     * @internal
+     * Required APIs include:
+     *
+     * - `BigInt`
+     * - `FinalizationRegistry`
+     * - `WeakRef`
+     *
+     *  Internet Explorer is not supported.
+     *
+     * @returns true if the environment is supported
      */
-    findByIDCBOR(idCBOR: Uint8Array): BasePendingIDSpecificOperation;
+    static isEnvironmentSupported(): boolean;
     /**
-     * Inserts a new document into the collection and returns its ID. If the
-     * document already exists, the contents of both are merged by default. You
-     * can change this by providing a different `writeStrategy` via `options`.
+     * Activate a `Ditto` instance by setting an offline only license token. You cannot initiate sync
+     * with `Ditto` before you have activated it. The offline license token is only valid for identities
+     * of type `development`, `manual`, `offlinePlayground`, and `sharedKey`.
      *
-     * @param value The content of the document to be inserted or updated.
-     * @param options.writeStrategy Specifies the desired strategy for inserting a
-     * document, defaults to `'merge'`.
+     * @param licenseToken the license token to activate the `Ditto` instance
+     * with. You can find yours on the [Ditto portal](https://portal.ditto.live).
      */
-    upsert(value: DocumentValue, options: UpsertOptions): Promise<DocumentID>;
-}
-
-declare abstract class BasePendingCursorOperation implements PromiseLike<Document[]> {
+    setOfflineOnlyLicenseToken(licenseToken: string): void;
     /**
-     * Removes all documents that match the query generated by the preceding
-     * function chaining.
+     * Returns the current transport configuration, frozen. If you want to modify
+     * the transport config, make a {@link TransportConfig.copy | copy} first. Or
+     * use the {@link updateTransportConfig | updateTransportConfig()}
+     * convenience method. By default peer-to-peer transports (Bluetooth, WiFi,
+     * and AWDL) are enabled if available in the current environment
+     * (Web, Node, OS, etc.).
      *
-     * @returns An array promise containing the IDs of the documents that were
-     * removed.
+     * @see {@link setTransportConfig | setTransportConfig()}
+     * @see {@link updateTransportConfig | updateTransportConfig()}
      */
-    abstract remove(): Promise<DocumentID[]>;
+    readonly transportConfig: TransportConfig;
     /**
-     * Evicts all documents that match the query generated by the preceding
-     * function chaining.
+     * Assigns a new transports configuration. By default peer-to-peer transports
+     * (Bluetooth, WiFi, and AWDL) are enabled. You may use this method to alter
+     * the configuration at any time, however sync will not begin until
+     * {@link startSync | startSync()} is called.
      *
-     * @return An array promise containing the IDs of the documents that were
-     * evicted.
+     * @see {@link transportConfig}
+     * @see {@link updateTransportConfig | updateTransportConfig()}
      */
-    abstract evict(): Promise<DocumentID[]>;
+    setTransportConfig(transportConfig: TransportConfig): void;
     /**
-     * Updates documents that match the query generated by the preceding function
-     * chaining.
+     * Convenience method for updating the transport config. Creates a copy of the
+     * current transport config, passes that copy to the `update` closure,
+     * allowing it to mutate as needed, and sets that updated copy afterwards.
+     */
+    updateTransportConfig(update: (transportConfig: TransportConfig) => void): Ditto;
+    /**
+     * Starts the network transports. Ditto will connect to other devices.
      *
-     * @param closure A closure that gets called with all of the documents
-     * matching the query. The documents are instances of {@link MutableDocument}
-     * so you can call update-related functions on them.
+     * By default Ditto will enable all peer-to-peer transport types. On **Node**,
+     * this means BluetoothLE, WiFi/LAN, and AWDL. On the **Web**, only connecting
+     * via  Websockets is supported. The network configuration can be
+     * customized with {@link updateTransportConfig | updateTransportConfig()}
+     * or replaced entirely with {@link setTransportConfig | setTransportConfig()}.
      *
-     * @returns An {@link UpdateResultsMap} promise mapping document IDs to lists
-     * of {@link UpdateResult | update results} that describe the updates that
-     * were performed for each document.
+     *
+     * Ditto will prevent the process from exiting until sync is stopped (not
+     * relevant when running in the browser).
+     *
+     * **NOTE**: the BluetoothLE transport on Linux is experimental, this
+     * method panics if no BluetoothLE hardware is available. Therefore, contrary
+     * to the above, the BluetoothLE transport is temporarily disabled by default
+     * on Linux.
+     *
+     * @see {@link isSyncActive}
+     * @see {@link stopSync | stopSync()}
      */
-    abstract update(closure: (documents: MutableDocument[]) => void): Promise<UpdateResultsMap>;
-    /** The query the receiver is operating with. */
-    readonly query: string;
-    /** The named arguments for the {@link query}. */
-    readonly queryArgs: QueryArguments | null;
-    /** The collection the receiver is operating on. */
-    readonly collection: CollectionInterface;
+    startSync(): void;
     /**
-     * Sorts the documents that match the query provided in the preceding
-     * `find`-like function call.
-     *
-     * @param query The query specifies the logic to be used when sorting the
-     * matching documents.
+     * Stops all network transports.
      *
-     * @param direction Specify whether you want the sorting order to be
-     * `Ascending` or `Descending`.
+     * You may continue to use the database locally but no data will sync to or
+     * from other devices.
      *
-     * @return A cursor that you can chain further function calls and then either
-     * get the matching documents immediately or get updates about them over time.
+     * @see {@link isSyncActive}
+     * @see {@link startSync | startSync()}
      */
-    sort(propertyPath: string, direction?: SortDirection): BasePendingCursorOperation;
+    stopSync(): void;
     /**
-     * Offsets the resulting set of matching documents.
+     * Registers an observer for info about Ditto peers in range of this device.
      *
-     * This is useful if you aren't interested in the first N matching documents
-     * for one reason or another. For example, you might already have queried the
-     * collection and obtained the first 20 matching documents and so you might
-     * want to run the same query as you did previously but ignore the first 20
-     * matching documents, and that is when you would use `offset`.
+     * Ditto will prevent the process from exiting as long as there are active
+     * peers observers (not relevant when running in the browser).
      *
-     * @param offset The number of matching documents that you want the eventual
-     * resulting set of matching documents to be offset by (and thus not include).
+     * @param callback called immediately with the current state of peers
+     * in range and whenever that state changes. Then it will be invoked
+     * repeatedly when Ditto devices come and go, or the active connections to
+     * them change.
      *
-     * @return A cursor that you can chain further function calls and then either
-     * get the matching documents immediately or get updates about them over time.
+     * @deprecated please use {@link Presence.observe | presence.observe()} instead.
      */
-    offset(offset: number): BasePendingCursorOperation;
+    observePeers(callback: (peersData: RemotePeer[]) => void): Observer;
     /**
-     * Limits the number of documents that get returned when querying a collection
-     * for matching documents.
+     * Register observer for changes of underlying transport conditions.
      *
-     * @param limit The maximum number of documents that will be returned.
+     * Ditto will prevent the process from exiting as long as there are active
+     * transport conditions observers (not relevant when running in the browser).
      *
-     * @return A cursor that you can chain further function calls and then either
-     * get the matching documents immediately or get updates about them over time.
+     * @param callback called when underlying transport conditions change with
+     * the changed `condition` and it's `source`.
      */
-    limit(limit: number): BasePendingCursorOperation;
+    observeTransportConditions(callback: (condition: TransportCondition, source: ConditionSource) => void): Observer;
     /**
-     * Executes the query generated by the preceding function chaining and return
-     * the list of matching documents.
+     * Removes all sync metadata for any remote peers which aren't currently
+     * connected. This method shouldn't usually be called. Manually running
+     * garbage collection often will result in slower sync times. Ditto
+     * automatically runs a garbage a collection process in the background at
+     * optimal times.
      *
-     * @returns An array promise containing {@link Document | documents} matching
-     * the query generated by the preceding function chaining.
+     * Manually running garbage collection is typically only useful during testing
+     * if large amounts of data are being generated. Alternatively, if an entire
+     * data set is to be evicted and it's clear that maintaining this metadata
+     * isn't necessary, then garbage collection could be run after evicting the
+     * old data.
+     *
+     * Only available in Node environments at the moment, no-op in the browser.
      */
-    exec(): Promise<Document[]>;
+    runGarbageCollection(): void;
     /**
-     * Updates documents that match the query generated by the preceding function
-     * chaining.
+     * Explicitly opt-in to disabling the ability to sync with Ditto peers running
+     * any version of the SDK in the v3 (or lower) series of releases.
      *
-     * @param closure A closure that gets called with all of the documents
-     * matching the query. The documents are instances of {@link MutableDocument}
-     * so you can call update-related functions on them.
-     * @param writeTransactionX  a transaction to perform the operation in.
+     * Assuming this succeeds then this peer will only be able to sync with other
+     * 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.
+     */
+    disableSyncWithV3(): void;
+    /**
+     * Shut down Ditto and release all resources.
      *
-     * @returns An {@link UpdateResultsMap} promise mapping document IDs to lists
-     * of {@link UpdateResult | update results} that describe the updates that
-     * were performed for each document.
-     * @internal
+     * Must be called before recreating a Ditto instance that uses the same
+     * persistence directory.
      */
-    updateWithTransaction(closure: (documents: MutableDocument[]) => void, writeTransactionX: Pointer<FFIWriteTransaction>): Promise<UpdateResultsMap>;
-    /** @internal */
-    constructor(query: string, queryArgs: QueryArguments | null, collection: CollectionInterface);
-    /** @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 */
-    protected queryArgsCBOR: Uint8Array | null;
-    /** @internal */
-    protected currentLimit: number;
-    /** @internal */
-    protected currentOffset: number;
+    close(): Promise<void>;
     /** @internal */
-    protected orderBys: OrderBy[];
-}
-
-/**
- * An object that describes how a document's position in a live query's list of
- * matching documents has changed since the previous live query event.
- */
-interface LiveQueryMove {
+    keepAlive: KeepAlive;
     /**
-     * The index of the document in the list of matching documents from the
-     * previous live query event.
-     */
-    readonly from: number;
+     * The number of operations pending before the Ditto instance can be closed.
+     *
+     * For testing purposes only.
+     * @internal */
+    get numPendingOperations(): number;
     /**
-     * The index of the document in the list of matching documents from the new
-     * live query event.
-     */
-    readonly to: number;
-}
-/** @internal */
+     * Makes sure that the closure is executed only if the Ditto instance hasn't
+     * been closed yet.
+     *
+     * @param closure the synchronous closure to execute.
+     * @returns the result of the closure.
+     * @throws if the Ditto instance was closed before calling this method.
+     * @internal */
+    deferClose<T>(closure: () => T): T;
+    /**
+     * Makes sure that the closure is executed to completion before the Ditto
+     * instance is closed.
+     *
+     * Any calls to {@link close | `Ditto.close()`} will wait until the closure
+     * has completed before closing the Ditto instance.
+     *
+     * @param closure the asynchronous closure to execute.
+     * @returns the result of the closure.
+     * @throws if the Ditto instance was closed before calling this method.
+     * @internal */
+    deferCloseAsync<T>(closure: () => Promise<T>): Promise<T>;
+    private sync;
+    private _isClosed;
+    private deferCloseAllowed;
+    private isWebValid;
+    private isX509Valid;
+    private presenceManager;
+    private transportConditionsManager;
+    /** Set of pending operations that need to complete before the Ditto instance can be closed in a safe manner. */
+    private pendingOperations;
+    private authClientValidityChanged;
+    private validateIdentity;
+    private setSyncActive;
+    private makeDefaultTransportConfig;
+}
+/** @internal */
+declare const checkAPIs: (_globalObject?: Window | typeof globalThis) => boolean;
+
+/**
+ * Represents an attachment and can be used to insert the associated attachment
+ * into a document at a specific key-path. You can't instantiate an attachment
+ * directly, please use the {@link Collection.newAttachment | newAttachment()}
+ * method of {@link Collection} instead.
+ */
+declare class Attachment {
+    /** @internal */
+    readonly ditto: Ditto;
+    /** @internal */
+    readonly token: AttachmentToken;
+    /** The attachment's metadata. */
+    get metadata(): {
+        [key: string]: string;
+    };
+    /**
+     * Returns the attachment's data.
+     */
+    getData(): Promise<Uint8Array>;
+    /**
+     * Copies the attachment to the specified file path. Node-only,
+     * throws in the browser.
+     *
+     * @param path The path that the attachment should be copied to.
+     */
+    copyToPath(path: string): Promise<void>;
+    /** @internal */
+    constructor(ditto: Ditto, token: AttachmentToken);
+}
+
+/**
+ * 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 */
+    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 */
+    readonly ditto: Ditto;
+    /** @internal */
+    readonly token: AttachmentToken;
+    /** @internal */
+    readonly eventHandler: (attachmentFetchEvent: AttachmentFetchEvent) => void | null;
+    /** @internal */
+    constructor(ditto: Ditto, token: AttachmentToken, eventHandler?: (attachmentFetchEvent: AttachmentFetchEvent) => void);
+    private cancelTokenPromise;
+    private static finalizationRegistry;
+    private static stopWithContextInfo;
+}
+
+/**
+ * Used to subscribe to receive updates from remote peers about matching
+ * documents.
+ *
+ * While {@link Subscription} objects remain in scope they ensure that
+ * documents in the collection specified and that match the query provided will
+ * try to be kept up-to-date with the latest changes from remote peers.
+ */
+declare class Subscription {
+    /**
+     * The query that the subscription is based on.
+     */
+    readonly query: string;
+    /**
+     * Returns `true` if subscription has been explicitly cancelled, `false`
+     * otherwise.
+     */
+    readonly isCancelled = false;
+    /**
+     * The name of the collection that the subscription is based on.
+     */
+    get collectionName(): string;
+    /**
+     * Cancels a subscription and releases all associated resources.
+     */
+    cancel(): void;
+    /** @internal */
+    constructor(collection: Collection, query: string, queryArgsCBOR: Uint8Array | null, orderBys: OrderBy[], limit: number, offset: number);
+    /**
+     * The collection this subscription belongs to.
+     * @internal Because not exposed in any of the other SDKs (yet?).
+     */
+    readonly collection: Collection;
+    /**
+     * The corresponding named arguments for {@link query}, if any.
+     * @internal Because not exposed in any of the other SDKs (yet?).
+     */
+    readonly queryArgsCBOR: Uint8Array | null;
+    private static finalizationRegistry;
+    private static add;
+    private static remove;
+    private contextInfo;
+}
+
+/**
+ * The type that is returned when calling
+ * {@link PendingCursorOperation.observeLocal | observeLocal()} on a
+ * {@link PendingCursorOperation} object. It handles the logic for calling the
+ * event handler that is provided to `observeLocal()` calls.
+ *
+ * Ditto will prevent the process from exiting as long as there are active live
+ * queries (not relevant when running in the browser).
+ *
+ * `LiveQuery` objects must be kept in scope for as long as you wish to have
+ * your event handler be called when there is an update to a document matching
+ * the query you provide. When you no longer want to receive updates about
+ * documents matching a query then you must call {@link stop | stop()}.
+ */
+declare class LiveQuery {
+    /** The query that the live query is based on. */
+    readonly query: string;
+    /** The arguments belonging to {@link query}. */
+    readonly queryArgs: QueryArguments | null;
+    /** The name of the collection that the live query is based on. */
+    get collectionName(): string;
+    /** Returns true if the receiver has been stopped. */
+    get isStopped(): boolean;
+    /**
+     * Stop the live query from delivering updates.
+     */
+    stop(): void;
+    /** @internal */
+    readonly limit: number;
+    /** @internal */
+    readonly offset: number;
+    /** @internal */
+    readonly collection: Collection;
+    /** @internal */
+    readonly subscription?: Subscription;
+    /** @internal */
+    readonly handler: QueryObservationHandler;
+    /** @internal */
+    constructor(query: string, queryArgs: QueryArguments | null, queryArgsCBOR: Uint8Array | null, orderBys: OrderBy[], limit: number, offset: number, collection: Collection, subscription: Subscription | null, handler: QueryObservationHandler);
+    /** @internal */
+    signalNext(): Promise<void>;
+    private orderBys;
+    private queryArgsCBOR;
+    private liveQueryID;
+}
+
+/**
+ * An object that describes how a document's position in a live query's list of
+ * matching documents has changed since the previous live query event.
+ */
+interface LiveQueryMove {
+    /**
+     * The index of the document in the list of matching documents from the
+     * previous live query event.
+     */
+    readonly from: number;
+    /**
+     * The index of the document in the list of matching documents from the new
+     * live query event.
+     */
+    readonly to: number;
+}
+/** @internal */
 interface LiveQueryEventUpdateParams {
     oldDocuments: Document[];
     insertions: number[];
@@ -1673,21 +2034,79 @@ declare class PendingCursorOperation extends BasePendingCursorOperation {
 }
 
 /**
- * The closure that is called whenever a single documunent covered by a
- * live query changes.
- */
-type SingleObservationHandler = (document: Document | null, event: SingleDocumentLiveQueryEvent, signalNext?: () => void) => void | Promise<void>;
-/**
- * These objects are returned when using {@link Collection.findByID | findByID()}
- * functionality on {@link Collection | collections}.
+ * These objects are returned when using
+ * {@link Collection.findByID | findByID()} functionality on
+ * {@link Collection | collections}.
  *
  * You can either call {@link exec | exec()} on the  object to get an immediate
- * return value, or you can establish either a live query or a subscription,
- * which both work over time.
+ * return value, or chain calls to update, evict or remove the document.
  *
- * A live query, established by calling
- * {@link PendingIDSpecificOperation.observeLocal | observeLocal()}, will notify
- * you every time there's an update to the document with the ID you provided in
+ * Live queries and subscriptions are only available outside of a transaction.
+ */
+declare abstract class BasePendingIDSpecificOperation implements PromiseLike<Document | undefined> {
+    /**
+     * Removes the document with the matching ID.
+     *
+     * @returns `true` promise if the document was found and removed. `false`
+     * promise if the document wasn't found and therefore wasn't removed.
+     */
+    abstract remove(): Promise<boolean>;
+    /**
+     * Evicts the document with the matching ID.
+     *
+     * @returns `true` promise if the document was found and evicted. `false`
+     * promise if the document wasn't found and therefore wasn't evicted.
+     */
+    abstract evict(): Promise<boolean>;
+    /**
+     * Updates the document with the matching ID.
+     *
+     * @param closure A closure that gets called with the document matching the
+     * ID. If found, the document is a {@link MutableDocument}, so you can call
+     * update-related functions on it. If the document is not found then the value
+     * provided to the closure will be `undefined`.
+     *
+     * @return An array promise of {@link UpdateResult | update results} that
+     * describe the updates that were performed on the document.
+     */
+    abstract update(closure: (document: MutableDocument) => void): Promise<UpdateResult[]>;
+    /** The ID of the document this operation operates on. */
+    readonly documentID: DocumentID;
+    /** The collection the receiver is operating on. */
+    readonly collection: CollectionInterface;
+    /**
+     * Executes the find operation to return the document with the matching ID.
+     *
+     * @returns The {@link Document} promise with the ID provided in the
+     * {@link Collection.findByID | findByID()} call or `undefined` if the document was
+     * not found.
+     */
+    exec(): Promise<Document | undefined>;
+    /** @internal */
+    constructor(documentID: DocumentID, collection: CollectionInterface);
+    /** @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 */
+    get query(): string;
+    protected documentIDCBOR: Uint8Array;
+}
+
+/**
+ * The closure that is called whenever a single documunent covered by a
+ * live query changes.
+ */
+type SingleObservationHandler = (document: Document | null, event: SingleDocumentLiveQueryEvent, signalNext?: () => void) => void | Promise<void>;
+/**
+ * These objects are returned when using {@link Collection.findByID | findByID()}
+ * functionality on {@link Collection | collections}.
+ *
+ * You can either call {@link exec | exec()} on the  object to get 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 PendingIDSpecificOperation.observeLocal | observeLocal()}, will notify
+ * you every time there's an update to the document with the ID you provided in
  * the preceding {@link Collection.findByID | findByID()} call.
  *
  * A subscription, established by calling {@link PendingIDSpecificOperation.subscribe | subscribe()}, will
@@ -2101,6 +2520,8 @@ declare class ExperimentalStore {
      * @returns a promise for an array of Ditto documents matching the query
      **/
     execute(query: string): Promise<Document[]>;
+    /** @internal */
+    close(): void;
 }
 
 /**
@@ -2147,782 +2568,346 @@ declare class WriteTransactionPendingIDSpecificOperation extends BasePendingIDSp
  * Create a `WriteTransactionCollection` by starting a {@link WriteTransaction}
  * and using its `scoped` method.
  */
-declare class WriteTransactionCollection implements CollectionInterface {
-    /** The name of the collection. */
-    readonly name: string;
-    /**
-     * The store this collection belongs to.
-     * @internal
-     */
-    readonly store: Store;
-    /**
-     * The write transaction within which this collection instance is used.
-     * @internal
-     */
-    readonly writeTransaction: WriteTransaction;
-    /**
-     * Search for documents in this collection using the provided query string.
-     *
-     * The returned cursor operation can be used to chain operations on the
-     * resulting document set.
-     *
-     * @param query The query to run against the collection.
-     * @param queryArgs These arguments replace placeholders in the provided
-     * query.
-     */
-    find(query: string, queryArgs?: QueryArguments | undefined): WriteTransactionPendingCursorOperation;
-    /**
-     * Convenience method, equivalent to calling {@link find | find()} and passing
-     * the query `"true"`.
-     */
-    findAll(): WriteTransactionPendingCursorOperation;
-    /**
-     * Generates a {@link WriteTransactionPendingIDSpecificOperation} with the
-     * provided document ID.
-     *
-     * The returned object can be used to find and return the document. It can also be used to update, remove or evict the document.
-     *
-     * @param id The ID of the document to find.
-     */
-    findByID(id: any): WriteTransactionPendingIDSpecificOperation;
-    upsert(value: DocumentValue, options?: UpsertOptions): Promise<DocumentID>;
-    /**
-     * See comment in {@link CollectionInterface.findByIDCBOR()}
-     *
-     * @internal */
-    findByIDCBOR(idCBOR: Uint8Array): WriteTransactionPendingIDSpecificOperation;
-    /**
-     * This constructor is marked internal because write transaction collections
-     * should be created from a {@link WriteTransaction} instance.
-     *
-     * @internal */
-    constructor(name: string, store: Store, writeTransaction: WriteTransaction);
-}
-
-/**
- * Provides information about the result of an operation on a document that was
- * part of a write transaction.
- *
- * The write transaction result can be one of the following types:
- *
- * - `inserted`
- * - `removed`
- * - `evicted`
- * - `updated`
- *
- * Please note that an `upsert` operation always results in the result type
- * `inserted`, regardless of whether it resulted in an update or insert.
- */
-interface WriteTransactionResult {
-    type: 'inserted' | 'removed' | 'evicted' | 'updated';
-    docID: DocumentID;
-    collectionName: string;
-}
-/**
- * Perform writes in a transaction.
- *
- * Create a write transaction using {@link Store.write | ditto.store.write}.
- */
-declare class WriteTransaction {
-    /** @internal */
-    readonly writeTransactionPointer: Pointer<FFIWriteTransaction>;
-    /** @internal */
-    readonly ditto: Ditto;
-    readonly results: WriteTransactionResult[];
-    /**
-     * Initialise a write transaction given a Ditto instance.
-     *
-     * This is not implemented as a constructor in order to be able to use FFI
-     * async functions. Users start transactions through {@link Store.write}.
-     *
-     * @param ditto an instance of Ditto
-     * @internal
-     */
-    static init(ditto: Ditto): Promise<WriteTransaction>;
-    /**
-     * Creates a transaction-specific
-     * {@link WriteTransactionCollection | collection} object that will ensure
-     * that operations called on it are all in the context of the collection name
-     * provided to this function. You can create many
-     * {@link WriteTransactionCollection | collection} objects per
-     * {@link WriteTransaction} object.
-     * */
-    scoped(toCollectionNamed: string): WriteTransactionCollection;
-    /** @internal */
-    commit(): Promise<void>;
-    /** @internal */
-    rollback(): Promise<void>;
-    /**
-     * Adds an entry to the list of results that is returned at the end of a
-     * transaction.
-     *
-     * @internal */
-    addResult(type: WriteTransactionResult['type'], docID: DocumentID, collectionName: string): void;
-    /** @internal */
-    constructor(ditto: Ditto, cTransaction: Pointer<FFIWriteTransaction>);
-}
-
-/**
- * The entrypoint for all actions that relate to data stored by Ditto. Provides
- * access to collections, a write transaction API, and a query hash API.
- *
- * You don't create one directly but can access it from a particular
- * {@link Ditto} instance via its {@link Ditto.store | store} property.
- */
-declare class Store {
-    /** The {@link Ditto} instance this store belongs to. */
-    readonly ditto: Ditto;
-    /** @internal */
-    readonly experimental: ExperimentalStore;
-    /**
-     * Returns the collection for the given name. If the collection doesn't
-     * exist yet, it will be created automatically as soon as the first
-     * entry is inserted.
-     */
-    collection(name: string): Collection;
-    /**
-     * Returns an object that lets you fetch or observe the collections in the
-     * store.
-     *
-     * @return A {@link PendingCollectionsOperation} object that you can use to
-     * fetch or observe the collections in the store
-     */
-    collections(): PendingCollectionsOperation;
-    /**
-     * Returns the names of all available collections in the store of the
-     * related {@link Ditto} instance.
-     */
-    collectionNames(): Promise<string[]>;
-    /**
-     * Initiate a write transaction in a callback.
-     *
-     * Allows you to group multiple operations together that affect multiple documents, potentially across multiple collections.
-     *
-     * @param callback is given access to a {@link WriteTransaction | write transaction object} that can be used to perform operations on the store.
-     * @returns a list of `WriteTransactionResult`s. There is a result for each operation performed as part of the write transaction.
-     */
-    write(callback: (transaction: WriteTransaction) => Promise<void>): Promise<WriteTransactionResult[]>;
-    /** @internal */
-    constructor(ditto: Ditto);
-    /**
-     * Private method, used only by the Portal https://github.com/getditto/ditto/pull/3652
-     * @internal
-     */
-    registerLiveQueryWebhook(collectionName: string, query: string, url: string): Promise<DocumentID>;
-}
-
-/** 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: string;
-    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. */
-    id: string;
-    /** Type of transport enabling this connection. */
-    type: ConnectionType;
-    /** The peer key of the peer at one end of the connection. */
-    peer1: Uint8Array;
-    /** The peer key of the peer at one end of the connection. */
-    peer2: Uint8Array;
-    approximateDistanceInMeters?: number;
-};
-/** An instance of Ditto taking part in the Ditto mesh network. */
-type Peer = {
-    /**
-     * Address to contact this peer via Ditto Bus, unique with a Ditto mesh
-     * network.
-     */
-    address: Address;
-    /**
-     * The peer key is a unique identifier for a given peer, equal to or derived
-     * from the cryptographic public key used to authenticate it.
-     *
-     * NOTE: This will be be empty when a peer is not updated to the latest
-     * version of the SDK.
-     */
-    peerKey: Uint8Array;
-    /**
-     * The human-readable device name of the peer. This defaults to the hostname
-     * but can be manually set by the application developer of the other peer.
-     * It is not necessarily unique.
-     */
-    deviceName: string;
-    /**
-     * Currently active connections of the peer.
-     */
-    connections: Connection[];
-    /**
-     * Indicates whether the peer is connected to Ditto Cloud.
-     */
-    isConnectedToDittoCloud: boolean;
-    /** The operating system the peer is running on, `undefined` if (yet) unknown. */
-    os?: string;
-    /** The Ditto SDK version the peer is running with, `undefined` if (yet) unknown. */
-    dittoSDKVersion?: string;
-};
-/**
- * Represents the Ditto mesh network of peers and their connections between each
- * other. The `localPeer` is the entry point, all others are remote peers known
- * by the local peer (either directly or via other remote peers).
- */
-type PresenceGraph = {
-    /**
-     * Returns the local peer (usually the peer that is represented by the
-     * currently running Ditto instance). The `localPeer` is the entry point, all
-     * others are remote peers known by the local peer (either directly or via
-     * other remote peers).
-     */
-    localPeer: Peer;
-    /**
-     * Returns all remote peers known by the `localPeer`, either directly or via
-     * other remote peers.
-     */
-    remotePeers: Peer[];
-    /**
-     * Returns the underlying CBOR data if the presence graph has been initialized
-     * with CBOR. All of Ditto API returning a presence graph has this property
-     * set.
-     */
-    underlyingCBOR?: Uint8Array;
-};
-/**
- * The entrypoint for all actions that relate presence of other peers known by
- * the current peer, either directly or through other peers.
- *
- * You don't create one directly but can access it from a particular `Ditto`
- * instance via its `presence` property.
- */
-declare class Presence {
-    /** The Ditto instance this object belongs to. */
-    readonly ditto: Ditto;
-    /**
-     * Returns the current presence graph capturing all known peers and
-     * connections between them.
-     */
-    get graph(): PresenceGraph;
-    /**
-     * Request information about Ditto peers in range of this device.
-     *
-     * This method returns an observer which should be held as long as updates are
-     * required. A newly registered observer will have a peers update delivered to
-     * it immediately. From then on it will be invoked repeatedly when Ditto
-     * devices come and go, or the active connections to them change.
-     */
-    observe(didChangeHandler: (presenceGraph: PresenceGraph) => void): Observer;
-    /** @internal */
-    constructor(ditto: Ditto);
-    private observerManager;
-}
-
-/** Types of connections that can be established between two peers. */
-type TransportCondition = 'Unknown' | 'OK' | 'GenericFailure' | 'AppInBackground' | 'MDNSFailure' | 'TCPListenFailure' | 'NoBLECentralPermission' | 'NoBLEPeripheralPermission' | 'CannotEstablishConnection' | 'BLEDisabled' | 'NoBLEHardware' | 'WiFiDisabled' | 'TemporarilyUnavailable';
-/** The source for a transport condition. */
-type ConditionSource = 'BLE' | 'TCP' | 'AWDL' | 'MDNS';
-/**
- * Types of connections that can be established between two peers.
- * @deprecated replaced by {@link ConnectionType}.
- */
-type PresenceConnectionType = 'WiFi' | 'WebSocket' | 'AWDL' | 'BLE';
-/**
- * A peer object with information about an observed peer.
- * @deprecated replaced by {@link Peer}.
- */
-type RemotePeer = {
-    networkID: string;
-    deviceName: string;
-    rssi?: number;
-    approximateDistanceInMeters?: number;
-    connections: PresenceConnectionType[];
-};
-/**
- * Ditto is the entry point for accessing Ditto-related functionality.
- */
-declare class Ditto {
-    /**
-     * Configure a custom identifier for the current device.
-     *
-     * When using {@link Presence.observe | presence.observe()}, each remote peer is
-     * represented by a short UTF-8 "device name". By default this will be a
-     * truncated version of the device's hostname. It does not need to be unique
-     * among peers. Configure the device name before calling
-     * {@link startSync | startSync()}. If it is too long it may be truncated.
-     */
-    deviceName: string;
-    /** Returns a string identifying the version of the Ditto SDK. */
-    get sdkVersion(): string;
-    /**
-     * The (validated) identity this Ditto instance was initialized with.
-     */
-    readonly identity: Identity;
-    /**
-     * The path this Ditto instance was initialized with, if no path was given at
-     * construction time, the default value is returned (see constructor).
-     */
-    readonly path: string;
-    /**
-     * Provides access to the SDK's store functionality.
-     */
-    readonly store: Store;
-    /**
-     * Provides access to the SDK's presence functionality.
-     */
-    readonly presence: Presence;
-    /**
-     * Provides access to authentication methods for logging on to Ditto Cloud.
-     */
-    readonly auth: Authenticator;
-    /**
-     * The site ID that the instance of `Ditto` is using as part of its identity.
-     */
-    readonly siteID: number | BigInt;
-    /**
-     * Returns `true` if an offline license token has been set, otherwise returns `false`.
-     *
-     * @see {@link setOfflineOnlyLicenseToken | setOfflineOnlyLicenseToken()}
-     */
-    readonly isActivated: 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;
-    /**
-     * Initializes a new `Ditto` instance.
-     *
-     * **NOTE**: The `sharedKey` identity is only supported for Node environments,
-     * using this to create a Ditto instance in the web browser will throw an
-     * exception.
-     *
-     * @param identity - Identity for the new Ditto instance, defaults to
-     * `offlinePlayground` with `appID` being the empty string `''`.
-     *
-     * @param path - On Node, `path` corresponds to a real directory
-     * on the file system (intermediate directories are created if needed). In the
-     * browser, `path` is used as an internal namespace for the in-memory storage.
-     * Defaults to `"ditto"`.
-     *
-     * @see {@link Ditto.identity}
-     * @see {@link Ditto.path}
-     */
-    constructor(identity?: Identity, path?: string);
-    /**
-     * Check if the current environment supports running Ditto.
-     *
-     * Required APIs include:
-     *
-     * - `BigInt`
-     * - `FinalizationRegistry`
-     * - `WeakRef`
-     *
-     *  Internet Explorer is not supported.
-     *
-     * @returns true if the environment is supported
-     */
-    static isEnvironmentSupported(): boolean;
+declare class WriteTransactionCollection implements CollectionInterface {
+    /** The name of the collection. */
+    readonly name: string;
     /**
-     * Activate a `Ditto` instance by setting an offline only license token. You cannot initiate sync
-     * with `Ditto` before you have activated it. The offline license token is only valid for identities
-     * of type `development`, `manual`, `offlinePlayground`, and `sharedKey`.
-     *
-     * @param licenseToken the license token to activate the `Ditto` instance
-     * with. You can find yours on the [Ditto portal](https://portal.ditto.live).
+     * The store this collection belongs to.
+     * @internal
      */
-    setOfflineOnlyLicenseToken(licenseToken: string): void;
+    readonly store: Store;
     /**
-     * Returns the current transport configuration, frozen. If you want to modify
-     * the transport config, make a {@link TransportConfig.copy | copy} first. Or
-     * use the {@link updateTransportConfig | updateTransportConfig()}
-     * convenience method. By default peer-to-peer transports (Bluetooth, WiFi,
-     * and AWDL) are enabled if available in the current environment
-     * (Web, Node, OS, etc.).
-     *
-     * @see {@link setTransportConfig | setTransportConfig()}
-     * @see {@link updateTransportConfig | updateTransportConfig()}
+     * The write transaction within which this collection instance is used.
+     * @internal
      */
-    readonly transportConfig: TransportConfig;
+    readonly writeTransaction: WriteTransaction;
     /**
-     * Assigns a new transports configuration. By default peer-to-peer transports
-     * (Bluetooth, WiFi, and AWDL) are enabled. You may use this method to alter
-     * the configuration at any time, however sync will not begin until
-     * {@link startSync | startSync()} is called.
+     * Search for documents in this collection using the provided query string.
      *
-     * @see {@link transportConfig}
-     * @see {@link updateTransportConfig | updateTransportConfig()}
+     * The returned cursor operation can be used to chain operations on the
+     * resulting document set.
+     *
+     * @param query The query to run against the collection.
+     * @param queryArgs These arguments replace placeholders in the provided
+     * query.
      */
-    setTransportConfig(transportConfig: TransportConfig): void;
+    find(query: string, queryArgs?: QueryArguments | undefined): WriteTransactionPendingCursorOperation;
     /**
-     * Convenience method for updating the transport config. Creates a copy of the
-     * current transport config, passes that copy to the `update` closure,
-     * allowing it to mutate as needed, and sets that updated copy afterwards.
+     * Convenience method, equivalent to calling {@link find | find()} and passing
+     * the query `"true"`.
      */
-    updateTransportConfig(update: (transportConfig: TransportConfig) => void): Ditto;
+    findAll(): WriteTransactionPendingCursorOperation;
     /**
-     * Starts the network transports. Ditto will connect to other devices.
-     *
-     * By default Ditto will enable all peer-to-peer transport types. On **Node**,
-     * this means BluetoothLE, WiFi/LAN, and AWDL. On the **Web**, only connecting
-     * via  Websockets is supported. The network configuration can be
-     * customized with {@link updateTransportConfig | updateTransportConfig()}
-     * or replaced entirely with {@link setTransportConfig | setTransportConfig()}.
-     *
-     *
-     * Ditto will prevent the process from exiting until sync is stopped (not
-     * relevant when running in the browser).
+     * Generates a {@link WriteTransactionPendingIDSpecificOperation} with the
+     * provided document ID.
      *
-     * **NOTE**: the BluetoothLE transport on Linux is experimental, this
-     * method panics if no BluetoothLE hardware is available. Therefore, contrary
-     * to the above, the BluetoothLE transport is temporarily disabled by default
-     * on Linux.
+     * The returned object can be used to find and return the document. It can also be used to update, remove or evict the document.
      *
-     * @see {@link isSyncActive}
-     * @see {@link stopSync | stopSync()}
+     * @param id The ID of the document to find.
      */
-    startSync(): void;
+    findByID(id: any): WriteTransactionPendingIDSpecificOperation;
+    upsert(value: DocumentValue, options?: UpsertOptions): Promise<DocumentID>;
     /**
-     * Stops all network transports.
-     *
-     * You may continue to use the database locally but no data will sync to or
-     * from other devices.
+     * See comment in {@link CollectionInterface.findByIDCBOR()}
      *
-     * @see {@link isSyncActive}
-     * @see {@link startSync | startSync()}
-     */
-    stopSync(): void;
+     * @internal */
+    findByIDCBOR(idCBOR: Uint8Array): WriteTransactionPendingIDSpecificOperation;
     /**
-     * Registers an observer for info about Ditto peers in range of this device.
-     *
-     * Ditto will prevent the process from exiting as long as there are active
-     * peers observers (not relevant when running in the browser).
-     *
-     * @param callback called immediately with the current state of peers
-     * in range and whenever that state changes. Then it will be invoked
-     * repeatedly when Ditto devices come and go, or the active connections to
-     * them change.
+     * This constructor is marked internal because write transaction collections
+     * should be created from a {@link WriteTransaction} instance.
      *
-     * @deprecated please use {@link Presence.observe | presence.observe()} instead.
-     */
-    observePeers(callback: (peersData: RemotePeer[]) => void): Observer;
+     * @internal */
+    constructor(name: string, store: Store, writeTransaction: WriteTransaction);
+}
+
+/**
+ * Provides information about the result of an operation on a document that was
+ * part of a write transaction.
+ *
+ * The write transaction result can be one of the following types:
+ *
+ * - `inserted`
+ * - `removed`
+ * - `evicted`
+ * - `updated`
+ *
+ * Please note that an `upsert` operation always results in the result type
+ * `inserted`, regardless of whether it resulted in an update or insert.
+ */
+interface WriteTransactionResult {
+    type: 'inserted' | 'removed' | 'evicted' | 'updated';
+    docID: DocumentID;
+    collectionName: string;
+}
+/**
+ * Perform writes in a transaction.
+ *
+ * Create a write transaction using {@link Store.write | ditto.store.write}.
+ */
+declare class WriteTransaction {
+    /** @internal */
+    readonly writeTransactionPointer: Pointer<FFIWriteTransaction>;
+    /** @internal */
+    readonly ditto: Ditto;
+    readonly results: WriteTransactionResult[];
     /**
-     * Register observer for changes of underlying transport conditions.
+     * Initialise a write transaction given a Ditto instance.
      *
-     * Ditto will prevent the process from exiting as long as there are active
-     * transport conditions observers (not relevant when running in the browser).
+     * This is not implemented as a constructor in order to be able to use FFI
+     * async functions. Users start transactions through {@link Store.write}.
      *
-     * @param callback called when underlying transport conditions change with
-     * the changed `condition` and it's `source`.
+     * @param ditto an instance of Ditto
+     * @internal
      */
-    observeTransportConditions(callback: (condition: TransportCondition, source: ConditionSource) => void): Observer;
+    static init(ditto: Ditto): Promise<WriteTransaction>;
     /**
-     * Removes all sync metadata for any remote peers which aren't currently
-     * connected. This method shouldn't usually be called. Manually running
-     * garbage collection often will result in slower sync times. Ditto
-     * automatically runs a garbage a collection process in the background at
-     * optimal times.
-     *
-     * Manually running garbage collection is typically only useful during testing
-     * if large amounts of data are being generated. Alternatively, if an entire
-     * data set is to be evicted and it's clear that maintaining this metadata
-     * isn't necessary, then garbage collection could be run after evicting the
-     * old data.
-     *
-     * Only available in Node environments at the moment, no-op in the browser.
-     */
-    runGarbageCollection(): void;
+     * Creates a transaction-specific
+     * {@link WriteTransactionCollection | collection} object that will ensure
+     * that operations called on it are all in the context of the collection name
+     * provided to this function. You can create many
+     * {@link WriteTransactionCollection | collection} objects per
+     * {@link WriteTransaction} object.
+     * */
+    scoped(toCollectionNamed: string): WriteTransactionCollection;
+    /** @internal */
+    commit(): Promise<void>;
+    /** @internal */
+    rollback(): Promise<void>;
     /**
-     * Explicitly opt-in to disabling the ability to sync with Ditto peers running
-     * any version of the SDK in the v3 (or lower) series of releases.
+     * Adds an entry to the list of results that is returned at the end of a
+     * transaction.
      *
-     * Assuming this succeeds then this peer will only be able to sync with other
-     * 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.
-     */
-    disableSyncWithV3(): void;
+     * @internal */
+    addResult(type: WriteTransactionResult['type'], docID: DocumentID, collectionName: string): void;
     /** @internal */
-    keepAlive: KeepAlive;
-    private sync;
-    private isWebValid;
-    private isX509Valid;
-    private presenceManager;
-    private transportConditionsManager;
-    private authClientValidityChanged;
-    private validateIdentity;
-    private setSyncActive;
-    private makeDefaultTransportConfig;
+    constructor(ditto: Ditto, cTransaction: Pointer<FFIWriteTransaction>);
 }
-/** @internal */
-declare const checkAPIs: (_globalObject?: Window | typeof globalThis) => boolean;
 
 /**
- * Represents an attachment and can be used to insert the associated attachment
- * into a document at a specific key-path. You can't instantiate an attachment
- * directly, please use the {@link Collection.newAttachment | newAttachment()}
- * method of {@link Collection} instead.
+ * The entrypoint for all actions that relate to data stored by Ditto. Provides
+ * access to collections, a write transaction API, and a query hash API.
+ *
+ * You don't create one directly but can access it from a particular
+ * {@link Ditto} instance via its {@link Ditto.store | store} property.
  */
-declare class Attachment {
-    /** @internal */
+declare class Store {
+    /** The {@link Ditto} instance this store belongs to. */
     readonly ditto: Ditto;
     /** @internal */
-    readonly token: AttachmentToken;
-    /** The attachment's metadata. */
-    get metadata(): {
-        [key: string]: string;
-    };
-    /**
-     * Returns the attachment's data.
-     */
-    getData(): Promise<Uint8Array>;
+    readonly experimental: ExperimentalStore;
     /**
-     * Copies the attachment to the specified file path. Node-only,
-     * throws in the browser.
-     *
-     * @param path The path that the attachment should be copied to.
+     * Returns the collection for the given name. If the collection doesn't
+     * exist yet, it will be created automatically as soon as the first
+     * entry is inserted.
      */
-    copyToPath(path: string): Promise<void>;
-    /** @internal */
-    constructor(ditto: Ditto, token: AttachmentToken);
-}
-
-/** @internal */
-declare class StaticTCPClient {
-}
-
-/** @internal */
-declare class WebsocketClient {
-}
-
-/** @internal */
-declare class Bridge<JSClass extends object, FFIType> {
-    readonly release: (pointer: Pointer<FFIType>) => void;
+    collection(name: string): Collection;
     /**
-     * Creates a new bridge for objects of `type`. Requires a `release` function
-     * that is called whenever a registered object is garbage collected, passing
-     * the associated `pointer` to it. The release function is then responsible
-     * to free or drop the corresponding native object.
-     *
-     * **IMPORTANT**: The `type` of all bridges needs to be set in `epilogue.ts`
-     * after initiating the bridge instance. This helps avoid import cycles
-     * (otherwise anything importing the bridge instance, would also have to
-     * import the type, which usually leads to import cycles).
+     * Returns an object that lets you fetch or observe the collections in the
+     * store.
      *
-     * @internal
+     * @return A {@link PendingCollectionsOperation} object that you can use to
+     * fetch or observe the collections in the store
      */
-    constructor(release: (pointer: Pointer<FFIType>) => void, options?: {});
-    /** @internal */
-    get type(): Function;
+    collections(): PendingCollectionsOperation;
     /**
-     * Returns the FFI pointer for `object` if registered, otherwise returns
-     * `undefined`. If `object` has been unregistered before, returns
-     * `undefined`, too.
-     *
-     * @internal
+     * Returns the names of all available collections in the store of the
+     * related {@link Ditto} instance.
      */
-    pointerFor(object: JSClass): Pointer<FFIType> | undefined;
+    collectionNames(): Promise<string[]>;
     /**
-     * Convenience method, returns the object for the FFI `pointer` if registered,
-     * otherwise returns `undefined`. If the object associated with the `pointer`
-     * has been unregistered before, returns `undefined`, too.
+     * Initiate a write transaction in a callback.
      *
-     * @internal
-     */
-    objectFor(pointer: Pointer<FFIType>): JSClass | undefined;
-    /**
-     * Returns the object for the FFI `pointer` if registered. Otherwise, calls
-     * the passed in `create` function to create a new object, which it then
-     * returns after registering. If no `create` function is given, uses the
-     * type of the bridge as a constructor and creates a new instance of it
-     * without passing any parameters.
+     * Allows you to group multiple operations together that affect multiple documents, potentially across multiple collections.
      *
-     * @internal
+     * @param callback is given access to a {@link WriteTransaction | write transaction object} that can be used to perform operations on the store.
+     * @returns a list of `WriteTransactionResult`s. There is a result for each operation performed as part of the write transaction.
      */
-    bridge(pointer: Pointer<FFIType>, objectOrCreate?: object | (() => JSClass), options?: {}): JSClass;
-    /** @internal */
-    registerType(value: Function): void;
-    /** @internal */
-    register(object: JSClass, pointer: Pointer<FFIType>): void;
-    /** @internal */
-    unregister(object: JSClass): void;
-    /** @internal */
-    unregisterAll(): void;
-    /** @internal */
-    get count(): number;
-    /** @internal */
-    static readonly all: any[];
-    /** @internal */
-    static readonly attachment: Bridge<Attachment, "AttachmentHandle_t">;
-    /** @internal */
-    static readonly document: Bridge<Document, "CDocument_t">;
-    /** @internal */
-    static readonly mutableDocument: Bridge<MutableDocument, "CDocument_t">;
-    /** @internal */
-    static readonly staticTCPClient: Bridge<StaticTCPClient, "TransportHandle_StaticTCPClientPlatformEvent_t">;
+    write(callback: (transaction: WriteTransaction) => Promise<void>): Promise<WriteTransactionResult[]>;
     /** @internal */
-    static readonly websocketClient: Bridge<WebsocketClient, "TransportHandle_WebsocketClientPlatformEvent_t">;
+    constructor(ditto: Ditto);
     /** @internal */
-    static readonly ditto: Bridge<Ditto, "CDitto_t">;
-    private internalType;
-    private metaByAddrMap;
-    private finalizationRegistry;
-    private finalize;
-}
-
-/** @internal */
-declare class Value {
-    readonly value: unknown;
-    readonly isDefault: boolean;
-    constructor(value: unknown, options?: unknown);
-}
-
-/**
- * Available options for {@link init | init()}.
- */
-type InitOptions = {
+    close(): void;
     /**
-     * You can explicitly pass the WebAssembly module or its location via the
-     * `webAssemblyModule` option. By default, Ditto tries to load the WebAssembly
-     * module from the same path where this JavaScript is served.
+     * Private method, used only by the Portal https://github.com/getditto/ditto/pull/3652
+     * @internal
      */
-    webAssemblyModule?: WebAssemblyModule;
-};
-/**
- * Initializes the whole Ditto module. Needs to be called and complete before
- * any of the Ditto API is used.
- *
- * @param options - Dictionary with global {@link InitOptions | initialization options}.
- */
-declare function init(options?: InitOptions): Promise<void>;
+    registerLiveQueryWebhook(collectionName: string, query: string, url: string): Promise<DocumentID>;
+}
 
-/** The log levels supported by Ditto. */
-type LogLevel = 'Error' | 'Warning' | 'Info' | 'Debug' | 'Verbose';
-/**
- * Closure that {@link Logger.setCustomLogCallback} can be set as a custom
- * log callback on {@link Logger}.
- */
-type CustomLogCallback = (logLevel: LogLevel, message: string) => void;
-/**
- * Class with static methods to customize the logging behavior from Ditto and
- * log messages with the Ditto logging infrastructure.
- */
-declare class Logger {
+type UpsertOptions = {
+    writeStrategy?: WriteStrategy;
+};
+interface CollectionInterface {
+    /** The name of the collection. */
+    readonly name: string;
     /**
-     * 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).
+     * The store this collection belongs to.
+     * @internal
      */
-    static readonly logFile?: string;
+    readonly store: Store;
     /**
-     * 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).
-     * In the browser, this method has no effect.
+     * Search for documents in this collection using the provided query string.
      *
-     * @param path can be `null`, in which case the current logging file, if any,
-     * is unregistered, otherwise, the file path must be within an already
-     * existing directory.
-     */
-    static setLogFile(path: string | null): void;
-    /**
-     * Convenience method, takes the path part of the URL and calls
-     * {@link setLogFile | setLogFile()} with it.
+     * @param query The query to run against the collection.
+     * @param queryArgs These arguments replace placeholders in the provided
+     * query.
      */
-    static setLogFileURL(url: URL | undefined): void;
-    /** Whether the logger is currently enabled. */
-    static get enabled(): boolean;
-    /** Enables or disables logging. */
-    static set enabled(enabled: boolean);
+    find(query: string, queryArgs?: QueryArguments): BasePendingCursorOperation;
     /**
-     * Represents whether or not emojis should be used as the log level
-     * indicator in the logs.
+     * Convenience method, equivalent to calling {@link find | find()} and passing
+     * the query `"true"`.
      */
-    static get emojiLogLevelHeadingsEnabled(): boolean;
+    findAll(): BasePendingCursorOperation;
     /**
-     * Represents whether or not emojis should be used as the log level
-     * indicator in the logs.
+     * Find documents given a specific ID.
+     *
+     * Use the returned cursor instance to chain operations on the search result.
+     *
+     * @param id The document's identifier
      */
-    static set emojiLogLevelHeadingsEnabled(emojiLogLevelHeadingsEnabled: boolean);
+    findByID(id: DocumentID | DocumentIDValue): BasePendingIDSpecificOperation;
     /**
-     * The minimum log level at which logs will be logged.
+     * TEMPORARY: helper to deal with non-canonical IDs.
      *
-     * For example if this is set to `Warning`, then only logs that are logged
-     * with the `Warning` or `Error` log levels will be shown.
+     * @internal
      */
-    static get minimumLogLevel(): LogLevel;
+    findByIDCBOR(idCBOR: Uint8Array): BasePendingIDSpecificOperation;
     /**
-     * The minimum log level at which logs will be logged.
+     * Inserts a new document into the collection and returns its ID. If the
+     * document already exists, the contents of both are merged by default. You
+     * can change this by providing a different `writeStrategy` via `options`.
      *
-     * For example if this is set to `Warning`, then only logs that are logged
-     * with the `Warning` or `Error` log levels will be shown.
+     * @param value The content of the document to be inserted or updated.
+     * @param options.writeStrategy Specifies the desired strategy for inserting a
+     * document, defaults to `'merge'`.
      */
-    static set minimumLogLevel(minimumLogLevel: LogLevel);
+    upsert(value: DocumentValue, options: UpsertOptions): Promise<DocumentID>;
+}
+
+declare abstract class BasePendingCursorOperation implements PromiseLike<Document[]> {
     /**
-     * Returns the current custom log callback, `undefined` by default. See
-     * {@link setCustomLogCallback | setCustomLogCallback()} for a detailed
-     * description.
+     * Removes all documents that match the query generated by the preceding
+     * function chaining.
+     *
+     * @returns An array promise containing the IDs of the documents that were
+     * removed.
      */
-    static readonly customLogCallback?: CustomLogCallback;
+    abstract remove(): Promise<DocumentID[]>;
     /**
-     * Registers a custom callback that will be called to report each log entry.
+     * Evicts all documents that match the query generated by the preceding
+     * function chaining.
      *
-     * @param callback function called for each log entry. `undefined` will
-     * unregister any previous callback and stop reporting log entries through
-     * callbacks.
+     * @return An array promise containing the IDs of the documents that were
+     * evicted.
      */
-    static setCustomLogCallback(callback: CustomLogCallback | undefined): Promise<void>;
+    abstract evict(): Promise<DocumentID[]>;
     /**
-     * Logs the message for the given `level`.
+     * Updates documents that match the query generated by the preceding function
+     * chaining.
      *
-     * @see {@link error | error()}
-     * @see {@link warning | warning()}
-     * @see {@link info | info()}
-     * @see {@link debug | debug()}
-     * @see {@link verbose | verbose()}
+     * @param closure A closure that gets called with all of the documents
+     * matching the query. The documents are instances of {@link MutableDocument}
+     * so you can call update-related functions on them.
+     *
+     * @returns An {@link UpdateResultsMap} promise mapping document IDs to lists
+     * of {@link UpdateResult | update results} that describe the updates that
+     * were performed for each document.
      */
-    static log(level: LogLevel, message: string): void;
+    abstract update(closure: (documents: MutableDocument[]) => void): Promise<UpdateResultsMap>;
+    /** The query the receiver is operating with. */
+    readonly query: string;
+    /** The named arguments for the {@link query}. */
+    readonly queryArgs: QueryArguments | null;
+    /** The collection the receiver is operating on. */
+    readonly collection: CollectionInterface;
     /**
-     * Convenience method, same as calling {@link log | log()} with
-     * {@link LogLevel} `Error`.
+     * Sorts the documents that match the query provided in the preceding
+     * `find`-like function call.
+     *
+     * @param query The query specifies the logic to be used when sorting the
+     * matching documents.
+     *
+     * @param direction Specify whether you want the sorting order to be
+     * `Ascending` or `Descending`.
+     *
+     * @return A cursor that you can chain further function calls and then either
+     * get the matching documents immediately or get updates about them over time.
      */
-    static error(message: string): void;
+    sort(propertyPath: string, direction?: SortDirection): BasePendingCursorOperation;
     /**
-     * Convenience method, same as calling {@link log | log()} with
-     * {@link LogLevel} `Warning`.
+     * Offsets the resulting set of matching documents.
+     *
+     * This is useful if you aren't interested in the first N matching documents
+     * for one reason or another. For example, you might already have queried the
+     * collection and obtained the first 20 matching documents and so you might
+     * want to run the same query as you did previously but ignore the first 20
+     * matching documents, and that is when you would use `offset`.
+     *
+     * @param offset The number of matching documents that you want the eventual
+     * resulting set of matching documents to be offset by (and thus not include).
+     *
+     * @return A cursor that you can chain further function calls and then either
+     * get the matching documents immediately or get updates about them over time.
      */
-    static warning(message: string): void;
+    offset(offset: number): BasePendingCursorOperation;
     /**
-     * Convenience method, same as calling {@link log | log()} with
-     * {@link LogLevel} `Info`.
+     * Limits the number of documents that get returned when querying a collection
+     * for matching documents.
+     *
+     * @param limit The maximum number of documents that will be returned.
+     *
+     * @return A cursor that you can chain further function calls and then either
+     * get the matching documents immediately or get updates about them over time.
      */
-    static info(message: string): void;
+    limit(limit: number): BasePendingCursorOperation;
     /**
-     * Convenience method, same as calling {@link log | log()} with
-     * {@link LogLevel} `Debug`.
+     * Executes the query generated by the preceding function chaining and return
+     * the list of matching documents.
+     *
+     * @returns An array promise containing {@link Document | documents} matching
+     * the query generated by the preceding function chaining.
      */
-    static debug(message: string): void;
+    exec(): Promise<Document[]>;
     /**
-     * Convenience method, same as calling {@link log | log()} with
-     * {@link LogLevel} `Verbose`.
+     * Updates documents that match the query generated by the preceding function
+     * chaining.
+     *
+     * @param closure A closure that gets called with all of the documents
+     * matching the query. The documents are instances of {@link MutableDocument}
+     * so you can call update-related functions on them.
+     * @param writeTransactionX  a transaction to perform the operation in.
+     *
+     * @returns An {@link UpdateResultsMap} promise mapping document IDs to lists
+     * of {@link UpdateResult | update results} that describe the updates that
+     * were performed for each document.
+     * @internal
      */
-    static verbose(message: string): void;
-    private constructor();
+    updateWithTransaction(closure: (documents: MutableDocument[]) => void, writeTransactionX: Pointer<FFIWriteTransaction>): Promise<UpdateResultsMap>;
+    /** @internal */
+    constructor(query: string, queryArgs: QueryArguments | null, collection: CollectionInterface);
+    /** @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 */
+    protected queryArgsCBOR: Uint8Array | null;
+    /** @internal */
+    protected currentLimit: number;
+    /** @internal */
+    protected currentOffset: number;
+    /** @internal */
+    protected orderBys: OrderBy[];
 }
 
+/**
+ * Get a count of bridged objects binned by bridge type.
+ *
+ * Use this in testing to ensure that all objects are properly garbage collected at the end of tests.
+ *
+ * @returns an object with a key per bridge type, containing the number of registered objects.
+ */
+declare function getBridgeLoad(): {
+    [bridgeName: string]: number;
+};
+
 /** @internal */
 declare class CBOR {
     /** @internal */
@@ -2931,5 +2916,5 @@ declare class CBOR {
     static decode(data: Uint8Array): any;
 }
 
-export { Address, Attachment, AttachmentFetchEvent, AttachmentFetchEventCompleted, AttachmentFetchEventDeleted, AttachmentFetchEventProgress, AttachmentFetchEventType, AttachmentFetcher, AttachmentToken, AuthenticationHandler, AuthenticationStatus, Authenticator, BasePendingCursorOperation, BasePendingIDSpecificOperation, Bridge, CBOR, Collection, CollectionInterface, CollectionsEvent, CollectionsEventParams, CollectionsObservationHandler, ConditionSource, Connection, ConnectionType, Counter, CustomLogCallback, Ditto, Document, DocumentID, DocumentIDValue, DocumentPath, DocumentValue, ExperimentalStore, Identity, IdentityManual, IdentityOfflinePlayground, IdentityOnlinePlayground, IdentityOnlineWithAuthentication, IdentitySharedKey, IdentityTypesRequiringOfflineLicenseToken, InitOptions, KeepAlive, LiveQuery, LiveQueryEvent, LiveQueryEventInitial, LiveQueryEventUpdate, LiveQueryEventUpdateParams, LiveQueryMove, LogLevel, Logger, MutableCounter, MutableDocument, MutableDocumentPath, MutableRegister, NotAvailableAuthenticator, Observer, ObserverOptions, OnlineAuthenticator, Peer, PendingCollectionsOperation, PendingCursorOperation, PendingIDSpecificOperation, Presence, PresenceConnectionType, PresenceGraph, QueryArguments, QueryObservationHandler, Register, RemotePeer, SingleDocumentLiveQueryEvent, SingleObservationHandler, SortDirection, Store, Subscription, TransportCondition, TransportConfig, TransportConfigConnect, TransportConfigGlobal, TransportConfigLan, TransportConfigListen, TransportConfigListenHTTP, TransportConfigListenTCP, TransportConfigPeerToPeer, UpdateResult, UpdateResultType, UpdateResultsMap, UpsertOptions, Value, WebAssemblyModule, WriteStrategy, WriteTransaction, WriteTransactionCollection, WriteTransactionPendingCursorOperation, WriteTransactionPendingIDSpecificOperation, WriteTransactionResult, addressToString, checkAPIs, init, 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, Ditto, Document, DocumentID, DocumentIDValue, DocumentPath, DocumentValue, ExperimentalStore, Identity, IdentityManual, IdentityOfflinePlayground, IdentityOnlinePlayground, IdentityOnlineWithAuthentication, IdentitySharedKey, IdentityTypesRequiringOfflineLicenseToken, InitOptions, KeepAlive, LiveQuery, LiveQueryEvent, LiveQueryEventInitial, LiveQueryEventUpdate, LiveQueryEventUpdateParams, LiveQueryMove, LogLevel, Logger, MutableCounter, MutableDocument, MutableDocumentPath, MutableRegister, NotAvailableAuthenticator, Observer, ObserverOptions, OnlineAuthenticator, Peer, PendingCollectionsOperation, PendingCursorOperation, PendingIDSpecificOperation, Presence, PresenceConnectionType, PresenceGraph, QueryArguments, QueryObservationHandler, Register, RemotePeer, SingleDocumentLiveQueryEvent, SingleObservationHandler, SortDirection, Store, Subscription, TransportCondition, TransportConfig, TransportConfigConnect, TransportConfigGlobal, TransportConfigLan, TransportConfigListen, TransportConfigListenHTTP, TransportConfigListenTCP, TransportConfigPeerToPeer, UpdateResult, UpdateResultType, UpdateResultsMap, UpsertOptions, Value, WebAssemblyModule, WriteStrategy, WriteTransaction, WriteTransactionCollection, WriteTransactionPendingCursorOperation, WriteTransactionPendingIDSpecificOperation, WriteTransactionResult, addressToString, checkAPIs, getBridgeLoad, init, validateDocumentIDCBOR, validateDocumentIDValue };
 //# sourceMappingURL=ditto.d.ts.map