@firebase/database-compat 2.0.0-canary.a75082f06 → 2.0.0-canary.e577a408c

package/dist/database-compat/src/index.d.ts

@@ -1,72 +1,790 @@
-/**
- * @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.
- */
-import { FirebaseNamespace } from '@firebase/app-compat';
-import * as types from '@firebase/database-types';
-export declare function registerDatabase(instance: FirebaseNamespace): void;
-declare module '@firebase/app-compat' {
-    interface FirebaseNamespace {
-        database?: {
-            (app?: FirebaseApp): types.FirebaseDatabase;
-            enableLogging: typeof types.enableLogging;
-            ServerValue: types.ServerValue;
-            Database: typeof types.FirebaseDatabase;
-        };
-    }
-    interface FirebaseApp {
-        database?(databaseURL?: string): types.FirebaseDatabase;
-    }
-}
+/**
+ * @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.
+ */
+import { FirebaseNamespace } from '@firebase/app-compat';
+import * as types from '@firebase/database-types';
+export declare function registerDatabase(instance: FirebaseNamespace): void;
+declare module '@firebase/app-compat' {
+    interface FirebaseNamespace {
+        database?: {
+            (app?: FirebaseApp): types.FirebaseDatabase;
+            enableLogging: typeof types.enableLogging;
+            ServerValue: types.ServerValue;
+            Database: typeof types.FirebaseDatabase;
+        };
+    }
+    interface FirebaseApp {
+        database?(databaseURL?: string): types.FirebaseDatabase;
+    }
+}
 
 import { FirebaseApp as FirebaseAppCompat } from "@firebase/app-compat";
 import { type DatabaseReference, type EmulatorMockTokenOptions, type DataSnapshot, type Database, type EventType, type Unsubscribe, type ListenOptions, type OnDisconnect, type ThenableReference, type QueryConstraint, type Query, type TransactionOptions, type TransactionResult } from "@firebase/database";
 declare module "@firebase/database" {
-    function child(parent: types.Reference, path: string): DatabaseReference;
-    function connectDatabaseEmulator(db: types.FirebaseDatabase, host: string, port: number, options?: {
+    /**
+     * Gets a `Reference` 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").
+     *
+     * @param parent - The parent location.
+     * @param path - A relative path from this location to the desired child
+     *   location.
+     * @returns The specified child location.
+     */
+    export declare function child(parent: types.Reference, path: string): DatabaseReference;
+    /**
+     * Modify the provided instance to communicate with the Realtime Database
+     * emulator.
+     *
+     * <p>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: types.FirebaseDatabase, host: string, port: number, options?: {
         mockUserToken?: EmulatorMockTokenOptions | string;
     }): void;
-    function get(query: types.Query): Promise<DataSnapshot>;
-    function getDatabase(app?: FirebaseAppCompat, url?: string): Database;
-    function goOffline(db: types.FirebaseDatabase): void;
-    function goOnline(db: types.FirebaseDatabase): void;
-    function off(query: types.Query, eventType?: EventType, callback?: (snapshot: DataSnapshot, previousChildName?: string | null) => unknown): void;
-    function onChildAdded(query: types.Query, callback: (snapshot: DataSnapshot, previousChildName?: string | null) => unknown, cancelCallback?: (error: Error) => unknown): Unsubscribe;
-    function onChildAdded(query: types.Query, callback: (snapshot: DataSnapshot, previousChildName: string | null) => unknown, options: ListenOptions): Unsubscribe;
-    function onChildAdded(query: types.Query, callback: (snapshot: DataSnapshot, previousChildName: string | null) => unknown, cancelCallback: (error: Error) => unknown, options: ListenOptions): Unsubscribe;
-    function onChildChanged(query: types.Query, callback: (snapshot: DataSnapshot, previousChildName: string | null) => unknown, cancelCallback?: (error: Error) => unknown): Unsubscribe;
-    function onChildChanged(query: types.Query, callback: (snapshot: DataSnapshot, previousChildName: string | null) => unknown, options: ListenOptions): Unsubscribe;
-    function onChildChanged(query: types.Query, callback: (snapshot: DataSnapshot, previousChildName: string | null) => unknown, cancelCallback: (error: Error) => unknown, options: ListenOptions): Unsubscribe;
-    function onChildMoved(query: types.Query, callback: (snapshot: DataSnapshot, previousChildName: string | null) => unknown, cancelCallback?: (error: Error) => unknown): Unsubscribe;
-    function onChildMoved(query: types.Query, callback: (snapshot: DataSnapshot, previousChildName: string | null) => unknown, options: ListenOptions): Unsubscribe;
-    function onChildMoved(query: types.Query, callback: (snapshot: DataSnapshot, previousChildName: string | null) => unknown, cancelCallback: (error: Error) => unknown, options: ListenOptions): Unsubscribe;
-    function onChildRemoved(query: types.Query, callback: (snapshot: DataSnapshot) => unknown, cancelCallback?: (error: Error) => unknown): Unsubscribe;
-    function onChildRemoved(query: types.Query, callback: (snapshot: DataSnapshot) => unknown, options: ListenOptions): Unsubscribe;
-    function onChildRemoved(query: types.Query, callback: (snapshot: DataSnapshot) => unknown, cancelCallback: (error: Error) => unknown, options: ListenOptions): Unsubscribe;
-    function onDisconnect(ref: types.Reference): OnDisconnect;
-    function onValue(query: types.Query, callback: (snapshot: DataSnapshot) => unknown, cancelCallback?: (error: Error) => unknown): Unsubscribe;
-    function onValue(query: types.Query, callback: (snapshot: DataSnapshot) => unknown, options: ListenOptions): Unsubscribe;
-    function onValue(query: types.Query, callback: (snapshot: DataSnapshot) => unknown, cancelCallback: (error: Error) => unknown, options: ListenOptions): Unsubscribe;
-    function push(parent: types.Reference, value?: unknown): ThenableReference;
-    function query(query: types.Query, ...queryConstraints: QueryConstraint[]): Query;
-    function ref(db: types.FirebaseDatabase, path?: string): DatabaseReference;
-    function refFromURL(db: types.FirebaseDatabase, url: string): DatabaseReference;
-    function remove(ref: types.Reference): Promise<void>;
-    function runTransaction(ref: types.Reference, transactionUpdate: (currentData: any) => unknown, options?: TransactionOptions): Promise<TransactionResult>;
-    function set(ref: types.Reference, value: unknown): Promise<void>;
-    function setPriority(ref: types.Reference, priority: string | number | null): Promise<void>;
-    function setWithPriority(ref: types.Reference, value: unknown, priority: string | number | null): Promise<void>;
-    function update(ref: types.Reference, values: object): Promise<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: types.Query): Promise<DataSnapshot>;
+    /**
+     * 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?: FirebaseAppCompat, 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: types.FirebaseDatabase): 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: types.FirebaseDatabase): void;
+    /**
+     * 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: types.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: types.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: types.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: types.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: types.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: types.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: types.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: types.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: types.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: types.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: types.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: types.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: types.Query, callback: (snapshot: DataSnapshot) => unknown, cancelCallback: (error: Error) => unknown, options: ListenOptions): Unsubscribe;
+    /**
+     * 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: types.Reference): 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: types.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: types.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: types.Query, callback: (snapshot: DataSnapshot) => unknown, cancelCallback: (error: Error) => unknown, options: ListenOptions): Unsubscribe;
+    /**
+     * 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: types.Reference, value?: unknown): ThenableReference;
+    /**
+     * 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: types.Query, ...queryConstraints: QueryConstraint[]): Query;
+    /* 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: types.FirebaseDatabase, 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: types.FirebaseDatabase, 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: types.Reference): Promise<void>;
+    /* 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: types.Reference, transactionUpdate: (currentData: any) => unknown, options?: TransactionOptions): Promise<TransactionResult>;
+    /**
+     * 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: types.Reference, value: unknown): Promise<void>;
+    /**
+     * 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: types.Reference, priority: string | number | null): Promise<void>;
+    /* 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: types.Reference, value: unknown, priority: string | number | null): Promise<void>;
+    /**
+     * Writes multiple values to the Database at once.
+     *
+     * 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).
+     *
+     * 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.
+     *
+     * A single `update()` will generate a single "value" event at the location
+     * where the `update()` was performed, regardless of how many children were
+     * modified.
+     *
+     * Note that modifying data with `update()` will cancel any pending
+     * transactions at that location, so extreme care should be taken if mixing
+     * `update()` and `transaction()` to modify the same data.
+     *
+     * Passing `null` to `update()` will remove the data at this location.
+     *
+     * See
+     * {@link https://firebase.googleblog.com/2015/09/introducing-multi-location-updates-and_86.html | Introducing multi-location updates and more}.
+     *
+     * @param ref - The location to write to.
+     * @param values - Object containing multiple values.
+     * @returns Resolves when update on server is complete.
+     */
+    export declare function update(ref: types.Reference, values: object): Promise<void>;
 }