@dittolive/ditto 4.0.3-alpha.linux-ble-fixes → 4.1.0

package/types/ditto.d.ts

@@ -18,8 +18,62 @@ declare class KeepAlive {
 }
 
 /** @internal */
-interface ObserverRemoving {
-    removeObserver(token: any): any;
+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;
+    hasObserver(token: ObserverToken): boolean;
+    /** @internal */
+    notify(...args: any[]): void;
+    /** @internal */
+    close(): 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 isClosed;
+    private isRegistered;
+    private callbacksByToken;
+    private constructorOptions;
+    private hasObservers;
+    private registerIfNeeded;
+    private unregisterIfNeeded;
+}
+
+/** @internal */
+interface ObserverManaging {
+    hasObserver(token: ObserverToken): any;
+    removeObserver(token: ObserverToken): any;
 }
 /** @internal */
 type ObserverOptions = {
@@ -33,13 +87,13 @@ type ObserverOptions = {
  */
 declare class Observer {
     /** @internal */
-    readonly observerManager: ObserverRemoving;
+    readonly observerManager: ObserverManaging;
     /** @internal */
-    readonly token?: any;
+    readonly token?: ObserverToken;
     /** @internal */
     readonly options?: ObserverOptions;
     /** @internal */
-    constructor(observerManager: ObserverRemoving, token: any, options?: ObserverOptions);
+    constructor(observerManager: ObserverManaging, token: any, options?: ObserverOptions);
     /**
      * Returns `true` if the observer has been explicitly stopped via the `stop()`
      * method. Otherwise returns `false`.
@@ -203,8 +257,6 @@ type Pointer<Type> = {
 /** @internal */
 type FFIWriteTransaction = 'CWriteTransaction_t';
 /** @internal */
-type FFIAuthClient = 'CAuthClient_t';
-/** @internal */
 type OrderBy = {
     query: string;
     direction: 'Ascending' | 'Descending';
@@ -869,56 +921,6 @@ declare class TransportConfig {
     static areListenHTTPsEqual(left: TransportConfigListenHTTP, right: TransportConfigListenHTTP): boolean;
 }
 
-/** @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.
  */
@@ -1019,6 +1021,8 @@ declare class Authenticator {
     /** @internal */
     '@ditto.authClientValidityChanged'(isWebValid: boolean, isX509Valid: boolean): void;
     /** @internal */
+    close(): void;
+    /** @internal */
     protected keepAlive: KeepAlive;
     /** @internal */
     protected observerManager: ObserverManager;
@@ -1028,15 +1032,12 @@ 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>;
-    readonly authClientPointer: Pointer<FFIAuthClient>;
     readonly authenticationHandler: AuthenticationHandler;
     private ditto;
-    constructor(keepAlive: KeepAlive, authClientPointer: Pointer<FFIAuthClient>, ditto: Ditto, authenticationHandler: AuthenticationHandler);
+    constructor(keepAlive: KeepAlive, ditto: Ditto, authenticationHandler: AuthenticationHandler);
     '@ditto.authenticationExpiring'(secondsRemaining: number): void;
     '@ditto.authClientValidityChanged'(isWebValid: boolean, isX509Valid: boolean): void;
     private updateAndNotify;
-    private static finalizationRegistry;
-    private static finalize;
 }
 /** @internal */
 declare class NotAvailableAuthenticator extends Authenticator {
@@ -1300,277 +1301,398 @@ declare class Presence {
     observe(didChangeHandler: (presenceGraph: PresenceGraph) => void): Observer;
     /** @internal */
     constructor(ditto: Ditto);
+    /** @internal */
+    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';
-/**
- * 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[];
+/** @internal */
+type SubscriptionContextInfo = {
+    id: string;
+    collectionName: string;
+    query: string;
+    queryArgsCBOR: Uint8Array | null;
+    orderBys: OrderBy[];
+    limit: number;
+    offset: number;
 };
 /**
- * Ditto is the entry point for accessing Ditto-related functionality.
+ * Tracks `Subscription` instances in order to remove them when Ditto is
+ * closed.
+ *
+ * @internal
  */
-declare class Ditto {
+declare class SubscriptionManager {
+    /** @internal */
+    constructor(ditto: Ditto);
     /**
-     * Configure a custom identifier for the current device.
+     * Begin tracking a subscription instance and start it.
      *
-     * 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.
+     * @internal */
+    add(subscription: Subscription): void;
+    /**
+     * Stop tracking a subscription instance and cancel it.
+     *
+     * @internal */
+    remove(subscription: Subscription): void;
+    /**
+     * Stop tracking all subscriptions and cancel them.
+     *
+     * @internal */
+    close(): void;
+    private ditto;
+    private subscriptions;
+    private finalizationRegistry;
+    /**
+     * Remove tracked subscription without unregistering from finalization
+     * registry.
+     *
+     * @internal */
+    private removeWithContextinfo;
+}
+
+/**
+ * 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.
      */
-    deviceName: string;
-    /** Returns a string identifying the version of the Ditto SDK. */
-    get sdkVersion(): string;
+    readonly query: string;
     /**
-     * The (validated) identity this Ditto instance was initialized with.
+     * Returns `true` if subscription has been explicitly cancelled, `false`
+     * otherwise.
      */
-    readonly identity: Identity;
+    readonly isCancelled = false;
     /**
-     * The path this Ditto instance was initialized with, if no path was given at
-     * construction time, the default value is returned (see constructor).
+     * The name of the collection that the subscription is based on.
      */
-    readonly path: string;
+    get collectionName(): string;
     /**
-     * Provides access to the SDK's store functionality.
+     * Cancels a subscription and releases all associated resources.
      */
-    readonly store: Store;
+    cancel(): void;
+    /** @internal */
+    constructor(collection: Collection, query: string, queryArgsCBOR: Uint8Array | null, orderBys: OrderBy[], limit: number, offset: number);
     /**
-     * Provides access to the SDK's presence functionality.
+     * The collection this subscription belongs to.
+     * @internal Because not exposed in any of the other SDKs (yet?).
      */
-    readonly presence: Presence;
+    readonly collection: Collection;
+    /** @internal */
+    private readonly manager;
     /**
-     * Provides access to authentication methods for logging on to Ditto Cloud.
+     * The corresponding named arguments for {@link query}, if any.
+     * @internal Because not exposed in any of the other SDKs (yet?).
      */
-    readonly auth: Authenticator;
+    readonly queryArgsCBOR: Uint8Array | null;
+    /** @internal */
+    readonly contextInfo: SubscriptionContextInfo;
+}
+
+/**
+ * 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 site ID that the instance of `Ditto` is using as part of its identity.
+     * The index of the document in the list of matching documents from the
+     * previous live query event.
      */
-    readonly siteID: number | BigInt;
+    readonly from: number;
     /**
-     * Returns `true` if an offline license token has been set, otherwise returns `false`.
-     *
-     * @see {@link setOfflineOnlyLicenseToken | setOfflineOnlyLicenseToken()}
+     * The index of the document in the list of matching documents from the new
+     * live query event.
      */
-    readonly isActivated: boolean;
+    readonly to: number;
+}
+/** @internal */
+interface LiveQueryEventUpdateParams {
+    oldDocuments: Document[];
+    insertions: number[];
+    deletions: number[];
+    updates: number[];
+    moves: LiveQueryMove[];
+}
+/**
+ * First event fired immediately after registering a live query without any
+ * mutations. All subsequent events are of type {@link LiveQueryEventUpdate}.
+ */
+declare class LiveQueryEventInitial {
     /**
-     * Returns `true` if sync is active, otherwise returns `false`. Use
-     * {@link startSync | startSync()} to activate and {@link stopSync | stopSync()}
-     * to deactivate sync.
+     * Whether or not this is the initial event being delivered. Always `true`
+     * for `LiveQueryEventInitial`.
      */
-    readonly isSyncActive: boolean;
+    readonly isInitial = true;
     /**
-     * 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}
+     * Returns a hash that represents the set of matching documents.
      */
-    constructor(identity?: Identity, path?: string);
+    hash(documents: Document[]): BigInt;
     /**
-     * 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
+     * Returns a pattern of words that together create a mnemonic, which
+     * represents the set of matching documents.
      */
-    static isEnvironmentSupported(): boolean;
+    hashMnemonic(documents: Document[]): string;
+}
+/**
+ * Represents an update event describing all changes that occured for documents
+ * covered by a (live) query.
+ */
+declare class LiveQueryEventUpdate {
     /**
-     * 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).
+     * Whether or not this is the initial event being delivered. Always `false`
+     * for `LiveQueryEventUpdate`.
      */
-    setOfflineOnlyLicenseToken(licenseToken: string): void;
+    readonly isInitial = false;
     /**
-     * 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 documents that previously matched the query, before the latest event.
      */
-    readonly transportConfig: TransportConfig;
+    readonly oldDocuments: Document[];
     /**
-     * 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.
-     *
-     * @see {@link transportConfig}
-     * @see {@link updateTransportConfig | updateTransportConfig()}
+     * The indexes in the array of matching documents that accompany this event,
+     * which relate to a document that was not in the previous most recent list of
+     * matching documents.
      */
-    setTransportConfig(transportConfig: TransportConfig): void;
+    readonly insertions: number[];
     /**
-     * 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.
+     * The indexes into the array {@link oldDocuments}, which relate to a document
+     * that was in the previous most recent list of matching documents but is no
+     * longer a matching document.
      */
-    updateTransportConfig(update: (transportConfig: TransportConfig) => void): Ditto;
+    readonly deletions: number[];
     /**
-     * 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).
-     *
-     * **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()}
+     * The indexes in the array of matching documents that accompany this event,
+     * which relate to a document that has been updated since the previous live
+     * query event.
      */
-    startSync(): void;
+    readonly updates: number[];
     /**
-     * Stops all network transports.
-     *
-     * You may continue to use the database locally but no data will sync to or
-     * from other devices.
-     *
-     * @see {@link isSyncActive}
-     * @see {@link startSync | startSync()}
+     * Objects that describe how documents' positions in the list of matching
+     * documents have changed since the previous live query event.
      */
-    stopSync(): void;
+    readonly moves: LiveQueryMove[];
     /**
-     * Registers an observer for info about Ditto peers in range of this device.
+     * Returns a hash that represents the set of matching documents.
+     */
+    hash(documents: Document[]): BigInt;
+    /**
+     * Returns a pattern of words that together create a mnemonic, which
+     * represents the set of matching documents.
+     */
+    hashMnemonic(documents: Document[]): string;
+    /** @internal */
+    constructor(params: LiveQueryEventUpdateParams);
+}
+/**
+ * Represents events delivered by a {@link LiveQuery}, which can be initial
+ * (fired immediately upon registration) or an update (all subsequent events).
+ */
+type LiveQueryEvent = LiveQueryEventInitial | LiveQueryEventUpdate;
+/**
+ * Provides information about a live query event relating to a single document
+ * live query.
+ */
+declare class SingleDocumentLiveQueryEvent {
+    /**
+     * Whether or not this is the initial event being delivered.
+     */
+    readonly isInitial: boolean;
+    /** The old representation of the document with the relveant document ID. */
+    readonly oldDocument?: Document;
+    /**
+     * Returns a hash that represents the set of matching documents.
+     */
+    hash(document: Document | null): BigInt;
+    /**
+     * Returns a pattern of words that together create a mnemonic, which
+     * represents the set of matching documents.
+     */
+    hashMnemonic(document: Document | null): string;
+    /** @internal */
+    constructor(isInitial: boolean, oldDocument?: Document);
+}
+
+/**
+ * The closure that is called whenever the documents covered by a live query
+ * change.
+ */
+type QueryObservationHandler = (documents: Document[], event: LiveQueryEvent, signalNext?: () => void) => void | Promise<void>;
+/**
+ * These objects are returned when using `find`-like functionality on
+ * {@link Collection}.
+ *
+ * They allow chaining of further query-related functions to do things like add
+ * a limit to the number of documents you want returned or specify how you want
+ * the documents to be sorted and ordered.
+ *
+ * You can either call {@link exec | exec()} on the object to get an array of
+ * {@link Document | documents} as an immediate return value, or you can
+ * establish either a live query or a subscription, which both work over time.
+ *
+ * A live query, established by calling
+ * {@link PendingCursorOperation.observeLocal | observeLocal()}, will notify you
+ * every time there's an update to a document that matches the query you
+ * provided in the preceding `find`-like call.
+ *
+ * A subscription, established by calling
+ * {@link PendingCursorOperation.subscribe | subscribe()}, will act as a signal
+ * to other peers that the device connects to that you would like to receive
+ * updates from them about documents that match the query you provided in the
+ * preceding `find`-like call.
+ *
+ * Update and remove functionality is also exposed through this object.
+ */
+declare class PendingCursorOperation extends BasePendingCursorOperation {
+    sort(propertyPath: string, direction?: SortDirection): PendingCursorOperation;
+    offset(offset: number): PendingCursorOperation;
+    limit(limit: number): PendingCursorOperation;
+    remove(): Promise<DocumentID[]>;
+    evict(): Promise<DocumentID[]>;
+    update(closure: (documents: MutableDocument[]) => void): Promise<UpdateResultsMap>;
+    /**
+     * Enables you to subscribe to changes that occur in a collection remotely.
      *
-     * Ditto will prevent the process from exiting as long as there are active
-     * peers observers (not relevant when running in the browser).
+     * Having a subscription acts as a signal to other peers that you are
+     * interested in receiving updates when local or remote changes are made to
+     * documents that match the query generated by the chain of operations that
+     * precedes the call to {@link subscribe | subscribe()}.
      *
-     * @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.
+     * The returned {@link Subscription} object must be kept in scope for as long
+     * as you want to keep receiving updates.
      *
-     * @deprecated please use {@link Presence.observe | presence.observe()} instead.
+     * @returns A {@link Subscription} object that must be kept in scope for as
+     * long as you want to keep receiving updates for documents that match the
+     * query specified in the preceding chain.
      */
-    observePeers(callback: (peersData: RemotePeer[]) => void): Observer;
+    subscribe(): Subscription;
     /**
-     * Register observer for changes of underlying transport conditions.
+     * Enables you to listen for changes that occur in a collection locally.
      *
-     * Ditto will prevent the process from exiting as long as there are active
-     * transport conditions observers (not relevant when running in the browser).
+     * The `handler` block will be called when local changes are
+     * made to documents that match the query generated by the chain of operations
+     * that precedes the call to {@link PendingCursorOperation.observeLocal | observeLocal()}.
+     * The returned {@link LiveQuery} object must be kept in scope for as long as
+     * you want the provided `handler` to be called when an update occurs.
      *
-     * @param callback called when underlying transport conditions change with
-     * the changed `condition` and it's `source`.
-     */
-    observeTransportConditions(callback: (condition: TransportCondition, source: ConditionSource) => void): Observer;
-    /**
-     * 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.
+     * This won't subscribe to receive changes made remotely by others and so it
+     * will only fire updates when a local change is made. If you want to receive
+     * remotely performed updates as well, you'll have to create a subscription
+     * via {@link PendingCursorOperation.subscribe | subscribe()} with the
+     * relevant query. The returned {@link LiveQuery} object must be kept in scope
+     * for as long as you want the provided `eventHandler` to be called when an
+     * update occurs.
      *
-     * 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.
+     * @param handler A closure that will be called every time there is a
+     * transaction committed to the store that involves modifications to documents
+     * matching the query in the collection this method was called on.
      *
-     * Only available in Node environments at the moment, no-op in the browser.
+     * @return A {@link LiveQuery} object that must be kept in scope for as long
+     * as you want to keep receiving updates.
      */
-    runGarbageCollection(): void;
+    observeLocal(handler: QueryObservationHandler): LiveQuery;
     /**
-     * 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.
+     * Enables you to listen for changes that occur in a collection locally and
+     * to signal when you are ready for the live query to deliver the next event.
      *
-     * 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.
+     * The `handler` block will be called when local changes are
+     * made to documents that match the query generated by the chain of operations
+     * that precedes the call to {@link PendingCursorOperation.observeLocalWithNextSignal | observeLocalWithNextSignal()}.
+     * The returned {@link LiveQuery} object must be kept in scope for as long as
+     * you want the provided `handler` to be called when an update occurs.
+     *
+     * This won't subscribe to receive changes made remotely by others and so it
+     * will only fire updates when a local change is made. If you want to receive
+     * remotely performed updates as well, you'll have to create a subscription
+     * via {@link PendingCursorOperation.subscribe | subscribe()} with the
+     * relevant query. The returned {@link LiveQuery} object must be kept in scope
+     * for as long as you want the provided `eventHandler` to be called when an
+     * update occurs.
+     *
+     * @param handler A closure that will be called every time there is a
+     * transaction committed to the store that involves modifications to
+     * documents matching the query in the collection that this method was called
+     * on.
+     *
+     * @return A {@link LiveQuery} object that must be kept in scope for as long
+     * as you want to keep receiving updates.
      */
-    disableSyncWithV3(): void;
+    observeLocalWithNextSignal(handler: QueryObservationHandler): LiveQuery;
     /** @internal */
-    keepAlive: KeepAlive;
-    private sync;
-    private isWebValid;
-    private isX509Valid;
-    private presenceManager;
-    private transportConditionsManager;
-    private authClientValidityChanged;
-    private validateIdentity;
-    private setSyncActive;
-    private makeDefaultTransportConfig;
+    constructor(query: string, queryArgs: QueryArguments | null, collection: Collection);
+    /** @internal */
+    _observe(handler: QueryObservationHandler, waitForNextSignal: boolean): LiveQuery;
 }
-/** @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 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 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>;
+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;
     /**
-     * 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.
+     * Stop the live query from delivering updates.
      */
-    copyToPath(path: string): Promise<void>;
+    stop(): void;
+    /** @internal */
+    orderBys: OrderBy[];
+    /** @internal */
+    queryArgsCBOR: Uint8Array | null;
+    /** @internal */
+    readonly limit: number;
+    /** @internal */
+    readonly offset: number;
+    /** @internal */
+    readonly collection: Collection;
+    /** @internal */
+    readonly handler: QueryObservationHandler;
+    /** @internal */
+    liveQueryManager: LiveQueryManager | null;
+    /** @internal */
+    readonly liveQueryID: number;
+    /** @internal */
+    constructor(query: string, queryArgs: QueryArguments | null, queryArgsCBOR: Uint8Array | null, orderBys: OrderBy[], limit: number, offset: number, collection: Collection, handler: QueryObservationHandler);
+    /** @internal */
+    signalNext(): Promise<void>;
+}
+
+/** @internal */
+declare class LiveQueryManager {
+    readonly ditto: Ditto;
+    readonly keepAlive: KeepAlive;
     /** @internal */
-    constructor(ditto: Ditto, token: AttachmentToken);
+    constructor(ditto: Ditto, keepAlive: KeepAlive);
+    /** @internal */
+    startLiveQuery(liveQuery: LiveQuery): void;
+    /** @internal */
+    stopLiveQuery(liveQuery: LiveQuery): void;
+    /** @internal */
+    close(): void;
+    private liveQueriesByID;
+    private finalizationRegistry;
+    private stopLiveQueryWithID;
+    private finalize;
 }
 
 /**
@@ -1643,341 +1765,379 @@ declare class AttachmentFetcher implements PromiseLike<Attachment | null> {
      */
     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>;
+    readonly cancelTokenPromise: Promise<unknown | null> | null;
     /** @internal */
     readonly ditto: Ditto;
     /** @internal */
+    readonly id: string;
+    /** @internal */
+    readonly manager: AttachmentFetcherManager;
+    /** @internal */
     readonly token: AttachmentToken;
     /** @internal */
-    readonly eventHandler: (attachmentFetchEvent: AttachmentFetchEvent) => void | null;
+    then<TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): PromiseLike<TResult1 | TResult2>;
     /** @internal */
-    constructor(ditto: Ditto, token: AttachmentToken, eventHandler?: (attachmentFetchEvent: AttachmentFetchEvent) => void);
-    private cancelTokenPromise;
-    private static finalizationRegistry;
-    private static stopWithContextInfo;
+    constructor(ditto: Ditto, token: AttachmentToken, manager: AttachmentFetcherManager, eventHandler?: (attachmentFetchEvent: AttachmentFetchEvent) => void);
+    /**
+     * This function is defined while a fetch is in progress and is used to reject
+     * the promise `this.attachment` when the fetch is canceled.
+     *
+     * @internal
+     */
+    private rejectPendingFetch;
 }
 
 /**
- * Used to subscribe to receive updates from remote peers about matching
- * documents.
+ * Manages attachment fetchers to make sure we free all resources when the
+ * fetcher is garbage collected and to allow us to wait for freeing of
+ * ressources to be finished before the ditto instance is closed.
  *
- * 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;
+ * @internal */
+declare class AttachmentFetcherManager {
+    readonly ditto: Ditto;
+    /** @internal */
+    constructor(ditto: Ditto);
     /**
-     * The name of the collection that the subscription is based on.
-     */
-    get collectionName(): string;
+     * Start an attachment fetcher.
+     *
+     * @internal */
+    startAttachmentFetcher(token: AttachmentToken, eventHandler?: (attachmentFetchEvent: AttachmentFetchEvent) => void): AttachmentFetcher;
     /**
-     * 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);
+     * Stop an attachment fetcher and wait for it to be stopped.
+     *
+     * @internal */
+    stopAttachmentFetcher(attachmentFetcher: AttachmentFetcher): Promise<void>;
     /**
-     * The collection this subscription belongs to.
-     * @internal Because not exposed in any of the other SDKs (yet?).
+     * Closing the manager will cancel all attachment fetchers.
+     *
+     * @internal
      */
-    readonly collection: Collection;
+    close(): void;
+    private contextInfoByID;
+    private finalizationRegistry;
     /**
-     * The corresponding named arguments for {@link query}, if any.
-     * @internal Because not exposed in any of the other SDKs (yet?).
+     * Stop the attachment fetcher without unregistering it from the finalization
+     * registry.
      */
-    readonly queryArgsCBOR: Uint8Array | null;
-    private static finalizationRegistry;
-    private static add;
-    private static remove;
-    private contextInfo;
+    private stopWithContextInfo;
 }
 
+/** 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';
 /**
- * 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()}.
+ * Types of connections that can be established between two peers.
+ * @deprecated replaced by {@link ConnectionType}.
  */
-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;
-}
-
+type PresenceConnectionType = 'WiFi' | 'WebSocket' | 'AWDL' | 'BLE';
 /**
- * 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.
+ * A peer object with information about an observed peer.
+ * @deprecated replaced by {@link Peer}.
  */
-interface LiveQueryMove {
+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 {
     /**
-     * The index of the document in the list of matching documents from the
-     * previous live query event.
+     * 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.
      */
-    readonly from: number;
+    deviceName: string;
+    /** Returns a string identifying the version of the Ditto SDK. */
+    get sdkVersion(): string;
     /**
-     * The index of the document in the list of matching documents from the new
-     * live query event.
+     * The (validated) identity this Ditto instance was initialized with.
      */
-    readonly to: number;
-}
-/** @internal */
-interface LiveQueryEventUpdateParams {
-    oldDocuments: Document[];
-    insertions: number[];
-    deletions: number[];
-    updates: number[];
-    moves: LiveQueryMove[];
-}
-/**
- * First event fired immediately after registering a live query without any
- * mutations. All subsequent events are of type {@link LiveQueryEventUpdate}.
- */
-declare class LiveQueryEventInitial {
+    readonly identity: Identity;
     /**
-     * Whether or not this is the initial event being delivered. Always `true`
-     * for `LiveQueryEventInitial`.
+     * The path this Ditto instance was initialized with, if no path was given at
+     * construction time, the default value is returned (see constructor).
      */
-    readonly isInitial = true;
+    readonly path: string;
     /**
-     * Returns a hash that represents the set of matching documents.
+     * Provides access to the SDK's store functionality.
      */
-    hash(documents: Document[]): BigInt;
+    readonly store: Store;
     /**
-     * Returns a pattern of words that together create a mnemonic, which
-     * represents the set of matching documents.
+     * Provides access to the SDK's presence functionality.
      */
-    hashMnemonic(documents: Document[]): string;
-}
-/**
- * Represents an update event describing all changes that occured for documents
- * covered by a (live) query.
- */
-declare class LiveQueryEventUpdate {
+    readonly presence: Presence;
     /**
-     * Whether or not this is the initial event being delivered. Always `false`
-     * for `LiveQueryEventUpdate`.
+     * Provides access to authentication methods for logging on to Ditto Cloud.
      */
-    readonly isInitial = false;
+    readonly auth: Authenticator;
     /**
-     * The documents that previously matched the query, before the latest event.
+     * The site ID that the instance of `Ditto` is using as part of its identity.
      */
-    readonly oldDocuments: Document[];
+    readonly siteID: number | BigInt;
     /**
-     * The indexes in the array of matching documents that accompany this event,
-     * which relate to a document that was not in the previous most recent list of
-     * matching documents.
+     * Returns `true` if an offline license token has been set, otherwise returns `false`.
+     *
+     * @see {@link setOfflineOnlyLicenseToken | setOfflineOnlyLicenseToken()}
      */
-    readonly insertions: number[];
+    readonly isActivated: boolean;
     /**
-     * The indexes into the array {@link oldDocuments}, which relate to a document
-     * that was in the previous most recent list of matching documents but is no
-     * longer a matching document.
+     * `true` once {@link close | Ditto.close()} has been called, otherwise
+     * `false`.
      */
-    readonly deletions: number[];
+    readonly isClosed: boolean;
     /**
-     * The indexes in the array of matching documents that accompany this event,
-     * which relate to a document that has been updated since the previous live
-     * query event.
+     * Returns `true` if sync is active, otherwise returns `false`. Use
+     * {@link startSync | startSync()} to activate and {@link stopSync | stopSync()}
+     * to deactivate sync.
      */
-    readonly updates: number[];
+    readonly isSyncActive: boolean;
     /**
-     * Objects that describe how documents' positions in the list of matching
-     * documents have changed since the previous live query event.
+     * 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;
+    /**
+     * 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).
+     */
+    setOfflineOnlyLicenseToken(licenseToken: string): void;
+    /**
+     * 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()}
      */
-    readonly moves: LiveQueryMove[];
+    readonly transportConfig: TransportConfig;
     /**
-     * Returns a hash that represents the set of matching documents.
+     * 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.
+     *
+     * @see {@link transportConfig}
+     * @see {@link updateTransportConfig | updateTransportConfig()}
      */
-    hash(documents: Document[]): BigInt;
+    setTransportConfig(transportConfig: TransportConfig): void;
     /**
-     * Returns a pattern of words that together create a mnemonic, which
-     * represents the set of matching documents.
+     * 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.
      */
-    hashMnemonic(documents: Document[]): string;
-    /** @internal */
-    constructor(params: LiveQueryEventUpdateParams);
-}
-/**
- * Represents events delivered by a {@link LiveQuery}, which can be initial
- * (fired immediately upon registration) or an update (all subsequent events).
- */
-type LiveQueryEvent = LiveQueryEventInitial | LiveQueryEventUpdate;
-/**
- * Provides information about a live query event relating to a single document
- * live query.
- */
-declare class SingleDocumentLiveQueryEvent {
+    updateTransportConfig(update: (transportConfig: TransportConfig) => void): Ditto;
     /**
-     * Whether or not this is the initial event being delivered.
+     * 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).
+     *
+     * **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()}
      */
-    readonly isInitial: boolean;
-    /** The old representation of the document with the relveant document ID. */
-    readonly oldDocument?: Document;
+    startSync(): void;
     /**
-     * Returns a hash that represents the set of matching documents.
+     * Stops all network transports.
+     *
+     * You may continue to use the database locally but no data will sync to or
+     * from other devices.
+     *
+     * @see {@link isSyncActive}
+     * @see {@link startSync | startSync()}
      */
-    hash(document: Document | null): BigInt;
+    stopSync(): void;
     /**
-     * Returns a pattern of words that together create a mnemonic, which
-     * represents the set of matching documents.
+     * 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.
+     *
+     * @deprecated please use {@link Presence.observe | presence.observe()} instead.
      */
-    hashMnemonic(document: Document | null): string;
-    /** @internal */
-    constructor(isInitial: boolean, oldDocument?: Document);
-}
-
-/**
- * The closure that is called whenever the documents covered by a live query
- * change.
- */
-type QueryObservationHandler = (documents: Document[], event: LiveQueryEvent, signalNext?: () => void) => void | Promise<void>;
-/**
- * These objects are returned when using `find`-like functionality on
- * {@link Collection}.
- *
- * They allow chaining of further query-related functions to do things like add
- * a limit to the number of documents you want returned or specify how you want
- * the documents to be sorted and ordered.
- *
- * You can either call {@link exec | exec()} on the object to get an array of
- * {@link Document | documents} as an immediate return value, or you can
- * establish either a live query or a subscription, which both work over time.
- *
- * A live query, established by calling
- * {@link PendingCursorOperation.observeLocal | observeLocal()}, will notify you
- * every time there's an update to a document that matches the query you
- * provided in the preceding `find`-like call.
- *
- * A subscription, established by calling
- * {@link PendingCursorOperation.subscribe | subscribe()}, will act as a signal
- * to other peers that the device connects to that you would like to receive
- * updates from them about documents that match the query you provided in the
- * preceding `find`-like call.
- *
- * Update and remove functionality is also exposed through this object.
- */
-declare class PendingCursorOperation extends BasePendingCursorOperation {
-    sort(propertyPath: string, direction?: SortDirection): PendingCursorOperation;
-    offset(offset: number): PendingCursorOperation;
-    limit(limit: number): PendingCursorOperation;
-    remove(): Promise<DocumentID[]>;
-    evict(): Promise<DocumentID[]>;
-    update(closure: (documents: MutableDocument[]) => void): Promise<UpdateResultsMap>;
+    observePeers(callback: (peersData: RemotePeer[]) => void): Observer;
     /**
-     * Enables you to subscribe to changes that occur in a collection remotely.
-     *
-     * Having a subscription acts as a signal to other peers that you are
-     * interested in receiving updates when local or remote changes are made to
-     * documents that match the query generated by the chain of operations that
-     * precedes the call to {@link subscribe | subscribe()}.
+     * Register observer for changes of underlying transport conditions.
      *
-     * The returned {@link Subscription} object must be kept in scope for as long
-     * as you want to keep receiving updates.
+     * Ditto will prevent the process from exiting as long as there are active
+     * transport conditions observers (not relevant when running in the browser).
      *
-     * @returns A {@link Subscription} object that must be kept in scope for as
-     * long as you want to keep receiving updates for documents that match the
-     * query specified in the preceding chain.
+     * @param callback called when underlying transport conditions change with
+     * the changed `condition` and it's `source`.
      */
-    subscribe(): Subscription;
+    observeTransportConditions(callback: (condition: TransportCondition, source: ConditionSource) => void): Observer;
     /**
-     * Enables you to listen for changes that occur in a collection locally.
+     * 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.
      *
-     * The `handler` block will be called when local changes are
-     * made to documents that match the query generated by the chain of operations
-     * that precedes the call to {@link PendingCursorOperation.observeLocal | observeLocal()}.
-     * The returned {@link LiveQuery} object must be kept in scope for as long as
-     * you want the provided `handler` to be called when an update occurs.
+     * 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.
      *
-     * This won't subscribe to receive changes made remotely by others and so it
-     * will only fire updates when a local change is made. If you want to receive
-     * remotely performed updates as well, you'll have to create a subscription
-     * via {@link PendingCursorOperation.subscribe | subscribe()} with the
-     * relevant query. The returned {@link LiveQuery} object must be kept in scope
-     * for as long as you want the provided `eventHandler` to be called when an
-     * update occurs.
+     * Only available in Node environments at the moment, no-op in the browser.
+     */
+    runGarbageCollection(): 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.
      *
-     * @param handler A closure that will be called every time there is a
-     * transaction committed to the store that involves modifications to documents
-     * matching the query in the collection this method was called on.
+     * 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.
      *
-     * @return A {@link LiveQuery} object that must be kept in scope for as long
-     * as you want to keep receiving updates.
+     * Must be called before recreating a Ditto instance that uses the same
+     * persistence directory.
      */
-    observeLocal(handler: QueryObservationHandler): LiveQuery;
+    close(): Promise<void>;
+    /** @internal */
+    keepAlive: KeepAlive;
+    /** @internal */
+    liveQueryManager: LiveQueryManager;
+    /** @internal */
+    subscriptionManager: SubscriptionManager;
+    /** @internal */
+    attachmentFetcherManager: AttachmentFetcherManager;
     /**
-     * Enables you to listen for changes that occur in a collection locally and
-     * to signal when you are ready for the live query to deliver the next event.
+     * The number of operations pending before the Ditto instance can be closed.
      *
-     * The `handler` block will be called when local changes are
-     * made to documents that match the query generated by the chain of operations
-     * that precedes the call to {@link PendingCursorOperation.observeLocalWithNextSignal | observeLocalWithNextSignal()}.
-     * The returned {@link LiveQuery} object must be kept in scope for as long as
-     * you want the provided `handler` to be called when an update occurs.
+     * For testing purposes only.
+     * @internal */
+    get numPendingOperations(): number;
+    /**
+     * Makes sure that the closure is executed only if the Ditto instance hasn't
+     * been closed yet.
      *
-     * This won't subscribe to receive changes made remotely by others and so it
-     * will only fire updates when a local change is made. If you want to receive
-     * remotely performed updates as well, you'll have to create a subscription
-     * via {@link PendingCursorOperation.subscribe | subscribe()} with the
-     * relevant query. The returned {@link LiveQuery} object must be kept in scope
-     * for as long as you want the provided `eventHandler` to be called when an
-     * update occurs.
+     * @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.
      *
-     * @param handler A closure that will be called every time there is a
-     * transaction committed to the store that involves modifications to
-     * documents matching the query in the collection that this method was called
-     * on.
+     * Any calls to {@link close | `Ditto.close()`} will wait until the closure
+     * has completed before closing the Ditto instance.
      *
-     * @return A {@link LiveQuery} object that must be kept in scope for as long
-     * as you want to keep receiving updates.
-     */
-    observeLocalWithNextSignal(handler: QueryObservationHandler): LiveQuery;
+     * @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 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 */
-    constructor(query: string, queryArgs: QueryArguments | null, collection: Collection);
+    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 */
-    _observe(handler: QueryObservationHandler, createSubscription: boolean, waitForNextSignal: boolean): LiveQuery;
+    constructor(ditto: Ditto, token: AttachmentToken);
 }
 
 /**
@@ -2132,7 +2292,7 @@ declare class PendingIDSpecificOperation extends BasePendingIDSpecificOperation
     /** @internal */
     constructor(documentID: DocumentID, collection: Collection);
     /** @internal */
-    _observe(handler: SingleObservationHandler, createSubscription: boolean, waitForNextSignal: boolean): LiveQuery;
+    _observe(handler: SingleObservationHandler, waitForNextSignal: boolean): LiveQuery;
 }
 
 /**
@@ -2240,7 +2400,7 @@ declare class Collection implements CollectionInterface {
      * fetch request to proceed and for you to be notified about the attachment's
      * fetch status changes.
      */
-    fetchAttachment(token: AttachmentToken, eventHandler?: (AttachmentFetchEvent: any) => void): AttachmentFetcher;
+    fetchAttachment(token: AttachmentToken, eventHandler?: (event: AttachmentFetchEvent) => void): AttachmentFetcher;
     /** @internal */
     constructor(name: string, store: Store);
     /** @internal */
@@ -2435,7 +2595,7 @@ declare class PendingCollectionsOperation implements PromiseLike<Collection[]> {
     /** @internal */
     then<TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): PromiseLike<TResult1 | TResult2>;
     /** @internal */
-    _observe(handler: CollectionsObservationHandler, createSubscription: boolean, waitForNextSignal: boolean): LiveQuery;
+    _observe(handler: CollectionsObservationHandler, waitForNextSignal: boolean): LiveQuery;
     private readonly pendingCursorOperation;
 }
 
@@ -2467,6 +2627,8 @@ declare class ExperimentalStore {
      * @returns a promise for an array of Ditto documents matching the query
      **/
     execute(query: string): Promise<Document[]>;
+    /** @internal */
+    close(): void;
 }
 
 /**
@@ -2670,6 +2832,8 @@ declare class Store {
     write(callback: (transaction: WriteTransaction) => Promise<void>): Promise<WriteTransactionResult[]>;
     /** @internal */
     constructor(ditto: Ditto);
+    /** @internal */
+    close(): void;
     /**
      * Private method, used only by the Portal https://github.com/getditto/ditto/pull/3652
      * @internal