@firebase/database 1.0.9 → 1.0.10

package/dist/node-esm/src/core/SparseSnapshotTree.d.ts

@@ -1,64 +1,64 @@
-/**
- * @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.
- */
-import { Node } from './snap/Node';
-import { Path } from './util/Path';
-/**
- * Helper class to store a sparse set of snapshots.
- */
-export interface SparseSnapshotTree {
-    value: Node | null;
-    readonly children: Map<string, SparseSnapshotTree>;
-}
-export declare function newSparseSnapshotTree(): SparseSnapshotTree;
-/**
- * Gets the node stored at the given path if one exists.
- * Only seems to be used in tests.
- *
- * @param path - Path to look up snapshot for.
- * @returns The retrieved node, or null.
- */
-export declare function sparseSnapshotTreeFind(sparseSnapshotTree: SparseSnapshotTree, path: Path): Node | null;
-/**
- * Stores the given node at the specified path. If there is already a node
- * at a shallower path, it merges the new data into that snapshot node.
- *
- * @param path - Path to look up snapshot for.
- * @param data - The new data, or null.
- */
-export declare function sparseSnapshotTreeRemember(sparseSnapshotTree: SparseSnapshotTree, path: Path, data: Node): void;
-/**
- * Purge the data at path from the cache.
- *
- * @param path - Path to look up snapshot for.
- * @returns True if this node should now be removed.
- */
-export declare function sparseSnapshotTreeForget(sparseSnapshotTree: SparseSnapshotTree, path: Path): boolean;
-/**
- * Recursively iterates through all of the stored tree and calls the
- * callback on each one.
- *
- * @param prefixPath - Path to look up node for.
- * @param func - The function to invoke for each tree.
- */
-export declare function sparseSnapshotTreeForEachTree(sparseSnapshotTree: SparseSnapshotTree, prefixPath: Path, func: (a: Path, b: Node) => unknown): void;
-/**
- * Iterates through each immediate child and triggers the callback.
- * Only seems to be used in tests.
- *
- * @param func - The function to invoke for each child.
- */
-export declare function sparseSnapshotTreeForEachChild(sparseSnapshotTree: SparseSnapshotTree, func: (a: string, b: SparseSnapshotTree) => void): void;
+/**
+ * @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.
+ */
+import { Node } from './snap/Node';
+import { Path } from './util/Path';
+/**
+ * Helper class to store a sparse set of snapshots.
+ */
+export interface SparseSnapshotTree {
+    value: Node | null;
+    readonly children: Map<string, SparseSnapshotTree>;
+}
+export declare function newSparseSnapshotTree(): SparseSnapshotTree;
+/**
+ * Gets the node stored at the given path if one exists.
+ * Only seems to be used in tests.
+ *
+ * @param path - Path to look up snapshot for.
+ * @returns The retrieved node, or null.
+ */
+export declare function sparseSnapshotTreeFind(sparseSnapshotTree: SparseSnapshotTree, path: Path): Node | null;
+/**
+ * Stores the given node at the specified path. If there is already a node
+ * at a shallower path, it merges the new data into that snapshot node.
+ *
+ * @param path - Path to look up snapshot for.
+ * @param data - The new data, or null.
+ */
+export declare function sparseSnapshotTreeRemember(sparseSnapshotTree: SparseSnapshotTree, path: Path, data: Node): void;
+/**
+ * Purge the data at path from the cache.
+ *
+ * @param path - Path to look up snapshot for.
+ * @returns True if this node should now be removed.
+ */
+export declare function sparseSnapshotTreeForget(sparseSnapshotTree: SparseSnapshotTree, path: Path): boolean;
+/**
+ * Recursively iterates through all of the stored tree and calls the
+ * callback on each one.
+ *
+ * @param prefixPath - Path to look up node for.
+ * @param func - The function to invoke for each tree.
+ */
+export declare function sparseSnapshotTreeForEachTree(sparseSnapshotTree: SparseSnapshotTree, prefixPath: Path, func: (a: Path, b: Node) => unknown): void;
+/**
+ * Iterates through each immediate child and triggers the callback.
+ * Only seems to be used in tests.
+ *
+ * @param func - The function to invoke for each child.
+ */
+export declare function sparseSnapshotTreeForEachChild(sparseSnapshotTree: SparseSnapshotTree, func: (a: string, b: SparseSnapshotTree) => void): void;

package/dist/node-esm/src/core/SyncPoint.d.ts

