@dittolive/ditto 2.1.0 → 3.0.0-alpha2

package/types/ditto.d.ts

@@ -509,7 +509,7 @@ declare function validateDocumentIDCBOR(idCBOR: Uint8Array): Uint8Array;
 /**
  * The types of an {@link UpdateResult}.
  */
-declare type UpdateResultType = 'set' | 'replacedWithCounter' | 'incremented' | 'inserted' | 'removed' | 'pushed' | 'popped';
+declare type UpdateResultType = 'set' | 'incremented' | 'removed';
 declare class UpdateResult {
     /** The update result's type. */
     readonly type: UpdateResultType;
@@ -518,15 +518,8 @@ declare class UpdateResult {
     /** The path to the key in the document that was updated. */
     readonly path: string;
     /**
-     * The associated value with different meaning depending on the type:
-     *
-     * - For type `set`, it's the new value at the key `path`.
-     * - For type `inserted`, it's the new value that was inserted into the array at
-     *   index encoded into key `path`.
-     * - For type `pushed`, it's the new value that was inserted into the array at
-     *   key `path`.
-     * - For type `popped`, it's the value that was popped off the array the
-         key `path`.
+     * The associated value for `set` operations. The value will be the new value
+     * at the key path.
      *
      * All other types of update results do not have this property set.
      */
@@ -536,18 +529,10 @@ declare class UpdateResult {
     /** @internal */
     static set(docID: DocumentID, path: string, value?: any): UpdateResult;
     /** @internal */
-    static replacedWithCounter(docID: DocumentID, path: string): UpdateResult;
-    /** @internal */
     static incremented(docID: DocumentID, path: string, amount: number): UpdateResult;
     /** @internal */
-    static inserted(docID: DocumentID, path: string, value?: any): UpdateResult;
-    /** @internal */
     static removed(docID: DocumentID, path: string): UpdateResult;
     /** @internal */
-    static pushed(docID: DocumentID, path: string, value?: any): UpdateResult;
-    /** @internal */
-    static popped(docID: DocumentID, path: string, value?: any): UpdateResult;
-    /** @internal */
     private constructor();
 }
 
@@ -636,113 +621,23 @@ declare class MutableRegister extends Register {
 }
 
 /**
- * Represents a CRDT Replicated Growable Array (RGA) that can be
- * upserted as part of a document or assigned to a property during an
- * update of a document.
+ * Represents a CRDT Replicated Growable Array (RGA).
+ *
+ * RGAs are deprecated and you should instead use a `Register` containing an
+ * array.
  */
 declare class RGA {
     /** The array representation of the RGA. */
     get value(): any[];
-    /**
-     * Constructs a new RGA that can be used as part of a document's content.
-     *
-     * @param array - The array to use as the RGA's representation.
-     */
-    constructor(array?: any[]);
     /** @internal */
-    static '@ditto.create'(mutableDocument: any, path: any, value: any): any;
+    private constructor();
     /** @internal */
-    protected '@ditto.mutableDocument': any;
+    static '@ditto.create'(path: any, value: any): RGA;
     /** @internal */
     protected '@ditto.path': any;
     /** @internal */
     protected '@ditto.value': any;
 }
-/**
- * Represents a mutable CRDT Replicated Growable Array (RGA) that can be
- * mutated as part of updating a document.
- *
- * This class can't be instantiated directly, it's returned automatically for
- * any `rga` property of a document within an update block via {@link MutableDocumentPath.rga}.
- */
-declare class MutableRGA extends RGA {
-    /** Returns the value of the RGA. */
-    get value(): any[];
-    /**
-     * Set a value at the specified index.
-     *
-     * Only valid within the `update` closure of
-     * {@link PendingCursorOperation.update | PendingCursorOperation.update()} and
-     * {@link PendingIDSpecificOperation.update | PendingIDSpecificOperation.update()},
-     * otherwise an exception is thrown.
-     *
-     * @param value - The value to set at the specified index.
-     * @param index - The index at which to set the provided value.
-     *
-     * @deprecated RGA usage should be replaced. Use arrays inside Registers
-     * instead.
-     */
-    setAt(value: any, index: number): void;
-    /**
-     * Remove a value at the specified index.
-     *
-     * Only valid within the `update` closure of
-     * {@link PendingCursorOperation.update | PendingCursorOperation.update()} and
-     * {@link PendingIDSpecificOperation.update | PendingIDSpecificOperation.update()},
-     * otherwise an exception is thrown.
-     *
-     * @param index - The index of the element to remove.
-     *
-     * @deprecated RGA usage should be replaced. Use arrays inside Registers
-     * instead.
-     */
-    removeAt(index: number): void;
-    /**
-     * Push a value on to the end of the RGA.
-     *
-     * Only valid within the `update` closure of
-     * {@link PendingCursorOperation.update | PendingCursorOperation.update()} and
-     * {@link PendingIDSpecificOperation.update | PendingIDSpecificOperation.update()},
-     * otherwise an exception is thrown.
-     *
-     * @param value - The value to push on to the RGA.
-     *
-     * @deprecated RGA usage should be replaced. Use arrays inside Registers
-     * instead.
-     */
-    push(value: any): void;
-    /**
-     * Pop a value off the end of the RGA.
-     *
-     * Only valid within the `update` closure of
-     * {@link PendingCursorOperation.update | PendingCursorOperation.update()} and
-     * {@link PendingIDSpecificOperation.update | PendingIDSpecificOperation.update()},
-     * otherwise an exception is thrown.
-     *
-     * @return The value popped off from the end of the RGA.
-     *
-     * @deprecated RGA usage should be replaced. Use arrays inside Registers
-     * instead.
-     */
-    pop(): any | null;
-    /**
-     * Inserts a value into the RGA at the index specified.
-     *
-     * Only valid within the `update` closure of
-     * {@link PendingCursorOperation.update | PendingCursorOperation.update()} and
-     * {@link PendingIDSpecificOperation.update | PendingIDSpecificOperation.update()},
-     * otherwise an exception is thrown.
-     *
-     * @param value - The value to insert into the RGA.
-     * @param index - The index at which to insert the provided value.
-     *
-     * @deprecated RGA usage should be replaced. Use arrays inside Registers
-     * instead.
-     */
-    insertAt(value: any, index: number): void;
-    /** @internal */
-    constructor(value: any);
-}
 
 /**
  * Serves as a token for a specific attachment that you can pass to a call to
@@ -877,12 +772,16 @@ declare class MutableDocumentPath {
     get register(): MutableRegister | null;
     /**
      * Returns the value at the previously specified key in the document as a
-     * {@link MutableRGA} if possible, otherwise returns `null`.
+     * {@link RGA} if possible, otherwise returns `null`.
+     *
+     * Note that the returned type, {@link RGA}, is deprecated and does not allow
+     * any mutation. RGAs cannot be created or mutated with this version of the
+     * SDK; they can only be read and this is for backwards compatibility reasons.
      *
      * @deprecated RGA usage should be replaced. Use arrays inside Registers
      * instead.
      */
-    get rga(): MutableRGA | null;
+    get rga(): RGA | null;
     /**
      * Returns the value at the previously specified key in the document as a
      * {@link AttachmentToken} if possible, otherwise returns `null`.
@@ -912,13 +811,7 @@ declare class MutableDocumentPath {
     /** @internal */
     '@ditto.set'(value: any, isDefault?: boolean): void;
     /** @internal */
-    '@ditto.pop'(): any;
-    /** @internal */
     '@ditto.remove'(): void;
-    /** @internal */
-    '@ditto.push'(value: any): void;
-    /** @internal */
-    '@ditto.insert'(value: any): void;
     /** @private */
     private updateInMemory;
     /** @private */
@@ -1198,8 +1091,8 @@ declare class UpdateResultsMap {
  * {@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).
+ * 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
@@ -1377,14 +1270,16 @@ declare type QueryObservationHandler = (documents: Document[], event: LiveQueryE
  * {@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
+ * 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.
+ * 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.
  */
@@ -1454,55 +1349,6 @@ declare class PendingCursorOperation implements PromiseLike<Document[]> {
      * query specified in the preceding chain.
      */
     subscribe(): Subscription;
-    /**
-     * Enables you to listen for changes that occur in a collection locally and
-     * remotely.
-     *
-     * The `handler` block will be called 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 PendingCursorOperation.observe | observe()}. 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 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.
-     *
-     * @deprecated Use {@link PendingCursorOperation.observeLocal | observeLocal()}
-     * and {@link PendingCursorOperation.subscribe | subscribe()} individually
-     * instead. For more info, please consult the
-     * {@link https://docs.ditto.live/javascript/common/concepts/syncing-data | corresponding Ditto docs}.
-     */
-    observe(handler: QueryObservationHandler): LiveQuery;
-    /**
-     * Enables you to listen for changes that occur in a collection locally and
-     * remotely and to signal when you are ready for the live query to deliver
-     * the next event.
-     *
-     * The `handler` block will be called 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 PendingCursorOperation.observeWithNextSignal | observeWithNextSignal()}. 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 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.
-     *
-     * @deprecated Use {@link PendingCursorOperation.observeLocalWithNextSignal | observeLocalWithNextSignal()}
-     * and {@link PendingCursorOperation.subscribe | subscribe()} individually
-     * instead. For more info, please consult the
-     * {@link https://docs.ditto.live/javascript/common/concepts/syncing-data | corresponding Ditto docs}.
-     */
-    observeWithNextSignal(handler: QueryObservationHandler): LiveQuery;
     /**
      * Enables you to listen for changes that occur in a collection locally.
      *
@@ -1617,7 +1463,8 @@ declare type SingleObservationHandler = (document: Document | null, event: Singl
  * 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
+ * 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.
  *
@@ -1648,57 +1495,6 @@ declare class PendingIDSpecificOperation implements PromiseLike<Document | undef
      * long as you want to keep receiving updates for the document.
      */
     subscribe(): Subscription;
-    /**
-     * Enables you to listen for changes that occur in relation to a document
-     * locally and remotely.
-     *
-     * The `handler` closure will be called when local or remote changes are
-     * made to the document referenced by the {@link Collection.findByID | findByID()} call
-     * that precedes the call to {@link PendingIDSpecificOperation.observe | observe()}.
-     *
-     * 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 handler A closure that will be called every time there is a
-     * transaction committed to the store that involves a modification to the
-     * document with the relevant ID in the collection that
-     * {@link PendingIDSpecificOperation.observe | observe()} was called on.
-     *
-     * @return A {@link LiveQuery} object that must be kept in scope for as long
-     * as you want to keep receiving updates.
-     *
-     * @deprecated Use {@link PendingIDSpecificOperation.observeLocal | observeLocal()}
-     * and {@link PendingIDSpecificOperation.subscribe | subscribe()} individually
-     * instead. For more info, please consult the
-     * {@link https://docs.ditto.live/javascript/common/concepts/syncing-data | corresponding Ditto docs}.
-     */
-    observe(handler: SingleObservationHandler): LiveQuery;
-    /**
-     * Enables you to listen for changes that occur in relation to a document
-     * locally and remotely, and to signal when you are ready for the live query
-     * to deliver the next event.
-     *
-     * The `handler` closure will be called when local or remote changes are
-     * made to the document referenced by the {@link Collection.findByID | findByID()} call
-     * that precedes the call to {@link PendingIDSpecificOperation.observeWithNextSignal | observeWithNextSignal()}.
-     *
-     * 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 handler A closure that will be called every time there is a
-     * transaction committed to the store that involves a modification to the
-     * document with the relevant ID in the collection that
-     * {@link PendingIDSpecificOperation.observeWithNextSignal | observeWithNextSignal()} was called on.
-     *
-     * @return A {@link LiveQuery} object that must be kept in scope for as long
-     * as you want to keep receiving updates.
-     *
-     * @deprecated Use {@link PendingIDSpecificOperation.observeLocalWithNextSignal | observeLocalWithNextSignal()}
-     * and {@link PendingIDSpecificOperation.subscribe | subscribe()} individually
-     * instead. For more info, please consult the
-     * {@link https://docs.ditto.live/javascript/common/concepts/syncing-data | corresponding Ditto docs}.
-     */
-    observeWithNextSignal(handler: SingleObservationHandler): LiveQuery;
     /**
      * Enables you to listen for changes that occur in relation to a document
      * locally.
@@ -1810,20 +1606,20 @@ declare class Collection {
      * Generates a {@link PendingCursorOperation} using the provided query.
      *
      * The returned object can be used to find and return the documents or you can
-     * chain a call to `observeLocal()` or `subscribe()` if you want to get updates
-     * about the list of matching documents over time. It can also be used to
-     * update, remove or evict the matching documents.
-     *
-     * You can incorporate dynamic data into the query string with placeholders
-     * in the form of `$args.my_arg_name`, along with providing an accompanying
-     * dictionary in the form of `{ "my_arg_name": "some value" }`.
-     * The placeholders will be appropriately replaced by the corresponding
-     * argument contained in `queryArgs`. This includes handling things like
-     * wrapping strings in quotation marks and arrays in square brackets, for
-     * example.
+     * chain a call to `observeLocal()` or `subscribe()` if you want to get
+     * updates about the list of matching documents over time. It can also be used
+     * to update, remove or evict the matching documents.
+     *
+     * You can incorporate dynamic data into the query string with placeholders in
+     * the form of `$args.my_arg_name`, along with providing an accompanying
+     * dictionary in the form of `{ "my_arg_name": "some value" }`. The
+     * placeholders will be appropriately replaced by the corresponding argument
+     * contained in `queryArgs`. This includes handling things like wrapping
+     * strings in quotation marks and arrays in square brackets, for example.
      *
      * @param query The query to run against the collection.
-     * @param queryArgs The arguments to use to replace placeholders in the provided query.
+     * @param queryArgs The arguments to use to replace placeholders in the
+     * provided query.
      */
     find(query: string, queryArgs?: QueryArguments): PendingCursorOperation;
     /**
@@ -1836,9 +1632,11 @@ declare class Collection {
      * ID.
      *
      * The returned object can be used to find and return the document or you can
-     * chain a call to {@link PendingIDSpecificOperation.observeLocal | observeLocal()}, or {@link PendingIDSpecificOperation.subscribe | subscribe()}
-     * if you want to get updates about the document over time. It can also be
-     * used to update, remove or evict the document.
+     * chain a call to
+     * {@link PendingIDSpecificOperation.observeLocal | observeLocal()}, or
+     * {@link PendingIDSpecificOperation.subscribe | subscribe()} if you want to
+     * get updates about the document over time. It can also be used to update,
+     * remove or evict the document.
      *
      * @param id The ID of the document to find.
      */
@@ -1875,8 +1673,8 @@ declare class Collection {
      * }
      * ```
      *
-     * @param pathOrData The path to the file that you want to create an attachment
-     * with or the raw data.
+     * @param pathOrData The path to the file that you want to create an
+     * attachment with or the raw data.
      *
      * @param metadata Metadata relating to the attachment.
      */
@@ -1982,17 +1780,18 @@ declare class CollectionsEvent {
  */
 declare type CollectionsObservationHandler = (event: CollectionsEvent, signalNext?: () => void) => void | Promise<void>;
 /**
- * These objects are returned when calling {@link Store.collections | collections()}
- * on {@link Store}.
+ * These objects are returned when calling
+ * {@link Store.collections | collections()} on {@link Store}.
  *
  * They allow chaining of further collections-related functions. You can either
  * call {@link exec | exec()} on the object to get an array of
  * {@link Collection}s as an immediate return value, or you can establish either
  * a live query or a subscription, which both work over time.
  *
- * A live query, established by calling {@link PendingCollectionsOperation.observeLocal | observeLocal()}, will notify
- * you every time there's a change in the collections that the device knows
- * about.
+ * A live query, established by calling
+ * {@link PendingCollectionsOperation.observeLocal | observeLocal()}, will
+ * notify you every time there's a change in the collections that the device
+ * knows about.
  *
  * A subscription, established by calling {@link subscribe | subscribe()}, will
  * act as a signal to other peers that the device connects to that you would
@@ -2048,47 +1847,6 @@ declare class PendingCollectionsOperation implements PromiseLike<Collection[]> {
      * collections that they know about.
      */
     subscribe(): Subscription;
-    /**
-     * Enables you to listen for changes that occur in relation to the collections
-     * that are known about. A closure gets called when an update is received
-     * either locally or remotely.
-     *
-     * 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 handler A closure that will be called every time there is an update
-     * about the list of known about collections.
-     *
-     * @return A {@link LiveQuery} object that must be kept in scope for as long
-     * as you want to keep receiving updates.
-     *
-     * @deprecated Use {@link PendingCollectionsOperation.observeLocal | observeLocal()}
-     * and {@link PendingCollectionsOperation.subscribe | subscribe()}
-     * individually instead. For more info, please consult the
-     * {@link https://docs.ditto.live/javascript/common/concepts/syncing-data | corresponding Ditto docs}.
-     */
-    observe(handler: CollectionsObservationHandler): LiveQuery;
-    /**
-     * Enables you to listen for changes that occur in relation to the collections
-     * that are known about. A block gets called when an update is received either
-     * locally or remotely. You can signal when you are ready for the next event
-     * to be delivered.
-     *
-     * 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 handler A closure that will be called every time there is an update
-     * about the list of known about collections.
-     *
-     * @return A {@link LiveQuery} object that must be kept in scope for as long
-     * as you want to keep receiving updates.
-     *
-     * @deprecated Use {@link PendingCollectionsOperation.observeLocalWithNextSignal | observeLocalWithNextSignal()}
-     * and {@link PendingCollectionsOperation.subscribe | subscribe()}
-     * individually instead. For more info, please consult the
-     * {@link https://docs.ditto.live/javascript/common/concepts/syncing-data | corresponding Ditto docs}.
-     */
-    observeWithNextSignal(handler: CollectionsObservationHandler): LiveQuery;
     /**
      * Enables you to listen for changes that occur in relation to the collections
      * that are known about locally.
@@ -2220,13 +1978,132 @@ declare class Observer {
     private static finalize;
 }
 
+/** Types of connections that can be established between two peers. */
+declare 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.
+ */
+declare 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. */
+declare type Connection = {
+    /** Unique identifier for the connection. */
+    id: string;
+    /** Type of transport enabling this connection. */
+    type: ConnectionType;
+    /** The address of the peer at one end of the connection. */
+    peer1: Address;
+    /** The address of the peer at one end of the connection. */
+    peer2: Address;
+    approximateDistanceInMeters?: number;
+};
+/** An instance of Ditto taking part in the Ditto mesh network. */
+declare type Peer = {
+    /**
+     * Address to contact this peer via Ditto Bus, unique with a Ditto mesh
+     * network.
+     */
+    address: Address;
+    /**
+     * 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).
+ */
+declare 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. */
 declare type TransportCondition = 'Unknown' | 'OK' | 'GenericFailure' | 'AppInBackground' | 'MDNSFailure' | 'TCPListenFailure' | 'NoBLECentralPermission' | 'NoBLEPeripheralPermission' | 'CannotEstablishConnection' | 'BLEDisabled' | 'NoBLEHardware' | 'WiFiDisabled' | 'TemporarilyUnavailable';
 /** The source for a transport condition. */
 declare type ConditionSource = 'BLE' | 'TCP' | 'AWDL' | 'MDNS';
-/** Types of connections that can be established between two peers. */
+/**
+ * Types of connections that can be established between two peers.
+ * @deprecated replaced by {@link ConnectionType}.
+ */
 declare type PresenceConnectionType = 'WiFi' | 'WebSocket' | 'AWDL' | 'BLE';
-/** A peer object with information about an observed peer. */
+/**
+ * A peer object with information about an observed peer.
+ * @deprecated replaced by {@link Peer}.
+ */
 declare type RemotePeer = {
     networkID: string;
     deviceName: string;
@@ -2241,7 +2118,7 @@ declare class Ditto {
     /**
      * Configure a custom identifier for the current device.
      *
-     * When using {@link observePeers | observePeers()}, each remote peer is
+     * 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
@@ -2263,6 +2140,10 @@ declare class Ditto {
      * 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.
      */
@@ -2382,6 +2263,8 @@ declare class Ditto {
      * 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.
      */
     observePeers(callback: (peersData: RemotePeer[]) => void): Observer;
     /**
@@ -2410,6 +2293,16 @@ declare class Ditto {
      * 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 v2 series of releases.
+     *
+     * Assuming this succeeds then this peer will only be able to sync with other
+     * peers using SDKs in the v3 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 v2 SDK peers.
+     */
+    disableSyncWithV2(): void;
     /** @internal */
     keepAlive: KeepAlive;
     private sync;
@@ -2428,27 +2321,47 @@ declare const dittoBridge: Bridge<Ditto, "CDitto_t">;
 /** @internal */
 declare type ObserverToken = string;
 /** @internal */
+declare 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, keepAlive?: KeepAlive | null);
+    constructor(id: string, options?: ObserverManagerConstructorOptions);
     /** @internal */
     addObserver(callback: any): ObserverToken;
     /** @internal */
     removeObserver(token: ObserverToken): void;
     /** @internal */
     notify(...args: any[]): void;
-    /** @abstract */
+    /**
+     * Can be injected and replaced via constructor options.
+     *
+     * @abstract
+     */
     protected register(callback: (...args: any[]) => void): void;
-    /** @abstract */
+    /**
+     * Can be injected and replaced via constructor options.
+     *
+     * @abstract
+     */
     protected unregister(): void;
-    /** @abstract */
-    protected processCallback(...args: any[]): any[];
+    /**
+     * 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;
@@ -2710,5 +2623,5 @@ declare class CBOR {
     static decode(data: Uint8Array): any;
 }
 
-export { Attachment, AttachmentFetchEvent, AttachmentFetchEventCompleted, AttachmentFetchEventDeleted, AttachmentFetchEventProgress, AttachmentFetchEventType, AttachmentFetcher, AttachmentToken, AuthenticationHandler, AuthenticationStatus, Authenticator, CBOR, Collection, CollectionsEvent, CollectionsEventParams, CollectionsObservationHandler, ConditionSource, Counter, CustomLogCallback, Ditto, Document, DocumentID, DocumentIDValue, DocumentPath, DocumentValue, Identity, IdentityManual, IdentityOfflinePlayground, IdentityOnlinePlayground, IdentityOnlineWithAuthentication, IdentitySharedKey, IdentityTypesRequiringOfflineLicenseToken, InitOptions, KeepAlive, LiveQuery, LiveQueryEvent, LiveQueryEventInitial, LiveQueryEventUpdate, LiveQueryEventUpdateParams, LiveQueryMove, LogLevel, Logger, MutableCounter, MutableDocument, MutableDocumentPath, MutableRGA, MutableRegister, NotAvailableAuthenticator, Observer, ObserverOptions, OnlineAuthenticator, PendingCollectionsOperation, PendingCursorOperation, PendingIDSpecificOperation, PresenceConnectionType, QueryArguments, QueryObservationHandler, RGA, Register, RemotePeer, SingleDocumentLiveQueryEvent, SingleObservationHandler, SortDirection, Store, Subscription, TransportCondition, TransportConfig, TransportConfigConnect, TransportConfigGlobal, TransportConfigLan, TransportConfigListen, TransportConfigListenHTTP, TransportConfigListenTCP, TransportConfigPeerToPeer, UpdateResult, UpdateResultType, UpdateResultsMap, UpsertOptions, Value, WebAssemblyModule, WriteStrategy, attachmentBridge, dittoBridge, documentBridge, init, mutableDocumentBridge, validateDocumentIDCBOR, validateDocumentIDValue };
+export { Address, Attachment, AttachmentFetchEvent, AttachmentFetchEventCompleted, AttachmentFetchEventDeleted, AttachmentFetchEventProgress, AttachmentFetchEventType, AttachmentFetcher, AttachmentToken, AuthenticationHandler, AuthenticationStatus, Authenticator, CBOR, Collection, CollectionsEvent, CollectionsEventParams, CollectionsObservationHandler, ConditionSource, Connection, ConnectionType, Counter, CustomLogCallback, Ditto, Document, DocumentID, DocumentIDValue, DocumentPath, DocumentValue, 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, RGA, Register, RemotePeer, SingleDocumentLiveQueryEvent, SingleObservationHandler, SortDirection, Store, Subscription, TransportCondition, TransportConfig, TransportConfigConnect, TransportConfigGlobal, TransportConfigLan, TransportConfigListen, TransportConfigListenHTTP, TransportConfigListenTCP, TransportConfigPeerToPeer, UpdateResult, UpdateResultType, UpdateResultsMap, UpsertOptions, Value, WebAssemblyModule, WriteStrategy, addressToString, attachmentBridge, dittoBridge, documentBridge, init, mutableDocumentBridge, validateDocumentIDCBOR, validateDocumentIDValue };
 //# sourceMappingURL=ditto.d.ts.map