);
+ static empty(): CompoundWrite;
+}
+
+/**
+ * Modify the provided instance to communicate with the Realtime Database
+ * emulator.
+ *
+ * Note: This method must be called before performing any other operation.
+ *
+ * @param db - The instance to modify.
+ * @param host - The emulator host (ex: localhost)
+ * @param port - The emulator port (ex: 8080)
+ * @param options.mockUserToken - the mock auth token to use for unit testing Security Rules
+ */
+export declare function connectDatabaseEmulator(
+ db: Database,
+ host: string,
+ port: number,
+ options?: {
+ mockUserToken?: EmulatorMockTokenOptions | string;
+ }
+): void;
+
+/**
+ * Class representing a Firebase Realtime Database.
+ */
+export declare class Database implements _FirebaseService {
+ _repoInternal: Repo;
+ /** The {@link @firebase/app#FirebaseApp} associated with this Realtime Database instance. */
+ readonly app: FirebaseApp;
+ /** Represents a `Database` instance. */
+ readonly 'type' = 'database';
+ /** Track if the instance has been used (root or repo accessed) */
+ _instanceStarted: boolean;
+ /** Backing state for root_ */
+ private _rootInternal?;
+ /** @hideconstructor */
+ constructor(
+ _repoInternal: Repo,
+ /** The {@link @firebase/app#FirebaseApp} associated with this Realtime Database instance. */
+ app: FirebaseApp
+ );
+ get _repo(): Repo;
+ get _root(): _ReferenceImpl;
+ _delete(): Promise;
+ _checkNotDeleted(apiName: string): void;
+}
+
+/**
+ * A `DatabaseReference` represents a specific location in your Database and can be used
+ * for reading or writing data to that Database location.
+ *
+ * You can reference the root or child location in your Database by calling
+ * `ref()` or `ref("child/path")`.
+ *
+ * Writing is done with the `set()` method and reading can be done with the
+ * `on*()` method. See {@link
+ * https://firebase.google.com/docs/database/web/read-and-write}
+ */
+export declare interface DatabaseReference extends Query {
+ /**
+ * The last part of the `DatabaseReference`'s path.
+ *
+ * For example, `"ada"` is the key for
+ * `https://.firebaseio.com/users/ada`.
+ *
+ * The key of a root `DatabaseReference` is `null`.
+ */
+ readonly key: string | null;
+ /**
+ * The parent location of a `DatabaseReference`.
+ *
+ * The parent of a root `DatabaseReference` is `null`.
+ */
+ readonly parent: DatabaseReference | null;
+ /** The root `DatabaseReference` of the Database. */
+ readonly root: DatabaseReference;
+}
+
+/**
+ * A `DataSnapshot` contains data from a Database location.
+ *
+ * Any time you read data from the Database, you receive the data as a
+ * `DataSnapshot`. A `DataSnapshot` is passed to the event callbacks you attach
+ * with `on()` or `once()`. You can extract the contents of the snapshot as a
+ * JavaScript object by calling the `val()` method. Alternatively, you can
+ * traverse into the snapshot by calling `child()` to return child snapshots
+ * (which you could then call `val()` on).
+ *
+ * A `DataSnapshot` is an efficiently generated, immutable copy of the data at
+ * a Database location. It cannot be modified and will never change (to modify
+ * data, you always call the `set()` method on a `Reference` directly).
+ */
+export declare class DataSnapshot {
+ readonly _node: Node_2;
+ /**
+ * The location of this DataSnapshot.
+ */
+ readonly ref: DatabaseReference;
+ readonly _index: Index;
+ /**
+ * @param _node - A SnapshotNode to wrap.
+ * @param ref - The location this snapshot came from.
+ * @param _index - The iteration order for this snapshot
+ * @hideconstructor
+ */
+ constructor(
+ _node: Node_2,
+ /**
+ * The location of this DataSnapshot.
+ */
+ ref: DatabaseReference,
+ _index: Index
+ );
+ /**
+ * Gets the priority value of the data in this `DataSnapshot`.
+ *
+ * Applications need not use priority but can order collections by
+ * ordinary properties (see
+ * {@link https://firebase.google.com/docs/database/web/lists-of-data#sorting_and_filtering_data |Sorting and filtering data}
+ * ).
+ */
+ get priority(): string | number | null;
+ /**
+ * The key (last part of the path) of the location of this `DataSnapshot`.
+ *
+ * The last token in a Database location is considered its key. For example,
+ * "ada" is the key for the /users/ada/ node. Accessing the key on any
+ * `DataSnapshot` will return the key for the location that generated it.
+ * However, accessing the key on the root URL of a Database will return
+ * `null`.
+ */
+ get key(): string | null;
+ /** Returns the number of child properties of this `DataSnapshot`. */
+ get size(): number;
+ /**
+ * Gets another `DataSnapshot` for the location at the specified relative path.
+ *
+ * Passing a relative path to the `child()` method of a DataSnapshot returns
+ * another `DataSnapshot` for the location at the specified relative path. The
+ * relative path can either be a simple child name (for example, "ada") or a
+ * deeper, slash-separated path (for example, "ada/name/first"). If the child
+ * location has no data, an empty `DataSnapshot` (that is, a `DataSnapshot`
+ * whose value is `null`) is returned.
+ *
+ * @param path - A relative path to the location of child data.
+ */
+ child(path: string): DataSnapshot;
+ /**
+ * Returns true if this `DataSnapshot` contains any data. It is slightly more
+ * efficient than using `snapshot.val() !== null`.
+ */
+ exists(): boolean;
+ /**
+ * Exports the entire contents of the DataSnapshot as a JavaScript object.
+ *
+ * The `exportVal()` method is similar to `val()`, except priority information
+ * is included (if available), making it suitable for backing up your data.
+ *
+ * @returns The DataSnapshot's contents as a JavaScript value (Object,
+ * Array, string, number, boolean, or `null`).
+ */
+ exportVal(): any;
+ /**
+ * Enumerates the top-level children in the `IteratedDataSnapshot`.
+ *
+ * Because of the way JavaScript objects work, the ordering of data in the
+ * JavaScript object returned by `val()` is not guaranteed to match the
+ * ordering on the server nor the ordering of `onChildAdded()` events. That is
+ * where `forEach()` comes in handy. It guarantees the children of a
+ * `DataSnapshot` will be iterated in their query order.
+ *
+ * If no explicit `orderBy*()` method is used, results are returned
+ * ordered by key (unless priorities are used, in which case, results are
+ * returned by priority).
+ *
+ * @param action - A function that will be called for each child DataSnapshot.
+ * The callback can return true to cancel further enumeration.
+ * @returns true if enumeration was canceled due to your callback returning
+ * true.
+ */
+ forEach(action: (child: IteratedDataSnapshot) => boolean | void): boolean;
+ /**
+ * Returns true if the specified child path has (non-null) data.
+ *
+ * @param path - A relative path to the location of a potential child.
+ * @returns `true` if data exists at the specified child path; else
+ * `false`.
+ */
+ hasChild(path: string): boolean;
+ /**
+ * Returns whether or not the `DataSnapshot` has any non-`null` child
+ * properties.
+ *
+ * You can use `hasChildren()` to determine if a `DataSnapshot` has any
+ * children. If it does, you can enumerate them using `forEach()`. If it
+ * doesn't, then either this snapshot contains a primitive value (which can be
+ * retrieved with `val()`) or it is empty (in which case, `val()` will return
+ * `null`).
+ *
+ * @returns true if this snapshot has any children; else false.
+ */
+ hasChildren(): boolean;
+ /**
+ * Returns a JSON-serializable representation of this object.
+ */
+ toJSON(): object | null;
+ /**
+ * Extracts a JavaScript value from a `DataSnapshot`.
+ *
+ * Depending on the data in a `DataSnapshot`, the `val()` method may return a
+ * scalar type (string, number, or boolean), an array, or an object. It may
+ * also return null, indicating that the `DataSnapshot` is empty (contains no
+ * data).
+ *
+ * @returns The DataSnapshot's contents as a JavaScript value (Object,
+ * Array, string, number, boolean, or `null`).
+ */
+ val(): any;
+}
+export { EmulatorMockTokenOptions };
+
+/**
+ * Logs debugging information to the console.
+ *
+ * @param enabled - Enables logging if `true`, disables logging if `false`.
+ * @param persistent - Remembers the logging state between page refreshes if
+ * `true`.
+ */
+export declare function enableLogging(
+ enabled: boolean,
+ persistent?: boolean
+): any;
+
+/**
+ * Logs debugging information to the console.
+ *
+ * @param logger - A custom logger function to control how things get logged.
+ */
+export declare function enableLogging(
+ logger: (message: string) => unknown
+): any;
+
+/**
+ * Creates a `QueryConstraint` with the specified ending point.
+ *
+ * Using `startAt()`, `startAfter()`, `endBefore()`, `endAt()` and `equalTo()`
+ * allows you to choose arbitrary starting and ending points for your queries.
+ *
+ * The ending point is inclusive, so children with exactly the specified value
+ * will be included in the query. The optional key argument can be used to
+ * further limit the range of the query. If it is specified, then children that
+ * have exactly the specified value must also have a key name less than or equal
+ * to the specified key.
+ *
+ * You can read more about `endAt()` in
+ * {@link https://firebase.google.com/docs/database/web/lists-of-data#filtering_data | Filtering data}.
+ *
+ * @param value - The value to end at. The argument type depends on which
+ * `orderBy*()` function was used in this query. Specify a value that matches
+ * the `orderBy*()` type. When used in combination with `orderByKey()`, the
+ * value must be a string.
+ * @param key - The child key to end at, among the children with the previously
+ * specified priority. This argument is only allowed if ordering by child,
+ * value, or priority.
+ */
+export declare function endAt(
+ value: number | string | boolean | null,
+ key?: string
+): QueryConstraint;
+
+/**
+ * Creates a `QueryConstraint` with the specified ending point (exclusive).
+ *
+ * Using `startAt()`, `startAfter()`, `endBefore()`, `endAt()` and `equalTo()`
+ * allows you to choose arbitrary starting and ending points for your queries.
+ *
+ * The ending point is exclusive. If only a value is provided, children
+ * with a value less than the specified value will be included in the query.
+ * If a key is specified, then children must have a value less than or equal
+ * to the specified value and a key name less than the specified key.
+ *
+ * @param value - The value to end before. The argument type depends on which
+ * `orderBy*()` function was used in this query. Specify a value that matches
+ * the `orderBy*()` type. When used in combination with `orderByKey()`, the
+ * value must be a string.
+ * @param key - The child key to end before, among the children with the
+ * previously specified priority. This argument is only allowed if ordering by
+ * child, value, or priority.
+ */
+export declare function endBefore(
+ value: number | string | boolean | null,
+ key?: string
+): QueryConstraint;
+
+/**
+ * Creates a `QueryConstraint` that includes children that match the specified
+ * value.
+ *
+ * Using `startAt()`, `startAfter()`, `endBefore()`, `endAt()` and `equalTo()`
+ * allows you to choose arbitrary starting and ending points for your queries.
+ *
+ * The optional key argument can be used to further limit the range of the
+ * query. If it is specified, then children that have exactly the specified
+ * value must also have exactly the specified key as their key name. This can be
+ * used to filter result sets with many matches for the same value.
+ *
+ * You can read more about `equalTo()` in
+ * {@link https://firebase.google.com/docs/database/web/lists-of-data#filtering_data | Filtering data}.
+ *
+ * @param value - The value to match for. The argument type depends on which
+ * `orderBy*()` function was used in this query. Specify a value that matches
+ * the `orderBy*()` type. When used in combination with `orderByKey()`, the
+ * value must be a string.
+ * @param key - The child key to start at, among the children with the
+ * previously specified priority. This argument is only allowed if ordering by
+ * child, value, or priority.
+ */
+export declare function equalTo(
+ value: number | string | boolean | null,
+ key?: string
+): QueryConstraint;
+
+/**
+ * Encapsulates the data needed to raise an event
+ * @interface
+ */
+declare interface Event_2 {
+ getPath(): Path;
+ getEventType(): string;
+ getEventRunner(): () => void;
+ toString(): string;
+}
+
+/**
+ * An EventGenerator is used to convert "raw" changes (Change) as computed by the
+ * CacheDiffer into actual events (Event) that can be raised. See generateEventsForChanges()
+ * for details.
+ *
+ */
+declare class EventGenerator {
+ query_: QueryContext;
+ index_: Index;
+ constructor(query_: QueryContext);
+}
+
+declare interface EventList {
+ events: Event_2[];
+ path: Path;
+}
+
+/**
+ * The event queue serves a few purposes:
+ * 1. It ensures we maintain event order in the face of event callbacks doing operations that result in more
+ * events being queued.
+ * 2. raiseQueuedEvents() handles being called reentrantly nicely. That is, if in the course of raising events,
+ * raiseQueuedEvents() is called again, the "inner" call will pick up raising events where the "outer" call
+ * left off, ensuring that the events are still raised synchronously and in order.
+ * 3. You can use raiseEventsAtPath and raiseEventsForChangedPath to ensure only relevant previously-queued
+ * events are raised synchronously.
+ *
+ * NOTE: This can all go away if/when we move to async events.
+ *
+ */
+declare class EventQueue {
+ eventLists_: EventList[];
+ /**
+ * Tracks recursion depth of raiseQueuedEvents_, for debugging purposes.
+ */
+ recursionDepth_: number;
+}
+
+/**
+ * An EventRegistration is basically an event type ('value', 'child_added', etc.) and a callback
+ * to be notified of that type of event.
+ *
+ * That said, it can also contain a cancel callback to be notified if the event is canceled. And
+ * currently, this code is organized around the idea that you would register multiple child_ callbacks
+ * together, as a single EventRegistration. Though currently we don't do that.
+ */
+declare interface EventRegistration {
+ /**
+ * True if this container has a callback to trigger for this event type
+ */
+ respondsTo(eventType: string): boolean;
+ createEvent(change: Change, query: QueryContext): Event_2;
+ /**
+ * Given event data, return a function to trigger the user's callback
+ */
+ getEventRunner(eventData: Event_2): () => void;
+ createCancelEvent(error: Error, path: Path): CancelEvent | null;
+ matches(other: EventRegistration): boolean;
+ /**
+ * False basically means this is a "dummy" callback container being used as a sentinel
+ * to remove all callback containers of a particular type. (e.g. if the user does
+ * ref.off('value') without specifying a specific callback).
+ *
+ * (TODO: Rework this, since it's hacky)
+ *
+ */
+ hasAnyCallback(): boolean;
+}
+
+/**
+ * One of the following strings: "value", "child_added", "child_changed",
+ * "child_removed", or "child_moved."
+ */
+export declare type EventType =
+ | 'value'
+ | 'child_added'
+ | 'child_changed'
+ | 'child_moved'
+ | 'child_removed';
+
+/* Excluded from this release type: _FirebaseService */
+
+/**
+ * Force the use of longPolling instead of websockets. This will be ignored if websocket protocol is used in databaseURL.
+ */
+export declare function forceLongPolling(): void;
+
+/**
+ * Force the use of websockets instead of longPolling.
+ */
+export declare function forceWebSockets(): void;
+
+/**
+ * Gets the most up-to-date result for this query.
+ *
+ * @param query - The query to run.
+ * @returns A `Promise` which resolves to the resulting DataSnapshot if a value is
+ * available, or rejects if the client is unable to return a value (e.g., if the
+ * server is unreachable and there is nothing cached).
+ */
+export declare function get(query: Query): Promise;
+
+/**
+ * Returns the instance of the Realtime Database SDK that is associated with the provided
+ * {@link @firebase/app#FirebaseApp}. Initializes a new instance with default settings if
+ * no instance exists or if the existing instance uses a custom database URL.
+ *
+ * @param app - The {@link @firebase/app#FirebaseApp} instance that the returned Realtime
+ * Database instance is associated with.
+ * @param url - The URL of the Realtime Database instance to connect to. If not
+ * provided, the SDK connects to the default instance of the Firebase App.
+ * @returns The `Database` instance of the provided app.
+ */
+export declare function getDatabase(app?: FirebaseApp, url?: string): Database;
+
+/**
+ * Disconnects from the server (all Database operations will be completed
+ * offline).
+ *
+ * The client automatically maintains a persistent connection to the Database
+ * server, which will remain active indefinitely and reconnect when
+ * disconnected. However, the `goOffline()` and `goOnline()` methods may be used
+ * to control the client connection in cases where a persistent connection is
+ * undesirable.
+ *
+ * While offline, the client will no longer receive data updates from the
+ * Database. However, all Database operations performed locally will continue to
+ * immediately fire events, allowing your application to continue behaving
+ * normally. Additionally, each operation performed locally will automatically
+ * be queued and retried upon reconnection to the Database server.
+ *
+ * To reconnect to the Database and begin receiving remote events, see
+ * `goOnline()`.
+ *
+ * @param db - The instance to disconnect.
+ */
+export declare function goOffline(db: Database): void;
+
+/**
+ * Reconnects to the server and synchronizes the offline Database state
+ * with the server state.
+ *
+ * This method should be used after disabling the active connection with
+ * `goOffline()`. Once reconnected, the client will transmit the proper data
+ * and fire the appropriate events so that your client "catches up"
+ * automatically.
+ *
+ * @param db - The instance to reconnect.
+ */
+export declare function goOnline(db: Database): void;
+
+/**
+ * A tree with immutable elements.
+ */
+declare class ImmutableTree {
+ readonly value: T | null;
+ readonly children: SortedMap>;
+ static fromObject(obj: { [k: string]: T }): ImmutableTree;
+ constructor(value: T | null, children?: SortedMap>);
+ /**
+ * True if the value is empty and there are no children
+ */
+ isEmpty(): boolean;
+ /**
+ * Given a path and predicate, return the first node and the path to that node
+ * where the predicate returns true.
+ *
+ * TODO Do a perf test -- If we're creating a bunch of `{path: value:}`
+ * objects on the way back out, it may be better to pass down a pathSoFar obj.
+ *
+ * @param relativePath - The remainder of the path
+ * @param predicate - The predicate to satisfy to return a node
+ */
+ findRootMostMatchingPathAndValue(
+ relativePath: Path,
+ predicate: (a: T) => boolean
+ ): {
+ path: Path;
+ value: T;
+ } | null;
+ /**
+ * Find, if it exists, the shortest subpath of the given path that points a defined
+ * value in the tree
+ */
+ findRootMostValueAndPath(relativePath: Path): {
+ path: Path;
+ value: T;
+ } | null;
+ /**
+ * @returns The subtree at the given path
+ */
+ subtree(relativePath: Path): ImmutableTree;
+ /**
+ * Sets a value at the specified path.
+ *
+ * @param relativePath - Path to set value at.
+ * @param toSet - Value to set.
+ * @returns Resulting tree.
+ */
+ set(relativePath: Path, toSet: T | null): ImmutableTree;
+ /**
+ * Removes the value at the specified path.
+ *
+ * @param relativePath - Path to value to remove.
+ * @returns Resulting tree.
+ */
+ remove(relativePath: Path): ImmutableTree;
+ /**
+ * Gets a value from the tree.
+ *
+ * @param relativePath - Path to get value for.
+ * @returns Value at path, or null.
+ */
+ get(relativePath: Path): T | null;
+ /**
+ * Replace the subtree at the specified path with the given new tree.
+ *
+ * @param relativePath - Path to replace subtree for.
+ * @param newTree - New tree.
+ * @returns Resulting tree.
+ */
+ setTree(relativePath: Path, newTree: ImmutableTree): ImmutableTree;
+ /**
+ * Performs a depth first fold on this tree. Transforms a tree into a single
+ * value, given a function that operates on the path to a node, an optional
+ * current value, and a map of child names to folded subtrees
+ */
+ fold(
+ fn: (
+ path: Path,
+ value: T,
+ children: {
+ [k: string]: V;
+ }
+ ) => V
+ ): V;
+ /**
+ * Recursive helper for public-facing fold() method
+ */
+ private fold_;
+ /**
+ * Find the first matching value on the given path. Return the result of applying f to it.
+ */
+ findOnPath(path: Path, f: (path: Path, value: T) => V | null): V | null;
+ private findOnPath_;
+ foreachOnPath(
+ path: Path,
+ f: (path: Path, value: T) => void
+ ): ImmutableTree;
+ private foreachOnPath_;
+ /**
+ * Calls the given function for each node in the tree that has a value.
+ *
+ * @param f - A function to be called with the path from the root of the tree to
+ * a node, and the value at that node. Called in depth-first order.
+ */
+ foreach(f: (path: Path, value: T) => void): void;
+ private foreach_;
+ foreachChild(f: (name: string, value: T) => void): void;
+}
+
+/**
+ * Returns a placeholder value that can be used to atomically increment the
+ * current database value by the provided delta.
+ *
+ * @param delta - the amount to modify the current value atomically.
+ * @returns A placeholder value for modifying data atomically server-side.
+ */
+export declare function increment(delta: number): object;
+
+declare abstract class Index {
+ abstract compare(a: NamedNode, b: NamedNode): number;
+ abstract isDefinedOn(node: Node_2): boolean;
+ /**
+ * @returns A standalone comparison function for
+ * this index
+ */
+ getCompare(): Comparator;
+ /**
+ * Given a before and after value for a node, determine if the indexed value has changed. Even if they are different,
+ * it's possible that the changes are isolated to parts of the snapshot that are not indexed.
+ *
+ *
+ * @returns True if the portion of the snapshot being indexed changed between oldNode and newNode
+ */
+ indexedValueChanged(oldNode: Node_2, newNode: Node_2): boolean;
+ /**
+ * @returns a node wrapper that will sort equal to or less than
+ * any other node wrapper, using this index
+ */
+ minPost(): NamedNode;
+ /**
+ * @returns a node wrapper that will sort greater than or equal to
+ * any other node wrapper, using this index
+ */
+ abstract maxPost(): NamedNode;
+ abstract makePost(indexValue: unknown, name: string): NamedNode;
+ /**
+ * @returns String representation for inclusion in a query spec
+ */
+ abstract toString(): string;
+}
+
+/* Excluded from this release type: _initStandalone */
+
+/**
+ * Represents a child snapshot of a `Reference` that is being iterated over. The key will never be undefined.
+ */
+export declare interface IteratedDataSnapshot extends DataSnapshot {
+ key: string;
+}
+
+/**
+ * Creates a new `QueryConstraint` that if limited to the first specific number
+ * of children.
+ *
+ * The `limitToFirst()` method is used to set a maximum number of children to be
+ * synced for a given callback. If we set a limit of 100, we will initially only
+ * receive up to 100 `child_added` events. If we have fewer than 100 messages
+ * stored in our Database, a `child_added` event will fire for each message.
+ * However, if we have over 100 messages, we will only receive a `child_added`
+ * event for the first 100 ordered messages. As items change, we will receive
+ * `child_removed` events for each item that drops out of the active list so
+ * that the total number stays at 100.
+ *
+ * You can read more about `limitToFirst()` in
+ * {@link https://firebase.google.com/docs/database/web/lists-of-data#filtering_data | Filtering data}.
+ *
+ * @param limit - The maximum number of nodes to include in this query.
+ */
+export declare function limitToFirst(limit: number): QueryConstraint;
+
+/**
+ * Creates a new `QueryConstraint` that is limited to return only the last
+ * specified number of children.
+ *
+ * The `limitToLast()` method is used to set a maximum number of children to be
+ * synced for a given callback. If we set a limit of 100, we will initially only
+ * receive up to 100 `child_added` events. If we have fewer than 100 messages
+ * stored in our Database, a `child_added` event will fire for each message.
+ * However, if we have over 100 messages, we will only receive a `child_added`
+ * event for the last 100 ordered messages. As items change, we will receive
+ * `child_removed` events for each item that drops out of the active list so
+ * that the total number stays at 100.
+ *
+ * You can read more about `limitToLast()` in
+ * {@link https://firebase.google.com/docs/database/web/lists-of-data#filtering_data | Filtering data}.
+ *
+ * @param limit - The maximum number of nodes to include in this query.
+ */
+export declare function limitToLast(limit: number): QueryConstraint;
+
+/** An options objects that can be used to customize a listener. */
+export declare interface ListenOptions {
+ /** Whether to remove the listener after its first invocation. */
+ readonly onlyOnce?: boolean;
+}
+
+declare interface ListenProvider {
+ startListening(
+ query: QueryContext,
+ tag: number | null,
+ hashFn: () => string,
+ onComplete: (a: string, b?: unknown) => Event_2[]
+ ): Event_2[];
+ stopListening(a: QueryContext, b: number | null): void;
+}
+
+/**
+ * Represents an empty node (a leaf node in the Red-Black Tree).
+ */
+declare class LLRBEmptyNode {
+ key: K;
+ value: V;
+ left: LLRBNode | LLRBEmptyNode;
+ right: LLRBNode | LLRBEmptyNode;
+ color: boolean;
+ /**
+ * Returns a copy of the current node.
+ *
+ * @returns The node copy.
+ */
+ copy(
+ key: K | null,
+ value: V | null,
+ color: boolean | null,
+ left: LLRBNode | LLRBEmptyNode | null,
+ right: LLRBNode | LLRBEmptyNode | null
+ ): LLRBEmptyNode;
+ /**
+ * Returns a copy of the tree, with the specified key/value added.
+ *
+ * @param key - Key to be added.
+ * @param value - Value to be added.
+ * @param comparator - Comparator.
+ * @returns New tree, with item added.
+ */
+ insert(key: K, value: V, comparator: Comparator): LLRBNode;
+ /**
+ * Returns a copy of the tree, with the specified key removed.
+ *
+ * @param key - The key to remove.
+ * @param comparator - Comparator.
+ * @returns New tree, with item removed.
+ */
+ remove(key: K, comparator: Comparator): LLRBEmptyNode;
+ /**
+ * @returns The total number of nodes in the tree.
+ */
+ count(): number;
+ /**
+ * @returns True if the tree is empty.
+ */
+ isEmpty(): boolean;
+ /**
+ * Traverses the tree in key order and calls the specified action function
+ * for each node.
+ *
+ * @param action - Callback function to be called for each
+ * node. If it returns true, traversal is aborted.
+ * @returns True if traversal was aborted.
+ */
+ inorderTraversal(action: (k: K, v: V) => unknown): boolean;
+ /**
+ * Traverses the tree in reverse key order and calls the specified action function
+ * for each node.
+ *
+ * @param action - Callback function to be called for each
+ * node. If it returns true, traversal is aborted.
+ * @returns True if traversal was aborted.
+ */
+ reverseTraversal(action: (k: K, v: V) => void): boolean;
+ minKey(): null;
+ maxKey(): null;
+ check_(): number;
+ /**
+ * @returns Whether this node is red.
+ */
+ isRed_(): boolean;
+}
+
+/**
+ * Represents a node in a Left-leaning Red-Black tree.
+ */
+declare class LLRBNode {
+ key: K;
+ value: V;
+ color: boolean;
+ left: LLRBNode | LLRBEmptyNode;
+ right: LLRBNode | LLRBEmptyNode;
+ /**
+ * @param key - Key associated with this node.
+ * @param value - Value associated with this node.
+ * @param color - Whether this node is red.
+ * @param left - Left child.
+ * @param right - Right child.
+ */
+ constructor(
+ key: K,
+ value: V,
+ color: boolean | null,
+ left?: LLRBNode | LLRBEmptyNode | null,
+ right?: LLRBNode | LLRBEmptyNode | null
+ );
+ static RED: boolean;
+ static BLACK: boolean;
+ /**
+ * Returns a copy of the current node, optionally replacing pieces of it.
+ *
+ * @param key - New key for the node, or null.
+ * @param value - New value for the node, or null.
+ * @param color - New color for the node, or null.
+ * @param left - New left child for the node, or null.
+ * @param right - New right child for the node, or null.
+ * @returns The node copy.
+ */
+ copy(
+ key: K | null,
+ value: V | null,
+ color: boolean | null,
+ left: LLRBNode | LLRBEmptyNode | null,
+ right: LLRBNode | LLRBEmptyNode | null
+ ): LLRBNode;
+ /**
+ * @returns The total number of nodes in the tree.
+ */
+ count(): number;
+ /**
+ * @returns True if the tree is empty.
+ */
+ isEmpty(): boolean;
+ /**
+ * Traverses the tree in key order and calls the specified action function
+ * for each node.
+ *
+ * @param action - Callback function to be called for each
+ * node. If it returns true, traversal is aborted.
+ * @returns The first truthy value returned by action, or the last falsey
+ * value returned by action
+ */
+ inorderTraversal(action: (k: K, v: V) => unknown): boolean;
+ /**
+ * Traverses the tree in reverse key order and calls the specified action function
+ * for each node.
+ *
+ * @param action - Callback function to be called for each
+ * node. If it returns true, traversal is aborted.
+ * @returns True if traversal was aborted.
+ */
+ reverseTraversal(action: (k: K, v: V) => void): boolean;
+ /**
+ * @returns The minimum node in the tree.
+ */
+ private min_;
+ /**
+ * @returns The maximum key in the tree.
+ */
+ minKey(): K;
+ /**
+ * @returns The maximum key in the tree.
+ */
+ maxKey(): K;
+ /**
+ * @param key - Key to insert.
+ * @param value - Value to insert.
+ * @param comparator - Comparator.
+ * @returns New tree, with the key/value added.
+ */
+ insert(key: K, value: V, comparator: Comparator): LLRBNode;
+ /**
+ * @returns New tree, with the minimum key removed.
+ */
+ private removeMin_;
+ /**
+ * @param key - The key of the item to remove.
+ * @param comparator - Comparator.
+ * @returns New tree, with the specified item removed.
+ */
+ remove(
+ key: K,
+ comparator: Comparator
+ ): LLRBNode | LLRBEmptyNode;
+ /**
+ * @returns Whether this is a RED node.
+ */
+ isRed_(): boolean;
+ /**
+ * @returns New tree after performing any needed rotations.
+ */
+ private fixUp_;
+ /**
+ * @returns New tree, after moveRedLeft.
+ */
+ private moveRedLeft_;
+ /**
+ * @returns New tree, after moveRedRight.
+ */
+ private moveRedRight_;
+ /**
+ * @returns New tree, after rotateLeft.
+ */
+ private rotateLeft_;
+ /**
+ * @returns New tree, after rotateRight.
+ */
+ private rotateRight_;
+ /**
+ * @returns Newt ree, after colorFlip.
+ */
+ private colorFlip_;
+ /**
+ * For testing.
+ *
+ * @returns True if all is well.
+ */
+ private checkMaxDepth_;
+ check_(): number;
+}
+
+declare class NamedNode {
+ name: string;
+ node: Node_2;
+ constructor(name: string, node: Node_2);
+ static Wrap(name: string, node: Node_2): NamedNode;
+}
+
+/**
+ * Node is an interface defining the common functionality for nodes in
+ * a DataSnapshot.
+ *
+ * @interface
+ */
+declare interface Node_2 {
+ /**
+ * Whether this node is a leaf node.
+ * @returns Whether this is a leaf node.
+ */
+ isLeafNode(): boolean;
+ /**
+ * Gets the priority of the node.
+ * @returns The priority of the node.
+ */
+ getPriority(): Node_2;
+ /**
+ * Returns a duplicate node with the new priority.
+ * @param newPriorityNode - New priority to set for the node.
+ * @returns Node with new priority.
+ */
+ updatePriority(newPriorityNode: Node_2): Node_2;
+ /**
+ * Returns the specified immediate child, or null if it doesn't exist.
+ * @param childName - The name of the child to retrieve.
+ * @returns The retrieved child, or an empty node.
+ */
+ getImmediateChild(childName: string): Node_2;
+ /**
+ * Returns a child by path, or null if it doesn't exist.
+ * @param path - The path of the child to retrieve.
+ * @returns The retrieved child or an empty node.
+ */
+ getChild(path: Path): Node_2;
+ /**
+ * Returns the name of the child immediately prior to the specified childNode, or null.
+ * @param childName - The name of the child to find the predecessor of.
+ * @param childNode - The node to find the predecessor of.
+ * @param index - The index to use to determine the predecessor
+ * @returns The name of the predecessor child, or null if childNode is the first child.
+ */
+ getPredecessorChildName(
+ childName: string,
+ childNode: Node_2,
+ index: Index
+ ): string | null;
+ /**
+ * Returns a duplicate node, with the specified immediate child updated.
+ * Any value in the node will be removed.
+ * @param childName - The name of the child to update.
+ * @param newChildNode - The new child node
+ * @returns The updated node.
+ */
+ updateImmediateChild(childName: string, newChildNode: Node_2): Node_2;
+ /**
+ * Returns a duplicate node, with the specified child updated. Any value will
+ * be removed.
+ * @param path - The path of the child to update.
+ * @param newChildNode - The new child node, which may be an empty node
+ * @returns The updated node.
+ */
+ updateChild(path: Path, newChildNode: Node_2): Node_2;
+ /**
+ * True if the immediate child specified exists
+ */
+ hasChild(childName: string): boolean;
+ /**
+ * @returns True if this node has no value or children.
+ */
+ isEmpty(): boolean;
+ /**
+ * @returns The number of children of this node.
+ */
+ numChildren(): number;
+ /**
+ * Calls action for each child.
+ * @param action - Action to be called for
+ * each child. It's passed the child name and the child node.
+ * @returns The first truthy value return by action, or the last falsey one
+ */
+ forEachChild(index: Index, action: (a: string, b: Node_2) => void): unknown;
+ /**
+ * @param exportFormat - True for export format (also wire protocol format).
+ * @returns Value of this node as JSON.
+ */
+ val(exportFormat?: boolean): unknown;
+ /**
+ * @returns hash representing the node contents.
+ */
+ hash(): string;
+ /**
+ * @param other - Another node
+ * @returns -1 for less than, 0 for equal, 1 for greater than other
+ */
+ compareTo(other: Node_2): number;
+ /**
+ * @returns Whether or not this snapshot equals other
+ */
+ equals(other: Node_2): boolean;
+ /**
+ * @returns This node, with the specified index now available
+ */
+ withIndex(indexDefinition: Index): Node_2;
+ isIndexed(indexDefinition: Index): boolean;
+}
+
+/**
+ * NodeFilter is used to update nodes and complete children of nodes while applying queries on the fly and keeping
+ * track of any child changes. This class does not track value changes as value changes depend on more
+ * than just the node itself. Different kind of queries require different kind of implementations of this interface.
+ * @interface
+ */
+declare interface NodeFilter_2 {
+ /**
+ * Update a single complete child in the snap. If the child equals the old child in the snap, this is a no-op.
+ * The method expects an indexed snap.
+ */
+ updateChild(
+ snap: Node_2,
+ key: string,
+ newChild: Node_2,
+ affectedPath: Path,
+ source: CompleteChildSource,
+ optChangeAccumulator: ChildChangeAccumulator | null
+ ): Node_2;
+ /**
+ * Update a node in full and output any resulting change from this complete update.
+ */
+ updateFullNode(
+ oldSnap: Node_2,
+ newSnap: Node_2,
+ optChangeAccumulator: ChildChangeAccumulator | null
+ ): Node_2;
+ /**
+ * Update the priority of the root node
+ */
+ updatePriority(oldSnap: Node_2, newPriority: Node_2): Node_2;
+ /**
+ * Returns true if children might be filtered due to query criteria
+ */
+ filtersNodes(): boolean;
+ /**
+ * Returns the index filter that this filter uses to get a NodeFilter that doesn't filter any children.
+ */
+ getIndexedFilter(): NodeFilter_2;
+ /**
+ * Returns the index that this filter uses
+ */
+ getIndex(): Index;
+}
+
+/**
+ * Detaches a callback previously attached with the corresponding `on*()` (`onValue`, `onChildAdded`) listener.
+ * Note: This is not the recommended way to remove a listener. Instead, please use the returned callback function from
+ * the respective `on*` callbacks.
+ *
+ * Detach a callback previously attached with `on*()`. Calling `off()` on a parent listener
+ * will not automatically remove listeners registered on child nodes, `off()`
+ * must also be called on any child listeners to remove the callback.
+ *
+ * If a callback is not specified, all callbacks for the specified eventType
+ * will be removed. Similarly, if no eventType is specified, all callbacks
+ * for the `Reference` will be removed.
+ *
+ * Individual listeners can also be removed by invoking their unsubscribe
+ * callbacks.
+ *
+ * @param query - The query that the listener was registered with.
+ * @param eventType - One of the following strings: "value", "child_added",
+ * "child_changed", "child_removed", or "child_moved." If omitted, all callbacks
+ * for the `Reference` will be removed.
+ * @param callback - The callback function that was passed to `on()` or
+ * `undefined` to remove all callbacks.
+ */
+export declare function off(
+ query: Query,
+ eventType?: EventType,
+ callback?: (
+ snapshot: DataSnapshot,
+ previousChildName?: string | null
+ ) => unknown
+): void;
+
+/**
+ * Listens for data changes at a particular location.
+ *
+ * This is the primary way to read data from a Database. Your callback
+ * will be triggered for the initial data and again whenever the data changes.
+ * Invoke the returned unsubscribe callback to stop receiving updates. See
+ * {@link https://firebase.google.com/docs/database/web/retrieve-data | Retrieve Data on the Web}
+ * for more details.
+ *
+ * An `onChildAdded` event will be triggered once for each initial child at this
+ * location, and it will be triggered again every time a new child is added. The
+ * `DataSnapshot` passed into the callback will reflect the data for the
+ * relevant child. For ordering purposes, it is passed a second argument which
+ * is a string containing the key of the previous sibling child by sort order,
+ * or `null` if it is the first child.
+ *
+ * @param query - The query to run.
+ * @param callback - A callback that fires when the specified event occurs.
+ * The callback will be passed a DataSnapshot and a string containing the key of
+ * the previous child, by sort order, or `null` if it is the first child.
+ * @param cancelCallback - An optional callback that will be notified if your
+ * event subscription is ever canceled because your client does not have
+ * permission to read this data (or it had permission but has now lost it).
+ * This callback will be passed an `Error` object indicating why the failure
+ * occurred.
+ * @returns A function that can be invoked to remove the listener.
+ */
+export declare function onChildAdded(
+ query: Query,
+ callback: (
+ snapshot: DataSnapshot,
+ previousChildName?: string | null
+ ) => unknown,
+ cancelCallback?: (error: Error) => unknown
+): Unsubscribe;
+
+/**
+ * Listens for data changes at a particular location.
+ *
+ * This is the primary way to read data from a Database. Your callback
+ * will be triggered for the initial data and again whenever the data changes.
+ * Invoke the returned unsubscribe callback to stop receiving updates. See
+ * {@link https://firebase.google.com/docs/database/web/retrieve-data | Retrieve Data on the Web}
+ * for more details.
+ *
+ * An `onChildAdded` event will be triggered once for each initial child at this
+ * location, and it will be triggered again every time a new child is added. The
+ * `DataSnapshot` passed into the callback will reflect the data for the
+ * relevant child. For ordering purposes, it is passed a second argument which
+ * is a string containing the key of the previous sibling child by sort order,
+ * or `null` if it is the first child.
+ *
+ * @param query - The query to run.
+ * @param callback - A callback that fires when the specified event occurs.
+ * The callback will be passed a DataSnapshot and a string containing the key of
+ * the previous child, by sort order, or `null` if it is the first child.
+ * @param options - An object that can be used to configure `onlyOnce`, which
+ * then removes the listener after its first invocation.
+ * @returns A function that can be invoked to remove the listener.
+ */
+export declare function onChildAdded(
+ query: Query,
+ callback: (
+ snapshot: DataSnapshot,
+ previousChildName: string | null
+ ) => unknown,
+ options: ListenOptions
+): Unsubscribe;
+
+/**
+ * Listens for data changes at a particular location.
+ *
+ * This is the primary way to read data from a Database. Your callback
+ * will be triggered for the initial data and again whenever the data changes.
+ * Invoke the returned unsubscribe callback to stop receiving updates. See
+ * {@link https://firebase.google.com/docs/database/web/retrieve-data | Retrieve Data on the Web}
+ * for more details.
+ *
+ * An `onChildAdded` event will be triggered once for each initial child at this
+ * location, and it will be triggered again every time a new child is added. The
+ * `DataSnapshot` passed into the callback will reflect the data for the
+ * relevant child. For ordering purposes, it is passed a second argument which
+ * is a string containing the key of the previous sibling child by sort order,
+ * or `null` if it is the first child.
+ *
+ * @param query - The query to run.
+ * @param callback - A callback that fires when the specified event occurs.
+ * The callback will be passed a DataSnapshot and a string containing the key of
+ * the previous child, by sort order, or `null` if it is the first child.
+ * @param cancelCallback - An optional callback that will be notified if your
+ * event subscription is ever canceled because your client does not have
+ * permission to read this data (or it had permission but has now lost it).
+ * This callback will be passed an `Error` object indicating why the failure
+ * occurred.
+ * @param options - An object that can be used to configure `onlyOnce`, which
+ * then removes the listener after its first invocation.
+ * @returns A function that can be invoked to remove the listener.
+ */
+export declare function onChildAdded(
+ query: Query,
+ callback: (
+ snapshot: DataSnapshot,
+ previousChildName: string | null
+ ) => unknown,
+ cancelCallback: (error: Error) => unknown,
+ options: ListenOptions
+): Unsubscribe;
+
+/**
+ * Listens for data changes at a particular location.
+ *
+ * This is the primary way to read data from a Database. Your callback
+ * will be triggered for the initial data and again whenever the data changes.
+ * Invoke the returned unsubscribe callback to stop receiving updates. See
+ * {@link https://firebase.google.com/docs/database/web/retrieve-data | Retrieve Data on the Web}
+ * for more details.
+ *
+ * An `onChildChanged` event will be triggered when the data stored in a child
+ * (or any of its descendants) changes. Note that a single `child_changed` event
+ * may represent multiple changes to the child. The `DataSnapshot` passed to the
+ * callback will contain the new child contents. For ordering purposes, the
+ * callback is also passed a second argument which is a string containing the
+ * key of the previous sibling child by sort order, or `null` if it is the first
+ * child.
+ *
+ * @param query - The query to run.
+ * @param callback - A callback that fires when the specified event occurs.
+ * The callback will be passed a DataSnapshot and a string containing the key of
+ * the previous child, by sort order, or `null` if it is the first child.
+ * @param cancelCallback - An optional callback that will be notified if your
+ * event subscription is ever canceled because your client does not have
+ * permission to read this data (or it had permission but has now lost it).
+ * This callback will be passed an `Error` object indicating why the failure
+ * occurred.
+ * @returns A function that can be invoked to remove the listener.
+ */
+export declare function onChildChanged(
+ query: Query,
+ callback: (
+ snapshot: DataSnapshot,
+ previousChildName: string | null
+ ) => unknown,
+ cancelCallback?: (error: Error) => unknown
+): Unsubscribe;
+
+/**
+ * Listens for data changes at a particular location.
+ *
+ * This is the primary way to read data from a Database. Your callback
+ * will be triggered for the initial data and again whenever the data changes.
+ * Invoke the returned unsubscribe callback to stop receiving updates. See
+ * {@link https://firebase.google.com/docs/database/web/retrieve-data | Retrieve Data on the Web}
+ * for more details.
+ *
+ * An `onChildChanged` event will be triggered when the data stored in a child
+ * (or any of its descendants) changes. Note that a single `child_changed` event
+ * may represent multiple changes to the child. The `DataSnapshot` passed to the
+ * callback will contain the new child contents. For ordering purposes, the
+ * callback is also passed a second argument which is a string containing the
+ * key of the previous sibling child by sort order, or `null` if it is the first
+ * child.
+ *
+ * @param query - The query to run.
+ * @param callback - A callback that fires when the specified event occurs.
+ * The callback will be passed a DataSnapshot and a string containing the key of
+ * the previous child, by sort order, or `null` if it is the first child.
+ * @param options - An object that can be used to configure `onlyOnce`, which
+ * then removes the listener after its first invocation.
+ * @returns A function that can be invoked to remove the listener.
+ */
+export declare function onChildChanged(
+ query: Query,
+ callback: (
+ snapshot: DataSnapshot,
+ previousChildName: string | null
+ ) => unknown,
+ options: ListenOptions
+): Unsubscribe;
+
+/**
+ * Listens for data changes at a particular location.
+ *
+ * This is the primary way to read data from a Database. Your callback
+ * will be triggered for the initial data and again whenever the data changes.
+ * Invoke the returned unsubscribe callback to stop receiving updates. See
+ * {@link https://firebase.google.com/docs/database/web/retrieve-data | Retrieve Data on the Web}
+ * for more details.
+ *
+ * An `onChildChanged` event will be triggered when the data stored in a child
+ * (or any of its descendants) changes. Note that a single `child_changed` event
+ * may represent multiple changes to the child. The `DataSnapshot` passed to the
+ * callback will contain the new child contents. For ordering purposes, the
+ * callback is also passed a second argument which is a string containing the
+ * key of the previous sibling child by sort order, or `null` if it is the first
+ * child.
+ *
+ * @param query - The query to run.
+ * @param callback - A callback that fires when the specified event occurs.
+ * The callback will be passed a DataSnapshot and a string containing the key of
+ * the previous child, by sort order, or `null` if it is the first child.
+ * @param cancelCallback - An optional callback that will be notified if your
+ * event subscription is ever canceled because your client does not have
+ * permission to read this data (or it had permission but has now lost it).
+ * This callback will be passed an `Error` object indicating why the failure
+ * occurred.
+ * @param options - An object that can be used to configure `onlyOnce`, which
+ * then removes the listener after its first invocation.
+ * @returns A function that can be invoked to remove the listener.
+ */
+export declare function onChildChanged(
+ query: Query,
+ callback: (
+ snapshot: DataSnapshot,
+ previousChildName: string | null
+ ) => unknown,
+ cancelCallback: (error: Error) => unknown,
+ options: ListenOptions
+): Unsubscribe;
+
+/**
+ * Listens for data changes at a particular location.
+ *
+ * This is the primary way to read data from a Database. Your callback
+ * will be triggered for the initial data and again whenever the data changes.
+ * Invoke the returned unsubscribe callback to stop receiving updates. See
+ * {@link https://firebase.google.com/docs/database/web/retrieve-data | Retrieve Data on the Web}
+ * for more details.
+ *
+ * An `onChildMoved` event will be triggered when a child's sort order changes
+ * such that its position relative to its siblings changes. The `DataSnapshot`
+ * passed to the callback will be for the data of the child that has moved. It
+ * is also passed a second argument which is a string containing the key of the
+ * previous sibling child by sort order, or `null` if it is the first child.
+ *
+ * @param query - The query to run.
+ * @param callback - A callback that fires when the specified event occurs.
+ * The callback will be passed a DataSnapshot and a string containing the key of
+ * the previous child, by sort order, or `null` if it is the first child.
+ * @param cancelCallback - An optional callback that will be notified if your
+ * event subscription is ever canceled because your client does not have
+ * permission to read this data (or it had permission but has now lost it).
+ * This callback will be passed an `Error` object indicating why the failure
+ * occurred.
+ * @returns A function that can be invoked to remove the listener.
+ */
+export declare function onChildMoved(
+ query: Query,
+ callback: (
+ snapshot: DataSnapshot,
+ previousChildName: string | null
+ ) => unknown,
+ cancelCallback?: (error: Error) => unknown
+): Unsubscribe;
+
+/**
+ * Listens for data changes at a particular location.
+ *
+ * This is the primary way to read data from a Database. Your callback
+ * will be triggered for the initial data and again whenever the data changes.
+ * Invoke the returned unsubscribe callback to stop receiving updates. See
+ * {@link https://firebase.google.com/docs/database/web/retrieve-data | Retrieve Data on the Web}
+ * for more details.
+ *
+ * An `onChildMoved` event will be triggered when a child's sort order changes
+ * such that its position relative to its siblings changes. The `DataSnapshot`
+ * passed to the callback will be for the data of the child that has moved. It
+ * is also passed a second argument which is a string containing the key of the
+ * previous sibling child by sort order, or `null` if it is the first child.
+ *
+ * @param query - The query to run.
+ * @param callback - A callback that fires when the specified event occurs.
+ * The callback will be passed a DataSnapshot and a string containing the key of
+ * the previous child, by sort order, or `null` if it is the first child.
+ * @param options - An object that can be used to configure `onlyOnce`, which
+ * then removes the listener after its first invocation.
+ * @returns A function that can be invoked to remove the listener.
+ */
+export declare function onChildMoved(
+ query: Query,
+ callback: (
+ snapshot: DataSnapshot,
+ previousChildName: string | null
+ ) => unknown,
+ options: ListenOptions
+): Unsubscribe;
+
+/**
+ * Listens for data changes at a particular location.
+ *
+ * This is the primary way to read data from a Database. Your callback
+ * will be triggered for the initial data and again whenever the data changes.
+ * Invoke the returned unsubscribe callback to stop receiving updates. See
+ * {@link https://firebase.google.com/docs/database/web/retrieve-data | Retrieve Data on the Web}
+ * for more details.
+ *
+ * An `onChildMoved` event will be triggered when a child's sort order changes
+ * such that its position relative to its siblings changes. The `DataSnapshot`
+ * passed to the callback will be for the data of the child that has moved. It
+ * is also passed a second argument which is a string containing the key of the
+ * previous sibling child by sort order, or `null` if it is the first child.
+ *
+ * @param query - The query to run.
+ * @param callback - A callback that fires when the specified event occurs.
+ * The callback will be passed a DataSnapshot and a string containing the key of
+ * the previous child, by sort order, or `null` if it is the first child.
+ * @param cancelCallback - An optional callback that will be notified if your
+ * event subscription is ever canceled because your client does not have
+ * permission to read this data (or it had permission but has now lost it).
+ * This callback will be passed an `Error` object indicating why the failure
+ * occurred.
+ * @param options - An object that can be used to configure `onlyOnce`, which
+ * then removes the listener after its first invocation.
+ * @returns A function that can be invoked to remove the listener.
+ */
+export declare function onChildMoved(
+ query: Query,
+ callback: (
+ snapshot: DataSnapshot,
+ previousChildName: string | null
+ ) => unknown,
+ cancelCallback: (error: Error) => unknown,
+ options: ListenOptions
+): Unsubscribe;
+
+/**
+ * Listens for data changes at a particular location.
+ *
+ * This is the primary way to read data from a Database. Your callback
+ * will be triggered for the initial data and again whenever the data changes.
+ * Invoke the returned unsubscribe callback to stop receiving updates. See
+ * {@link https://firebase.google.com/docs/database/web/retrieve-data | Retrieve Data on the Web}
+ * for more details.
+ *
+ * An `onChildRemoved` event will be triggered once every time a child is
+ * removed. The `DataSnapshot` passed into the callback will be the old data for
+ * the child that was removed. A child will get removed when either:
+ *
+ * - a client explicitly calls `remove()` on that child or one of its ancestors
+ * - a client calls `set(null)` on that child or one of its ancestors
+ * - that child has all of its children removed
+ * - there is a query in effect which now filters out the child (because it's
+ * sort order changed or the max limit was hit)
+ *
+ * @param query - The query to run.
+ * @param callback - A callback that fires when the specified event occurs.
+ * The callback will be passed a DataSnapshot and a string containing the key of
+ * the previous child, by sort order, or `null` if it is the first child.
+ * @param cancelCallback - An optional callback that will be notified if your
+ * event subscription is ever canceled because your client does not have
+ * permission to read this data (or it had permission but has now lost it).
+ * This callback will be passed an `Error` object indicating why the failure
+ * occurred.
+ * @returns A function that can be invoked to remove the listener.
+ */
+export declare function onChildRemoved(
+ query: Query,
+ callback: (snapshot: DataSnapshot) => unknown,
+ cancelCallback?: (error: Error) => unknown
+): Unsubscribe;
+
+/**
+ * Listens for data changes at a particular location.
+ *
+ * This is the primary way to read data from a Database. Your callback
+ * will be triggered for the initial data and again whenever the data changes.
+ * Invoke the returned unsubscribe callback to stop receiving updates. See
+ * {@link https://firebase.google.com/docs/database/web/retrieve-data | Retrieve Data on the Web}
+ * for more details.
+ *
+ * An `onChildRemoved` event will be triggered once every time a child is
+ * removed. The `DataSnapshot` passed into the callback will be the old data for
+ * the child that was removed. A child will get removed when either:
+ *
+ * - a client explicitly calls `remove()` on that child or one of its ancestors
+ * - a client calls `set(null)` on that child or one of its ancestors
+ * - that child has all of its children removed
+ * - there is a query in effect which now filters out the child (because it's
+ * sort order changed or the max limit was hit)
+ *
+ * @param query - The query to run.
+ * @param callback - A callback that fires when the specified event occurs.
+ * The callback will be passed a DataSnapshot and a string containing the key of
+ * the previous child, by sort order, or `null` if it is the first child.
+ * @param options - An object that can be used to configure `onlyOnce`, which
+ * then removes the listener after its first invocation.
+ * @returns A function that can be invoked to remove the listener.
+ */
+export declare function onChildRemoved(
+ query: Query,
+ callback: (snapshot: DataSnapshot) => unknown,
+ options: ListenOptions
+): Unsubscribe;
+
+/**
+ * Listens for data changes at a particular location.
+ *
+ * This is the primary way to read data from a Database. Your callback
+ * will be triggered for the initial data and again whenever the data changes.
+ * Invoke the returned unsubscribe callback to stop receiving updates. See
+ * {@link https://firebase.google.com/docs/database/web/retrieve-data | Retrieve Data on the Web}
+ * for more details.
+ *
+ * An `onChildRemoved` event will be triggered once every time a child is
+ * removed. The `DataSnapshot` passed into the callback will be the old data for
+ * the child that was removed. A child will get removed when either:
+ *
+ * - a client explicitly calls `remove()` on that child or one of its ancestors
+ * - a client calls `set(null)` on that child or one of its ancestors
+ * - that child has all of its children removed
+ * - there is a query in effect which now filters out the child (because it's
+ * sort order changed or the max limit was hit)
+ *
+ * @param query - The query to run.
+ * @param callback - A callback that fires when the specified event occurs.
+ * The callback will be passed a DataSnapshot and a string containing the key of
+ * the previous child, by sort order, or `null` if it is the first child.
+ * @param cancelCallback - An optional callback that will be notified if your
+ * event subscription is ever canceled because your client does not have
+ * permission to read this data (or it had permission but has now lost it).
+ * This callback will be passed an `Error` object indicating why the failure
+ * occurred.
+ * @param options - An object that can be used to configure `onlyOnce`, which
+ * then removes the listener after its first invocation.
+ * @returns A function that can be invoked to remove the listener.
+ */
+export declare function onChildRemoved(
+ query: Query,
+ callback: (snapshot: DataSnapshot) => unknown,
+ cancelCallback: (error: Error) => unknown,
+ options: ListenOptions
+): Unsubscribe;
+
+/**
+ * The `onDisconnect` class allows you to write or clear data when your client
+ * disconnects from the Database server. These updates occur whether your
+ * client disconnects cleanly or not, so you can rely on them to clean up data
+ * even if a connection is dropped or a client crashes.
+ *
+ * The `onDisconnect` class is most commonly used to manage presence in
+ * applications where it is useful to detect how many clients are connected and
+ * when other clients disconnect. See
+ * {@link https://firebase.google.com/docs/database/web/offline-capabilities | Enabling Offline Capabilities in JavaScript}
+ * for more information.
+ *
+ * To avoid problems when a connection is dropped before the requests can be
+ * transferred to the Database server, these functions should be called before
+ * writing any data.
+ *
+ * Note that `onDisconnect` operations are only triggered once. If you want an
+ * operation to occur each time a disconnect occurs, you'll need to re-establish
+ * the `onDisconnect` operations each time you reconnect.
+ */
+export declare class OnDisconnect {
+ private _repo;
+ private _path;
+ /** @hideconstructor */
+ constructor(_repo: Repo, _path: Path);
+ /**
+ * Cancels all previously queued `onDisconnect()` set or update events for this
+ * location and all children.
+ *
+ * If a write has been queued for this location via a `set()` or `update()` at a
+ * parent location, the write at this location will be canceled, though writes
+ * to sibling locations will still occur.
+ *
+ * @returns Resolves when synchronization to the server is complete.
+ */
+ cancel(): Promise;
+ /**
+ * Ensures the data at this location is deleted when the client is disconnected
+ * (due to closing the browser, navigating to a new page, or network issues).
+ *
+ * @returns Resolves when synchronization to the server is complete.
+ */
+ remove(): Promise;
+ /**
+ * Ensures the data at this location is set to the specified value when the
+ * client is disconnected (due to closing the browser, navigating to a new page,
+ * or network issues).
+ *
+ * `set()` is especially useful for implementing "presence" systems, where a
+ * value should be changed or cleared when a user disconnects so that they
+ * appear "offline" to other users. See
+ * {@link https://firebase.google.com/docs/database/web/offline-capabilities | Enabling Offline Capabilities in JavaScript}
+ * for more information.
+ *
+ * Note that `onDisconnect` operations are only triggered once. If you want an
+ * operation to occur each time a disconnect occurs, you'll need to re-establish
+ * the `onDisconnect` operations each time.
+ *
+ * @param value - The value to be written to this location on disconnect (can
+ * be an object, array, string, number, boolean, or null).
+ * @returns Resolves when synchronization to the Database is complete.
+ */
+ set(value: unknown): Promise;
+ /**
+ * Ensures the data at this location is set to the specified value and priority
+ * when the client is disconnected (due to closing the browser, navigating to a
+ * new page, or network issues).
+ *
+ * @param value - The value to be written to this location on disconnect (can
+ * be an object, array, string, number, boolean, or null).
+ * @param priority - The priority to be written (string, number, or null).
+ * @returns Resolves when synchronization to the Database is complete.
+ */
+ setWithPriority(
+ value: unknown,
+ priority: number | string | null
+ ): Promise;
+ /**
+ * Writes multiple values at this location when the client is disconnected (due
+ * to closing the browser, navigating to a new page, or network issues).
+ *
+ * The `values` argument contains multiple property-value pairs that will be
+ * written to the Database together. Each child property can either be a simple
+ * property (for example, "name") or a relative path (for example, "name/first")
+ * from the current location to the data to update.
+ *
+ * As opposed to the `set()` method, `update()` can be use to selectively update
+ * only the referenced properties at the current location (instead of replacing
+ * all the child properties at the current location).
+ *
+ * @param values - Object containing multiple values.
+ * @returns Resolves when synchronization to the Database is complete.
+ */
+ update(values: object): Promise;
+}
+
+/**
+ * Returns an `OnDisconnect` object - see
+ * {@link https://firebase.google.com/docs/database/web/offline-capabilities | Enabling Offline Capabilities in JavaScript}
+ * for more information on how to use it.
+ *
+ * @param ref - The reference to add OnDisconnect triggers for.
+ */
+export declare function onDisconnect(ref: DatabaseReference): OnDisconnect;
+
+/**
+ * Listens for data changes at a particular location.
+ *
+ * This is the primary way to read data from a Database. Your callback
+ * will be triggered for the initial data and again whenever the data changes.
+ * Invoke the returned unsubscribe callback to stop receiving updates. See
+ * {@link https://firebase.google.com/docs/database/web/retrieve-data | Retrieve Data on the Web}
+ * for more details.
+ *
+ * An `onValue` event will trigger once with the initial data stored at this
+ * location, and then trigger again each time the data changes. The
+ * `DataSnapshot` passed to the callback will be for the location at which
+ * `on()` was called. It won't trigger until the entire contents has been
+ * synchronized. If the location has no data, it will be triggered with an empty
+ * `DataSnapshot` (`val()` will return `null`).
+ *
+ * @param query - The query to run.
+ * @param callback - A callback that fires when the specified event occurs. The
+ * callback will be passed a DataSnapshot.
+ * @param cancelCallback - An optional callback that will be notified if your
+ * event subscription is ever canceled because your client does not have
+ * permission to read this data (or it had permission but has now lost it).
+ * This callback will be passed an `Error` object indicating why the failure
+ * occurred.
+ * @returns A function that can be invoked to remove the listener.
+ */
+export declare function onValue(
+ query: Query,
+ callback: (snapshot: DataSnapshot) => unknown,
+ cancelCallback?: (error: Error) => unknown
+): Unsubscribe;
+
+/**
+ * Listens for data changes at a particular location.
+ *
+ * This is the primary way to read data from a Database. Your callback
+ * will be triggered for the initial data and again whenever the data changes.
+ * Invoke the returned unsubscribe callback to stop receiving updates. See
+ * {@link https://firebase.google.com/docs/database/web/retrieve-data | Retrieve Data on the Web}
+ * for more details.
+ *
+ * An `onValue` event will trigger once with the initial data stored at this
+ * location, and then trigger again each time the data changes. The
+ * `DataSnapshot` passed to the callback will be for the location at which
+ * `on()` was called. It won't trigger until the entire contents has been
+ * synchronized. If the location has no data, it will be triggered with an empty
+ * `DataSnapshot` (`val()` will return `null`).
+ *
+ * @param query - The query to run.
+ * @param callback - A callback that fires when the specified event occurs. The
+ * callback will be passed a DataSnapshot.
+ * @param options - An object that can be used to configure `onlyOnce`, which
+ * then removes the listener after its first invocation.
+ * @returns A function that can be invoked to remove the listener.
+ */
+export declare function onValue(
+ query: Query,
+ callback: (snapshot: DataSnapshot) => unknown,
+ options: ListenOptions
+): Unsubscribe;
+
+/**
+ * Listens for data changes at a particular location.
+ *
+ * This is the primary way to read data from a Database. Your callback
+ * will be triggered for the initial data and again whenever the data changes.
+ * Invoke the returned unsubscribe callback to stop receiving updates. See
+ * {@link https://firebase.google.com/docs/database/web/retrieve-data | Retrieve Data on the Web}
+ * for more details.
+ *
+ * An `onValue` event will trigger once with the initial data stored at this
+ * location, and then trigger again each time the data changes. The
+ * `DataSnapshot` passed to the callback will be for the location at which
+ * `on()` was called. It won't trigger until the entire contents has been
+ * synchronized. If the location has no data, it will be triggered with an empty
+ * `DataSnapshot` (`val()` will return `null`).
+ *
+ * @param query - The query to run.
+ * @param callback - A callback that fires when the specified event occurs. The
+ * callback will be passed a DataSnapshot.
+ * @param cancelCallback - An optional callback that will be notified if your
+ * event subscription is ever canceled because your client does not have
+ * permission to read this data (or it had permission but has now lost it).
+ * This callback will be passed an `Error` object indicating why the failure
+ * occurred.
+ * @param options - An object that can be used to configure `onlyOnce`, which
+ * then removes the listener after its first invocation.
+ * @returns A function that can be invoked to remove the listener.
+ */
+export declare function onValue(
+ query: Query,
+ callback: (snapshot: DataSnapshot) => unknown,
+ cancelCallback: (error: Error) => unknown,
+ options: ListenOptions
+): Unsubscribe;
+
+/**
+ * Creates a new `QueryConstraint` that orders by the specified child key.
+ *
+ * Queries can only order by one key at a time. Calling `orderByChild()`
+ * multiple times on the same query is an error.
+ *
+ * Firebase queries allow you to order your data by any child key on the fly.
+ * However, if you know in advance what your indexes will be, you can define
+ * them via the .indexOn rule in your Security Rules for better performance. See
+ * the{@link https://firebase.google.com/docs/database/security/indexing-data}
+ * rule for more information.
+ *
+ * You can read more about `orderByChild()` in
+ * {@link https://firebase.google.com/docs/database/web/lists-of-data#sort_data | Sort data}.
+ *
+ * @param path - The path to order by.
+ */
+export declare function orderByChild(path: string): QueryConstraint;
+
+/**
+ * Creates a new `QueryConstraint` that orders by the key.
+ *
+ * Sorts the results of a query by their (ascending) key values.
+ *
+ * You can read more about `orderByKey()` in
+ * {@link https://firebase.google.com/docs/database/web/lists-of-data#sort_data | Sort data}.
+ */
+export declare function orderByKey(): QueryConstraint;
+
+/**
+ * Creates a new `QueryConstraint` that orders by priority.
+ *
+ * Applications need not use priority but can order collections by
+ * ordinary properties (see
+ * {@link https://firebase.google.com/docs/database/web/lists-of-data#sort_data | Sort data}
+ * for alternatives to priority.
+ */
+export declare function orderByPriority(): QueryConstraint;
+
+/**
+ * Creates a new `QueryConstraint` that orders by value.
+ *
+ * If the children of a query are all scalar values (string, number, or
+ * boolean), you can order the results by their (ascending) values.
+ *
+ * You can read more about `orderByValue()` in
+ * {@link https://firebase.google.com/docs/database/web/lists-of-data#sort_data | Sort data}.
+ */
+export declare function orderByValue(): QueryConstraint;
+
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * An immutable object representing a parsed path. It's immutable so that you
+ * can pass them around to other functions without worrying about them changing
+ * it.
+ */
+declare class Path {
+ pieces_: string[];
+ pieceNum_: number;
+ /**
+ * @param pathOrString - Path string to parse, or another path, or the raw
+ * tokens array
+ */
+ constructor(pathOrString: string | string[], pieceNum?: number);
+ toString(): string;
+}
+
+/**
+ * Firebase connection. Abstracts wire protocol and handles reconnecting.
+ *
+ * NOTE: All JSON objects sent to the realtime connection must have property names enclosed
+ * in quotes to make sure the closure compiler does not minify them.
+ */
+declare class PersistentConnection extends ServerActions {
+ private repoInfo_;
+ private applicationId_;
+ private onDataUpdate_;
+ private onConnectStatus_;
+ private onServerInfoUpdate_;
+ private authTokenProvider_;
+ private appCheckTokenProvider_;
+ private authOverride_?;
+ id: number;
+ private log_;
+ private interruptReasons_;
+ private readonly listens;
+ private outstandingPuts_;
+ private outstandingGets_;
+ private outstandingPutCount_;
+ private outstandingGetCount_;
+ private onDisconnectRequestQueue_;
+ private connected_;
+ private reconnectDelay_;
+ private maxReconnectDelay_;
+ private securityDebugCallback_;
+ lastSessionId: string | null;
+ private establishConnectionTimer_;
+ private visible_;
+ private requestCBHash_;
+ private requestNumber_;
+ private realtime_;
+ private authToken_;
+ private appCheckToken_;
+ private forceTokenRefresh_;
+ private invalidAuthTokenCount_;
+ private invalidAppCheckTokenCount_;
+ private firstConnection_;
+ private lastConnectionAttemptTime_;
+ private lastConnectionEstablishedTime_;
+ private static nextPersistentConnectionId_;
+ /**
+ * Counter for number of connections created. Mainly used for tagging in the logs
+ */
+ private static nextConnectionId_;
+ /**
+ * @param repoInfo_ - Data about the namespace we are connecting to
+ * @param applicationId_ - The Firebase App ID for this project
+ * @param onDataUpdate_ - A callback for new data from the server
+ */
+ constructor(
+ repoInfo_: RepoInfo,
+ applicationId_: string,
+ onDataUpdate_: (
+ a: string,
+ b: unknown,
+ c: boolean,
+ d: number | null
+ ) => void,
+ onConnectStatus_: (a: boolean) => void,
+ onServerInfoUpdate_: (a: unknown) => void,
+ authTokenProvider_: AuthTokenProvider,
+ appCheckTokenProvider_: AppCheckTokenProvider,
+ authOverride_?: object | null
+ );
+ protected sendRequest(
+ action: string,
+ body: unknown,
+ onResponse?: (a: unknown) => void
+ ): void;
+ get(query: QueryContext): Promise;
+ listen(
+ query: QueryContext,
+ currentHashFn: () => string,
+ tag: number | null,
+ onComplete: (a: string, b: unknown) => void
+ ): void;
+ private sendGet_;
+ private sendListen_;
+ private static warnOnListenWarnings_;
+ refreshAuthToken(token: string): void;
+ private reduceReconnectDelayIfAdminCredential_;
+ refreshAppCheckToken(token: string | null): void;
+ /**
+ * Attempts to authenticate with the given credentials. If the authentication attempt fails, it's triggered like
+ * a auth revoked (the connection is closed).
+ */
+ tryAuth(): void;
+ /**
+ * Attempts to authenticate with the given token. If the authentication
+ * attempt fails, it's triggered like the token was revoked (the connection is
+ * closed).
+ */
+ tryAppCheck(): void;
+ /**
+ * @inheritDoc
+ */
+ unlisten(query: QueryContext, tag: number | null): void;
+ private sendUnlisten_;
+ onDisconnectPut(
+ pathString: string,
+ data: unknown,
+ onComplete?: (a: string, b: string) => void
+ ): void;
+ onDisconnectMerge(
+ pathString: string,
+ data: unknown,
+ onComplete?: (a: string, b: string) => void
+ ): void;
+ onDisconnectCancel(
+ pathString: string,
+ onComplete?: (a: string, b: string) => void
+ ): void;
+ private sendOnDisconnect_;
+ put(
+ pathString: string,
+ data: unknown,
+ onComplete?: (a: string, b: string) => void,
+ hash?: string
+ ): void;
+ merge(
+ pathString: string,
+ data: unknown,
+ onComplete: (a: string, b: string | null) => void,
+ hash?: string
+ ): void;
+ putInternal(
+ action: string,
+ pathString: string,
+ data: unknown,
+ onComplete: (a: string, b: string | null) => void,
+ hash?: string
+ ): void;
+ private sendPut_;
+ reportStats(stats: { [k: string]: unknown }): void;
+ private onDataMessage_;
+ private onDataPush_;
+ private onReady_;
+ private scheduleConnect_;
+ private initConnection_;
+ private onVisible_;
+ private onOnline_;
+ private onRealtimeDisconnect_;
+ private establishConnection_;
+ interrupt(reason: string): void;
+ resume(reason: string): void;
+ private handleTimestamp_;
+ private cancelSentTransactions_;
+ private onListenRevoked_;
+ private removeListen_;
+ private onAuthRevoked_;
+ private onAppCheckRevoked_;
+ private onSecurityDebugPacket_;
+ private restoreState_;
+ /**
+ * Sends client stats for first connection
+ */
+ private sendConnectStats_;
+ private shouldReconnect_;
+}
+
+declare class PriorityIndex extends Index {
+ compare(a: NamedNode, b: NamedNode): number;
+ isDefinedOn(node: Node_2): boolean;
+ indexedValueChanged(oldNode: Node_2, newNode: Node_2): boolean;
+ minPost(): NamedNode;
+ maxPost(): NamedNode;
+ makePost(indexValue: unknown, name: string): NamedNode;
+ /**
+ * @returns String representation for inclusion in a query spec
+ */
+ toString(): string;
+}
+
+/**
+ * Generates a new child location using a unique key and returns its
+ * `Reference`.
+ *
+ * This is the most common pattern for adding data to a collection of items.
+ *
+ * If you provide a value to `push()`, the value is written to the
+ * generated location. If you don't pass a value, nothing is written to the
+ * database and the child remains empty (but you can use the `Reference`
+ * elsewhere).
+ *
+ * The unique keys generated by `push()` are ordered by the current time, so the
+ * resulting list of items is chronologically sorted. The keys are also
+ * designed to be unguessable (they contain 72 random bits of entropy).
+ *
+ * See {@link https://firebase.google.com/docs/database/web/lists-of-data#append_to_a_list_of_data | Append to a list of data}.
+ * See {@link https://firebase.googleblog.com/2015/02/the-2120-ways-to-ensure-unique_68.html | The 2^120 Ways to Ensure Unique Identifiers}.
+ *
+ * @param parent - The parent location.
+ * @param value - Optional value to be written at the generated location.
+ * @returns Combined `Promise` and `Reference`; resolves when write is complete,
+ * but can be used immediately as the `Reference` to the child location.
+ */
+export declare function push(
+ parent: DatabaseReference,
+ value?: unknown
+): ThenableReference;
+
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * A `Query` sorts and filters the data at a Database location so only a subset
+ * of the child data is included. This can be used to order a collection of
+ * data by some attribute (for example, height of dinosaurs) as well as to
+ * restrict a large list of items (for example, chat messages) down to a number
+ * suitable for synchronizing to the client. Queries are created by chaining
+ * together one or more of the filter methods defined here.
+ *
+ * Just as with a `DatabaseReference`, you can receive data from a `Query` by using the
+ * `on*()` methods. You will only receive events and `DataSnapshot`s for the
+ * subset of the data that matches your query.
+ *
+ * See {@link https://firebase.google.com/docs/database/web/lists-of-data#sorting_and_filtering_data}
+ * for more information.
+ */
+export declare interface Query extends QueryContext {
+ /** The `DatabaseReference` for the `Query`'s location. */
+ readonly ref: DatabaseReference;
+ /**
+ * Returns whether or not the current and provided queries represent the same
+ * location, have the same query parameters, and are from the same instance of
+ * `FirebaseApp`.
+ *
+ * Two `DatabaseReference` objects are equivalent if they represent the same location
+ * and are from the same instance of `FirebaseApp`.
+ *
+ * Two `Query` objects are equivalent if they represent the same location,
+ * have the same query parameters, and are from the same instance of
+ * `FirebaseApp`. Equivalent queries share the same sort order, limits, and
+ * starting and ending points.
+ *
+ * @param other - The query to compare against.
+ * @returns Whether or not the current and provided queries are equivalent.
+ */
+ isEqual(other: Query | null): boolean;
+ /**
+ * Returns a JSON-serializable representation of this object.
+ *
+ * @returns A JSON-serializable representation of this object.
+ */
+ toJSON(): string;
+ /**
+ * Gets the absolute URL for this location.
+ *
+ * The `toString()` method returns a URL that is ready to be put into a
+ * browser, curl command, or a `refFromURL()` call. Since all of those expect
+ * the URL to be url-encoded, `toString()` returns an encoded URL.
+ *
+ * Append '.json' to the returned URL when typed into a browser to download
+ * JSON-formatted data. If the location is secured (that is, not publicly
+ * readable), you will get a permission-denied error.
+ *
+ * @returns The absolute URL for this location.
+ */
+ toString(): string;
+}
+
+/**
+ * Creates a new immutable instance of `Query` that is extended to also include
+ * additional query constraints.
+ *
+ * @param query - The Query instance to use as a base for the new constraints.
+ * @param queryConstraints - The list of `QueryConstraint`s to apply.
+ * @throws if any of the provided query constraints cannot be combined with the
+ * existing or new constraints.
+ */
+export declare function query(
+ query: Query,
+ ...queryConstraints: QueryConstraint[]
+): Query;
+
+/**
+ * A `QueryConstraint` is used to narrow the set of documents returned by a
+ * Database query. `QueryConstraint`s are created by invoking {@link endAt},
+ * {@link endBefore}, {@link startAt}, {@link startAfter}, {@link
+ * limitToFirst}, {@link limitToLast}, {@link orderByChild},
+ * {@link orderByChild}, {@link orderByKey} , {@link orderByPriority} ,
+ * {@link orderByValue} or {@link equalTo} and
+ * can then be passed to {@link query} to create a new query instance that
+ * also contains this `QueryConstraint`.
+ */
+export declare abstract class QueryConstraint {
+ /** The type of this query constraints */
+ abstract readonly type: QueryConstraintType;
+ /**
+ * Takes the provided `Query` and returns a copy of the `Query` with this
+ * `QueryConstraint` applied.
+ */
+ abstract _apply(query: _QueryImpl): _QueryImpl;
+}
+
+/** Describes the different query constraints available in this SDK. */
+export declare type QueryConstraintType =
+ | 'endAt'
+ | 'endBefore'
+ | 'startAt'
+ | 'startAfter'
+ | 'limitToFirst'
+ | 'limitToLast'
+ | 'orderByChild'
+ | 'orderByKey'
+ | 'orderByPriority'
+ | 'orderByValue'
+ | 'equalTo';
+
+declare interface QueryContext {
+ readonly _queryIdentifier: string;
+ readonly _queryObject: object;
+ readonly _repo: Repo;
+ readonly _path: Path;
+ readonly _queryParams: _QueryParams;
+}
+
+/* Excluded from this release type: _QueryImpl */
+
+/* Excluded from this release type: _QueryParams */
+
+/**
+ *
+ * Returns a `Reference` representing the location in the Database
+ * corresponding to the provided path. If no path is provided, the `Reference`
+ * will point to the root of the Database.
+ *
+ * @param db - The database instance to obtain a reference for.
+ * @param path - Optional path representing the location the returned
+ * `Reference` will point. If not provided, the returned `Reference` will
+ * point to the root of the Database.
+ * @returns If a path is provided, a `Reference`
+ * pointing to the provided path. Otherwise, a `Reference` pointing to the
+ * root of the Database.
+ */
+export declare function ref(db: Database, path?: string): DatabaseReference;
+
+/* Excluded from this release type: _ReferenceImpl */
+
+/**
+ * Returns a `Reference` representing the location in the Database
+ * corresponding to the provided Firebase URL.
+ *
+ * An exception is thrown if the URL is not a valid Firebase Database URL or it
+ * has a different domain than the current `Database` instance.
+ *
+ * Note that all query parameters (`orderBy`, `limitToLast`, etc.) are ignored
+ * and are not applied to the returned `Reference`.
+ *
+ * @param db - The database instance to obtain a reference for.
+ * @param url - The Firebase URL at which the returned `Reference` will
+ * point.
+ * @returns A `Reference` pointing to the provided
+ * Firebase URL.
+ */
+export declare function refFromURL(
+ db: Database,
+ url: string
+): DatabaseReference;
+
+/**
+ * Removes the data at this Database location.
+ *
+ * Any data at child locations will also be deleted.
+ *
+ * The effect of the remove will be visible immediately and the corresponding
+ * event 'value' will be triggered. Synchronization of the remove to the
+ * Firebase servers will also be started, and the returned Promise will resolve
+ * when complete. If provided, the onComplete callback will be called
+ * asynchronously after synchronization has finished.
+ *
+ * @param ref - The location to remove.
+ * @returns Resolves when remove on server is complete.
+ */
+export declare function remove(ref: DatabaseReference): Promise;
+
+/**
+ * A connection to a single data repository.
+ */
+declare class Repo {
+ repoInfo_: RepoInfo;
+ forceRestClient_: boolean;
+ authTokenProvider_: AuthTokenProvider;
+ appCheckProvider_: AppCheckTokenProvider;
+ /** Key for uniquely identifying this repo, used in RepoManager */
+ readonly key: string;
+ dataUpdateCount: number;
+ infoSyncTree_: SyncTree;
+ serverSyncTree_: SyncTree;
+ stats_: StatsCollection;
+ statsListener_: StatsListener | null;
+ eventQueue_: EventQueue;
+ nextWriteId_: number;
+ server_: ServerActions;
+ statsReporter_: StatsReporter;
+ infoData_: SnapshotHolder;
+ interceptServerDataCallback_: ((a: string, b: unknown) => void) | null;
+ /** A list of data pieces and paths to be set when this client disconnects. */
+ onDisconnect_: SparseSnapshotTree;
+ /** Stores queues of outstanding transactions for Firebase locations. */
+ transactionQueueTree_: Tree;
+ persistentConnection_: PersistentConnection | null;
+ constructor(
+ repoInfo_: RepoInfo,
+ forceRestClient_: boolean,
+ authTokenProvider_: AuthTokenProvider,
+ appCheckProvider_: AppCheckTokenProvider
+ );
+ /**
+ * @returns The URL corresponding to the root of this Firebase.
+ */
+ toString(): string;
+}
+
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * A class that holds metadata about a Repo object
+ */
+declare class RepoInfo {
+ readonly secure: boolean;
+ readonly namespace: string;
+ readonly webSocketOnly: boolean;
+ readonly nodeAdmin: boolean;
+ readonly persistenceKey: string;
+ readonly includeNamespaceInQueryParams: boolean;
+ readonly isUsingEmulator: boolean;
+ private _host;
+ private _domain;
+ internalHost: string;
+ /**
+ * @param host - Hostname portion of the url for the repo
+ * @param secure - Whether or not this repo is accessed over ssl
+ * @param namespace - The namespace represented by the repo
+ * @param webSocketOnly - Whether to prefer websockets over all other transports (used by Nest).
+ * @param nodeAdmin - Whether this instance uses Admin SDK credentials
+ * @param persistenceKey - Override the default session persistence storage key
+ */
+ constructor(
+ host: string,
+ secure: boolean,
+ namespace: string,
+ webSocketOnly: boolean,
+ nodeAdmin?: boolean,
+ persistenceKey?: string,
+ includeNamespaceInQueryParams?: boolean,
+ isUsingEmulator?: boolean
+ );
+ isCacheableHost(): boolean;
+ isCustomHost(): boolean;
+ get host(): string;
+ set host(newHost: string);
+ toString(): string;
+ toURLString(): string;
+}
+
+/* Excluded from this release type: _repoManagerDatabaseFromApp */
+
+/**
+ * Atomically modifies the data at this location.
+ *
+ * Atomically modify the data at this location. Unlike a normal `set()`, which
+ * just overwrites the data regardless of its previous value, `runTransaction()` is
+ * used to modify the existing value to a new value, ensuring there are no
+ * conflicts with other clients writing to the same location at the same time.
+ *
+ * To accomplish this, you pass `runTransaction()` an update function which is
+ * used to transform the current value into a new value. If another client
+ * writes to the location before your new value is successfully written, your
+ * update function will be called again with the new current value, and the
+ * write will be retried. This will happen repeatedly until your write succeeds
+ * without conflict or you abort the transaction by not returning a value from
+ * your update function.
+ *
+ * Note: Modifying data with `set()` will cancel any pending transactions at
+ * that location, so extreme care should be taken if mixing `set()` and
+ * `runTransaction()` to update the same data.
+ *
+ * Note: When using transactions with Security and Firebase Rules in place, be
+ * aware that a client needs `.read` access in addition to `.write` access in
+ * order to perform a transaction. This is because the client-side nature of
+ * transactions requires the client to read the data in order to transactionally
+ * update it.
+ *
+ * @param ref - The location to atomically modify.
+ * @param transactionUpdate - A developer-supplied function which will be passed
+ * the current data stored at this location (as a JavaScript object). The
+ * function should return the new value it would like written (as a JavaScript
+ * object). If `undefined` is returned (i.e. you return with no arguments) the
+ * transaction will be aborted and the data at this location will not be
+ * modified.
+ * @param options - An options object to configure transactions.
+ * @returns A `Promise` that can optionally be used instead of the `onComplete`
+ * callback to handle success and failure.
+ */
+export declare function runTransaction(
+ ref: DatabaseReference,
+ transactionUpdate: (currentData: any) => unknown,
+ options?: TransactionOptions
+): Promise;
+
+/**
+ * Interface defining the set of actions that can be performed against the Firebase server
+ * (basically corresponds to our wire protocol).
+ *
+ * @interface
+ */
+declare abstract class ServerActions {
+ abstract listen(
+ query: QueryContext,
+ currentHashFn: () => string,
+ tag: number | null,
+ onComplete: (a: string, b: unknown) => void
+ ): void;
+ /**
+ * Remove a listen.
+ */
+ abstract unlisten(query: QueryContext, tag: number | null): void;
+ /**
+ * Get the server value satisfying this query.
+ */
+ abstract get(query: QueryContext): Promise;
+ put(
+ pathString: string,
+ data: unknown,
+ onComplete?: (a: string, b: string) => void,
+ hash?: string
+ ): void;
+ merge(
+ pathString: string,
+ data: unknown,
+ onComplete: (a: string, b: string | null) => void,
+ hash?: string
+ ): void;
+ /**
+ * Refreshes the auth token for the current connection.
+ * @param token - The authentication token
+ */
+ refreshAuthToken(token: string): void;
+ /**
+ * Refreshes the app check token for the current connection.
+ * @param token The app check token
+ */
+ refreshAppCheckToken(token: string): void;
+ onDisconnectPut(
+ pathString: string,
+ data: unknown,
+ onComplete?: (a: string, b: string) => void
+ ): void;
+ onDisconnectMerge(
+ pathString: string,
+ data: unknown,
+ onComplete?: (a: string, b: string) => void
+ ): void;
+ onDisconnectCancel(
+ pathString: string,
+ onComplete?: (a: string, b: string) => void
+ ): void;
+ reportStats(stats: { [k: string]: unknown }): void;
+}
+
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Returns a placeholder value for auto-populating the current timestamp (time
+ * since the Unix epoch, in milliseconds) as determined by the Firebase
+ * servers.
+ */
+export declare function serverTimestamp(): object;
+
+/**
+ * Writes data to this Database location.
+ *
+ * This will overwrite any data at this location and all child locations.
+ *
+ * The effect of the write will be visible immediately, and the corresponding
+ * events ("value", "child_added", etc.) will be triggered. Synchronization of
+ * the data to the Firebase servers will also be started, and the returned
+ * Promise will resolve when complete. If provided, the `onComplete` callback
+ * will be called asynchronously after synchronization has finished.
+ *
+ * Passing `null` for the new value is equivalent to calling `remove()`; namely,
+ * all data at this location and all child locations will be deleted.
+ *
+ * `set()` will remove any priority stored at this location, so if priority is
+ * meant to be preserved, you need to use `setWithPriority()` instead.
+ *
+ * Note that modifying data with `set()` will cancel any pending transactions
+ * at that location, so extreme care should be taken if mixing `set()` and
+ * `transaction()` to modify the same data.
+ *
+ * A single `set()` will generate a single "value" event at the location where
+ * the `set()` was performed.
+ *
+ * @param ref - The location to write to.
+ * @param value - The value to be written (string, number, boolean, object,
+ * array, or null).
+ * @returns Resolves when write to server is complete.
+ */
+export declare function set(
+ ref: DatabaseReference,
+ value: unknown
+): Promise;
+
+/**
+ * Sets a priority for the data at this Database location.
+ *
+ * Applications need not use priority but can order collections by
+ * ordinary properties (see
+ * {@link https://firebase.google.com/docs/database/web/lists-of-data#sorting_and_filtering_data | Sorting and filtering data}
+ * ).
+ *
+ * @param ref - The location to write to.
+ * @param priority - The priority to be written (string, number, or null).
+ * @returns Resolves when write to server is complete.
+ */
+export declare function setPriority(
+ ref: DatabaseReference,
+ priority: string | number | null
+): Promise;
+
+/* Excluded from this release type: _setSDKVersion */
+
+/**
+ * Writes data the Database location. Like `set()` but also specifies the
+ * priority for that data.
+ *
+ * Applications need not use priority but can order collections by
+ * ordinary properties (see
+ * {@link https://firebase.google.com/docs/database/web/lists-of-data#sorting_and_filtering_data | Sorting and filtering data}
+ * ).
+ *
+ * @param ref - The location to write to.
+ * @param value - The value to be written (string, number, boolean, object,
+ * array, or null).
+ * @param priority - The priority to be written (string, number, or null).
+ * @returns Resolves when write to server is complete.
+ */
+export declare function setWithPriority(
+ ref: DatabaseReference,
+ value: unknown,
+ priority: string | number | null
+): Promise