@@ -1,91 +1,91 @@
-/**
- * @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.
- */
-import { ReferenceConstructor } from '../api/Reference';
-import { Operation } from './operation/Operation';
-import { Node } from './snap/Node';
-import { Path } from './util/Path';
-import { Event } from './view/Event';
-import { EventRegistration, QueryContext } from './view/EventRegistration';
-import { View } from './view/View';
-import { WriteTreeRef } from './WriteTree';
-/**
- * SyncPoint represents a single location in a SyncTree with 1 or more event registrations, meaning we need to
- * maintain 1 or more Views at this location to cache server data and raise appropriate events for server changes
- * and user writes (set, transaction, update).
- *
- * It's responsible for:
- *  - Maintaining the set of 1 or more views necessary at this location (a SyncPoint with 0 views should be removed).
- *  - Proxying user / server operations to the views as appropriate (i.e. applyServerOverwrite,
- *    applyUserOverwrite, etc.)
- */
-export declare class SyncPoint {
-    /**
-     * The Views being tracked at this location in the tree, stored as a map where the key is a
-     * queryId and the value is the View for that query.
-     *
-     * NOTE: This list will be quite small (usually 1, but perhaps 2 or 3; any more is an odd use case).
-     */
-    readonly views: Map<string, View>;
-}
-export declare function syncPointSetReferenceConstructor(val: ReferenceConstructor): void;
-export declare function syncPointIsEmpty(syncPoint: SyncPoint): boolean;
-export declare function syncPointApplyOperation(syncPoint: SyncPoint, operation: Operation, writesCache: WriteTreeRef, optCompleteServerCache: Node | null): Event[];
-/**
- * Get a view for the specified query.
- *
- * @param query - The query to return a view for
- * @param writesCache
- * @param serverCache
- * @param serverCacheComplete
- * @returns Events to raise.
- */
-export declare function syncPointGetView(syncPoint: SyncPoint, query: QueryContext, writesCache: WriteTreeRef, serverCache: Node | null, serverCacheComplete: boolean): View;
-/**
- * Add an event callback for the specified query.
- *
- * @param query
- * @param eventRegistration
- * @param writesCache
- * @param serverCache - Complete server cache, if we have it.
- * @param serverCacheComplete
- * @returns Events to raise.
- */
-export declare function syncPointAddEventRegistration(syncPoint: SyncPoint, query: QueryContext, eventRegistration: EventRegistration, writesCache: WriteTreeRef, serverCache: Node | null, serverCacheComplete: boolean): Event[];
-/**
- * Remove event callback(s).  Return cancelEvents if a cancelError is specified.
- *
- * If query is the default query, we'll check all views for the specified eventRegistration.
- * If eventRegistration is null, we'll remove all callbacks for the specified view(s).
- *
- * @param eventRegistration - If null, remove all callbacks.
- * @param cancelError - If a cancelError is provided, appropriate cancel events will be returned.
- * @returns removed queries and any cancel events
- */
-export declare function syncPointRemoveEventRegistration(syncPoint: SyncPoint, query: QueryContext, eventRegistration: EventRegistration | null, cancelError?: Error): {
-    removed: QueryContext[];
-    events: Event[];
-};
-export declare function syncPointGetQueryViews(syncPoint: SyncPoint): View[];
-/**
- * @param path - The path to the desired complete snapshot
- * @returns A complete cache, if it exists
- */
-export declare function syncPointGetCompleteServerCache(syncPoint: SyncPoint, path: Path): Node | null;
-export declare function syncPointViewForQuery(syncPoint: SyncPoint, query: QueryContext): View | null;
-export declare function syncPointViewExistsForQuery(syncPoint: SyncPoint, query: QueryContext): boolean;
-export declare function syncPointHasCompleteView(syncPoint: SyncPoint): boolean;
-export declare function syncPointGetCompleteView(syncPoint: SyncPoint): View | null;
+/**
+ * @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.
+ */
+import { ReferenceConstructor } from '../api/Reference';
+import { Operation } from './operation/Operation';
+import { Node } from './snap/Node';
+import { Path } from './util/Path';
+import { Event } from './view/Event';
+import { EventRegistration, QueryContext } from './view/EventRegistration';
+import { View } from './view/View';
+import { WriteTreeRef } from './WriteTree';
+/**
+ * SyncPoint represents a single location in a SyncTree with 1 or more event registrations, meaning we need to
+ * maintain 1 or more Views at this location to cache server data and raise appropriate events for server changes
+ * and user writes (set, transaction, update).
+ *
+ * It's responsible for:
+ *  - Maintaining the set of 1 or more views necessary at this location (a SyncPoint with 0 views should be removed).
+ *  - Proxying user / server operations to the views as appropriate (i.e. applyServerOverwrite,
+ *    applyUserOverwrite, etc.)
+ */
+export declare class SyncPoint {
+    /**
+     * The Views being tracked at this location in the tree, stored as a map where the key is a
+     * queryId and the value is the View for that query.
+     *
+     * NOTE: This list will be quite small (usually 1, but perhaps 2 or 3; any more is an odd use case).
+     */
+    readonly views: Map<string, View>;
+}
+export declare function syncPointSetReferenceConstructor(val: ReferenceConstructor): void;
+export declare function syncPointIsEmpty(syncPoint: SyncPoint): boolean;
+export declare function syncPointApplyOperation(syncPoint: SyncPoint, operation: Operation, writesCache: WriteTreeRef, optCompleteServerCache: Node | null): Event[];
+/**
+ * Get a view for the specified query.
+ *
+ * @param query - The query to return a view for
+ * @param writesCache
+ * @param serverCache
+ * @param serverCacheComplete
+ * @returns Events to raise.
+ */
+export declare function syncPointGetView(syncPoint: SyncPoint, query: QueryContext, writesCache: WriteTreeRef, serverCache: Node | null, serverCacheComplete: boolean): View;
+/**
+ * Add an event callback for the specified query.
+ *
+ * @param query
+ * @param eventRegistration
+ * @param writesCache
+ * @param serverCache - Complete server cache, if we have it.
+ * @param serverCacheComplete
+ * @returns Events to raise.
+ */
+export declare function syncPointAddEventRegistration(syncPoint: SyncPoint, query: QueryContext, eventRegistration: EventRegistration, writesCache: WriteTreeRef, serverCache: Node | null, serverCacheComplete: boolean): Event[];
+/**
+ * Remove event callback(s).  Return cancelEvents if a cancelError is specified.
+ *
+ * If query is the default query, we'll check all views for the specified eventRegistration.
+ * If eventRegistration is null, we'll remove all callbacks for the specified view(s).
+ *
+ * @param eventRegistration - If null, remove all callbacks.
+ * @param cancelError - If a cancelError is provided, appropriate cancel events will be returned.
+ * @returns removed queries and any cancel events
+ */
+export declare function syncPointRemoveEventRegistration(syncPoint: SyncPoint, query: QueryContext, eventRegistration: EventRegistration | null, cancelError?: Error): {
+    removed: QueryContext[];
+    events: Event[];
+};
+export declare function syncPointGetQueryViews(syncPoint: SyncPoint): View[];
+/**
+ * @param path - The path to the desired complete snapshot
+ * @returns A complete cache, if it exists
+ */
+export declare function syncPointGetCompleteServerCache(syncPoint: SyncPoint, path: Path): Node | null;
+export declare function syncPointViewForQuery(syncPoint: SyncPoint, query: QueryContext): View | null;
+export declare function syncPointViewExistsForQuery(syncPoint: SyncPoint, query: QueryContext): boolean;
+export declare function syncPointHasCompleteView(syncPoint: SyncPoint): boolean;
+export declare function syncPointGetCompleteView(syncPoint: SyncPoint): View | null;

package/dist/node-esm/src/core/SyncTree.d.ts

@@ -1,166 +1,166 @@
-/**
- * @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.
- */
-import { ReferenceConstructor } from '../api/Reference';
-import { Node } from './snap/Node';
-import { SyncPoint } from './SyncPoint';
-import { ImmutableTree } from './util/ImmutableTree';
-import { Path } from './util/Path';
-import { Event } from './view/Event';
-import { EventRegistration, QueryContext } from './view/EventRegistration';
-import { WriteTree } from './WriteTree';
-export declare function syncTreeSetReferenceConstructor(val: ReferenceConstructor): void;
-export interface ListenProvider {
-    startListening(query: QueryContext, tag: number | null, hashFn: () => string, onComplete: (a: string, b?: unknown) => Event[]): Event[];
-    stopListening(a: QueryContext, b: number | null): void;
-}
-export declare function resetSyncTreeTag(): void;
-/**
- * SyncTree is the central class for managing event callback registration, data caching, views
- * (query processing), and event generation.  There are typically two SyncTree instances for
- * each Repo, one for the normal Firebase data, and one for the .info data.
- *
- * It has a number of responsibilities, including:
- *  - Tracking all user event callbacks (registered via addEventRegistration() and removeEventRegistration()).
- *  - Applying and caching data changes for user set(), transaction(), and update() calls
- *    (applyUserOverwrite(), applyUserMerge()).
- *  - Applying and caching data changes for server data changes (applyServerOverwrite(),
- *    applyServerMerge()).
- *  - Generating user-facing events for server and user changes (all of the apply* methods
- *    return the set of events that need to be raised as a result).
- *  - Maintaining the appropriate set of server listens to ensure we are always subscribed
- *    to the correct set of paths and queries to satisfy the current set of user event
- *    callbacks (listens are started/stopped using the provided listenProvider).
- *
- * NOTE: Although SyncTree tracks event callbacks and calculates events to raise, the actual
- * events are returned to the caller rather than raised synchronously.
- *
- */
-export declare class SyncTree {
-    listenProvider_: ListenProvider;
-    /**
-     * Tree of SyncPoints.  There's a SyncPoint at any location that has 1 or more views.
-     */
-    syncPointTree_: ImmutableTree<SyncPoint>;
-    /**
-     * A tree of all pending user writes (user-initiated set()'s, transaction()'s, update()'s, etc.).
-     */
-    pendingWriteTree_: WriteTree;
-    readonly tagToQueryMap: Map<number, string>;
-    readonly queryToTagMap: Map<string, number>;
-    /**
-     * @param listenProvider_ - Used by SyncTree to start / stop listening
-     *   to server data.
-     */
-    constructor(listenProvider_: ListenProvider);
-}
-/**
- * Apply the data changes for a user-generated set() or transaction() call.
- *
- * @returns Events to raise.
- */
-export declare function syncTreeApplyUserOverwrite(syncTree: SyncTree, path: Path, newData: Node, writeId: number, visible?: boolean): Event[];
-/**
- * Apply the data from a user-generated update() call
- *
- * @returns Events to raise.
- */
-export declare function syncTreeApplyUserMerge(syncTree: SyncTree, path: Path, changedChildren: {
-    [k: string]: Node;
-}, writeId: number): Event[];
-/**
- * Acknowledge a pending user write that was previously registered with applyUserOverwrite() or applyUserMerge().
- *
- * @param revert - True if the given write failed and needs to be reverted
- * @returns Events to raise.
- */
-export declare function syncTreeAckUserWrite(syncTree: SyncTree, writeId: number, revert?: boolean): Event[];
-/**
- * Apply new server data for the specified path..
- *
- * @returns Events to raise.
- */
-export declare function syncTreeApplyServerOverwrite(syncTree: SyncTree, path: Path, newData: Node): Event[];
-/**
- * Apply new server data to be merged in at the specified path.
- *
- * @returns Events to raise.
- */
-export declare function syncTreeApplyServerMerge(syncTree: SyncTree, path: Path, changedChildren: {
-    [k: string]: Node;
-}): Event[];
-/**
- * Apply a listen complete for a query
- *
- * @returns Events to raise.
- */
-export declare function syncTreeApplyListenComplete(syncTree: SyncTree, path: Path): Event[];
-/**
- * Apply a listen complete for a tagged query
- *
- * @returns Events to raise.
- */
-export declare function syncTreeApplyTaggedListenComplete(syncTree: SyncTree, path: Path, tag: number): Event[];
-/**
- * Remove event callback(s).
- *
- * If query is the default query, we'll check all queries for the specified eventRegistration.
- * If eventRegistration is null, we'll remove all callbacks for the specified query/queries.
- *
- * @param eventRegistration - If null, all callbacks are removed.
- * @param cancelError - If a cancelError is provided, appropriate cancel events will be returned.
- * @param skipListenerDedup - When performing a `get()`, we don't add any new listeners, so no
- *  deduping needs to take place. This flag allows toggling of that behavior
- * @returns Cancel events, if cancelError was provided.
- */
-export declare function syncTreeRemoveEventRegistration(syncTree: SyncTree, query: QueryContext, eventRegistration: EventRegistration | null, cancelError?: Error, skipListenerDedup?: boolean): Event[];
-/**
- * Apply new server data for the specified tagged query.
- *
- * @returns Events to raise.
- */
-export declare function syncTreeApplyTaggedQueryOverwrite(syncTree: SyncTree, path: Path, snap: Node, tag: number): Event[];
-/**
- * Apply server data to be merged in for the specified tagged query.
- *
- * @returns Events to raise.
- */
-export declare function syncTreeApplyTaggedQueryMerge(syncTree: SyncTree, path: Path, changedChildren: {
-    [k: string]: Node;
-}, tag: number): Event[];
-/**
- * Add an event callback for the specified query.
- *
- * @returns Events to raise.
- */
-export declare function syncTreeAddEventRegistration(syncTree: SyncTree, query: QueryContext, eventRegistration: EventRegistration, skipSetupListener?: boolean): Event[];
-/**
- * Returns a complete cache, if we have one, of the data at a particular path. If the location does not have a
- * listener above it, we will get a false "null". This shouldn't be a problem because transactions will always
- * have a listener above, and atomic operations would correctly show a jitter of <increment value> ->
- *     <incremented total> as the write is applied locally and then acknowledged at the server.
- *
- * Note: this method will *include* hidden writes from transaction with applyLocally set to false.
- *
- * @param path - The path to the data we want
- * @param writeIdsToExclude - A specific set to be excluded
- */
-export declare function syncTreeCalcCompleteEventCache(syncTree: SyncTree, path: Path, writeIdsToExclude?: number[]): Node;
-export declare function syncTreeGetServerValue(syncTree: SyncTree, query: QueryContext): Node | null;
-/**
- * Return the tag associated with the given query.
- */
-export declare function syncTreeTagForQuery(syncTree: SyncTree, query: QueryContext): number | null;
+/**
+ * @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.
+ */
+import { ReferenceConstructor } from '../api/Reference';
+import { Node } from './snap/Node';
+import { SyncPoint } from './SyncPoint';
+import { ImmutableTree } from './util/ImmutableTree';
+import { Path } from './util/Path';
+import { Event } from './view/Event';
+import { EventRegistration, QueryContext } from './view/EventRegistration';
+import { WriteTree } from './WriteTree';
+export declare function syncTreeSetReferenceConstructor(val: ReferenceConstructor): void;
+export interface ListenProvider {
+    startListening(query: QueryContext, tag: number | null, hashFn: () => string, onComplete: (a: string, b?: unknown) => Event[]): Event[];
+    stopListening(a: QueryContext, b: number | null): void;
+}
+export declare function resetSyncTreeTag(): void;
+/**
+ * SyncTree is the central class for managing event callback registration, data caching, views
+ * (query processing), and event generation.  There are typically two SyncTree instances for
+ * each Repo, one for the normal Firebase data, and one for the .info data.
+ *
+ * It has a number of responsibilities, including:
+ *  - Tracking all user event callbacks (registered via addEventRegistration() and removeEventRegistration()).
+ *  - Applying and caching data changes for user set(), transaction(), and update() calls
+ *    (applyUserOverwrite(), applyUserMerge()).
+ *  - Applying and caching data changes for server data changes (applyServerOverwrite(),
+ *    applyServerMerge()).
+ *  - Generating user-facing events for server and user changes (all of the apply* methods
+ *    return the set of events that need to be raised as a result).
+ *  - Maintaining the appropriate set of server listens to ensure we are always subscribed
+ *    to the correct set of paths and queries to satisfy the current set of user event
+ *    callbacks (listens are started/stopped using the provided listenProvider).
+ *
+ * NOTE: Although SyncTree tracks event callbacks and calculates events to raise, the actual
+ * events are returned to the caller rather than raised synchronously.
+ *
+ */
+export declare class SyncTree {
+    listenProvider_: ListenProvider;
+    /**
+     * Tree of SyncPoints.  There's a SyncPoint at any location that has 1 or more views.
+     */
+    syncPointTree_: ImmutableTree<SyncPoint>;
+    /**
+     * A tree of all pending user writes (user-initiated set()'s, transaction()'s, update()'s, etc.).
+     */
+    pendingWriteTree_: WriteTree;
+    readonly tagToQueryMap: Map<number, string>;
+    readonly queryToTagMap: Map<string, number>;
+    /**
+     * @param listenProvider_ - Used by SyncTree to start / stop listening
+     *   to server data.
+     */
+    constructor(listenProvider_: ListenProvider);
+}
+/**
+ * Apply the data changes for a user-generated set() or transaction() call.
+ *
+ * @returns Events to raise.
+ */
+export declare function syncTreeApplyUserOverwrite(syncTree: SyncTree, path: Path, newData: Node, writeId: number, visible?: boolean): Event[];
+/**
+ * Apply the data from a user-generated update() call
+ *
+ * @returns Events to raise.
+ */
+export declare function syncTreeApplyUserMerge(syncTree: SyncTree, path: Path, changedChildren: {
+    [k: string]: Node;
+}, writeId: number): Event[];
+/**
+ * Acknowledge a pending user write that was previously registered with applyUserOverwrite() or applyUserMerge().
+ *
+ * @param revert - True if the given write failed and needs to be reverted
+ * @returns Events to raise.
+ */
+export declare function syncTreeAckUserWrite(syncTree: SyncTree, writeId: number, revert?: boolean): Event[];
+/**
+ * Apply new server data for the specified path..
+ *
+ * @returns Events to raise.
+ */
+export declare function syncTreeApplyServerOverwrite(syncTree: SyncTree, path: Path, newData: Node): Event[];
+/**
+ * Apply new server data to be merged in at the specified path.
+ *
+ * @returns Events to raise.
+ */
+export declare function syncTreeApplyServerMerge(syncTree: SyncTree, path: Path, changedChildren: {
+    [k: string]: Node;
+}): Event[];
+/**
+ * Apply a listen complete for a query
+ *
+ * @returns Events to raise.
+ */
+export declare function syncTreeApplyListenComplete(syncTree: SyncTree, path: Path): Event[];
+/**
+ * Apply a listen complete for a tagged query
+ *
+ * @returns Events to raise.
+ */
+export declare function syncTreeApplyTaggedListenComplete(syncTree: SyncTree, path: Path, tag: number): Event[];
+/**
+ * Remove event callback(s).
+ *
+ * If query is the default query, we'll check all queries for the specified eventRegistration.
+ * If eventRegistration is null, we'll remove all callbacks for the specified query/queries.
+ *
+ * @param eventRegistration - If null, all callbacks are removed.
+ * @param cancelError - If a cancelError is provided, appropriate cancel events will be returned.
+ * @param skipListenerDedup - When performing a `get()`, we don't add any new listeners, so no
+ *  deduping needs to take place. This flag allows toggling of that behavior
+ * @returns Cancel events, if cancelError was provided.
+ */
+export declare function syncTreeRemoveEventRegistration(syncTree: SyncTree, query: QueryContext, eventRegistration: EventRegistration | null, cancelError?: Error, skipListenerDedup?: boolean): Event[];
+/**
+ * Apply new server data for the specified tagged query.
+ *
+ * @returns Events to raise.
+ */
+export declare function syncTreeApplyTaggedQueryOverwrite(syncTree: SyncTree, path: Path, snap: Node, tag: number): Event[];
+/**
+ * Apply server data to be merged in for the specified tagged query.
+ *
+ * @returns Events to raise.
+ */
+export declare function syncTreeApplyTaggedQueryMerge(syncTree: SyncTree, path: Path, changedChildren: {
+    [k: string]: Node;
+}, tag: number): Event[];
+/**
+ * Add an event callback for the specified query.
+ *
+ * @returns Events to raise.
+ */
+export declare function syncTreeAddEventRegistration(syncTree: SyncTree, query: QueryContext, eventRegistration: EventRegistration, skipSetupListener?: boolean): Event[];
+/**
+ * Returns a complete cache, if we have one, of the data at a particular path. If the location does not have a
+ * listener above it, we will get a false "null". This shouldn't be a problem because transactions will always
+ * have a listener above, and atomic operations would correctly show a jitter of <increment value> ->
+ *     <incremented total> as the write is applied locally and then acknowledged at the server.
+ *
+ * Note: this method will *include* hidden writes from transaction with applyLocally set to false.
+ *
+ * @param path - The path to the data we want
+ * @param writeIdsToExclude - A specific set to be excluded
+ */
+export declare function syncTreeCalcCompleteEventCache(syncTree: SyncTree, path: Path, writeIdsToExclude?: number[]): Node;
+export declare function syncTreeGetServerValue(syncTree: SyncTree, query: QueryContext): Node | null;
+/**
+ * Return the tag associated with the given query.
+ */
+export declare function syncTreeTagForQuery(syncTree: SyncTree, query: QueryContext): number | null;