@depup/firebase__database 1.1.1-depup.0

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

@@ -0,0 +1,144 @@
+/**
+ * @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 { ValueEventRegistration } from '../api/Reference_impl';
+import { AppCheckTokenProvider } from './AppCheckTokenProvider';
+import { AuthTokenProvider } from './AuthTokenProvider';
+import { PersistentConnection } from './PersistentConnection';
+import { RepoInfo } from './RepoInfo';
+import { ServerActions } from './ServerActions';
+import { Node } from './snap/Node';
+import { SnapshotHolder } from './SnapshotHolder';
+import { SparseSnapshotTree } from './SparseSnapshotTree';
+import { StatsCollection } from './stats/StatsCollection';
+import { StatsListener } from './stats/StatsListener';
+import { StatsReporter } from './stats/StatsReporter';
+import { SyncTree } from './SyncTree';
+import { Indexable } from './util/misc';
+import { Path } from './util/Path';
+import { Tree } from './util/Tree';
+import { EventQueue } from './view/EventQueue';
+import { EventRegistration, QueryContext } from './view/EventRegistration';
+declare const enum TransactionStatus {
+    RUN = 0,
+    SENT = 1,
+    COMPLETED = 2,
+    SENT_NEEDS_ABORT = 3,
+    NEEDS_ABORT = 4
+}
+interface Transaction {
+    path: Path;
+    update: (a: unknown) => unknown;
+    onComplete: (error: Error | null, committed: boolean, node: Node | null) => void;
+    status: TransactionStatus;
+    order: number;
+    applyLocally: boolean;
+    retryCount: number;
+    unwatcher: () => void;
+    abortReason: string | null;
+    currentWriteId: number;
+    currentInputSnapshot: Node | null;
+    currentOutputSnapshotRaw: Node | null;
+    currentOutputSnapshotResolved: Node | null;
+}
+/**
+ * A connection to a single data repository.
+ */
+export 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<Transaction[]>;
+    persistentConnection_: PersistentConnection | null;
+    constructor(repoInfo_: RepoInfo, forceRestClient_: boolean, authTokenProvider_: AuthTokenProvider, appCheckProvider_: AppCheckTokenProvider);
+    /**
+     * @returns The URL corresponding to the root of this Firebase.
+     */
+    toString(): string;
+}
+export declare function repoStart(repo: Repo, appId: string, authOverride?: object): void;
+/**
+ * @returns The time in milliseconds, taking the server offset into account if we have one.
+ */
+export declare function repoServerTime(repo: Repo): number;
+/**
+ * Generate ServerValues using some variables from the repo object.
+ */
+export declare function repoGenerateServerValues(repo: Repo): Indexable;
+export declare function repoInterceptServerData(repo: Repo, callback: ((a: string, b: unknown) => unknown) | null): void;
+/**
+ * The purpose of `getValue` is to return the latest known value
+ * satisfying `query`.
+ *
+ * This method will first check for in-memory cached values
+ * belonging to active listeners. If they are found, such values
+ * are considered to be the most up-to-date.
+ *
+ * If the client is not connected, this method will wait until the
+ *  repo has established a connection and then request the value for `query`.
+ * If the client is not able to retrieve the query result for another reason,
+ * it reports an error.
+ *
+ * @param query - The query to surface a value for.
+ */
+export declare function repoGetValue(repo: Repo, query: QueryContext, eventRegistration: ValueEventRegistration): Promise<Node>;
+export declare function repoSetWithPriority(repo: Repo, path: Path, newVal: unknown, newPriority: number | string | null, onComplete: ((status: Error | null, errorReason?: string) => void) | null): void;
+export declare function repoUpdate(repo: Repo, path: Path, childrenToMerge: {
+    [k: string]: unknown;
+}, onComplete: ((status: Error | null, errorReason?: string) => void) | null): void;
+export declare function repoOnDisconnectCancel(repo: Repo, path: Path, onComplete: ((status: Error | null, errorReason?: string) => void) | null): void;
+export declare function repoOnDisconnectSet(repo: Repo, path: Path, value: unknown, onComplete: ((status: Error | null, errorReason?: string) => void) | null): void;
+export declare function repoOnDisconnectSetWithPriority(repo: Repo, path: Path, value: unknown, priority: unknown, onComplete: ((status: Error | null, errorReason?: string) => void) | null): void;
+export declare function repoOnDisconnectUpdate(repo: Repo, path: Path, childrenToMerge: {
+    [k: string]: unknown;
+}, onComplete: ((status: Error | null, errorReason?: string) => void) | null): void;
+export declare function repoAddEventCallbackForQuery(repo: Repo, query: QueryContext, eventRegistration: EventRegistration): void;
+export declare function repoRemoveEventCallbackForQuery(repo: Repo, query: QueryContext, eventRegistration: EventRegistration): void;
+export declare function repoInterrupt(repo: Repo): void;
+export declare function repoResume(repo: Repo): void;
+export declare function repoStats(repo: Repo, showDelta?: boolean): void;
+export declare function repoStatsIncrementCounter(repo: Repo, metric: string): void;
+export declare function repoCallOnCompleteCallback(repo: Repo, callback: ((status: Error | null, errorReason?: string) => void) | null, status: string, errorReason?: string | null): void;
+/**
+ * Creates a new transaction, adds it to the transactions we're tracking, and
+ * sends it to the server if possible.
+ *
+ * @param path - Path at which to do transaction.
+ * @param transactionUpdate - Update callback.
+ * @param onComplete - Completion callback.
+ * @param unwatcher - Function that will be called when the transaction no longer
+ * need data updates for `path`.
+ * @param applyLocally - Whether or not to make intermediate results visible
+ */
+export declare function repoStartTransaction(repo: Repo, path: Path, transactionUpdate: (a: unknown) => unknown, onComplete: ((error: Error, committed: boolean, node: Node) => void) | null, unwatcher: () => void, applyLocally: boolean): void;
+export {};

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

@@ -0,0 +1,61 @@
+/**
+ * @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 { EmulatorMockTokenOptions } from '@firebase/util';
+export interface RepoInfoEmulatorOptions {
+    mockUserToken?: string | EmulatorMockTokenOptions;
+}
+/**
+ * A class that holds metadata about a Repo object
+ */
+export declare class RepoInfo {
+    readonly secure: boolean;
+    readonly namespace: string;
+    readonly webSocketOnly: boolean;
+    readonly nodeAdmin: boolean;
+    readonly persistenceKey: string;
+    readonly includeNamespaceInQueryParams: boolean;
+    readonly isUsingEmulator: boolean;
+    readonly emulatorOptions: RepoInfoEmulatorOptions | null;
+    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, emulatorOptions?: RepoInfoEmulatorOptions | null);
+    isCacheableHost(): boolean;
+    isCustomHost(): boolean;
+    get host(): string;
+    set host(newHost: string);
+    toString(): string;
+    toURLString(): string;
+}
+/**
+ * Returns the websocket URL for this repo
+ * @param repoInfo - RepoInfo object
+ * @param type - of connection
+ * @param params - list
+ * @returns The URL for this repo
+ */
+export declare function repoInfoConnectionURL(repoInfo: RepoInfo, type: string, params: {
+    [k: string]: string;
+}): string;

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

@@ -0,0 +1,52 @@
+/**
+ * @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 { QueryContext } from './view/EventRegistration';
+/**
+ * Interface defining the set of actions that can be performed against the Firebase server
+ * (basically corresponds to our wire protocol).
+ *
+ * @interface
+ */
+export 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<string>;
+    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;
+}

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

@@ -0,0 +1,26 @@
+/**
+ * @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';
+/**
+ * Mutable object which basically just stores a reference to the "latest" immutable snapshot.
+ */
+export declare class SnapshotHolder {
+    private rootNode_;
+    getNode(path: Path): Node;
+    updateSnapshot(path: Path, newSnapshotNode: Node): void;
+}

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

@@ -0,0 +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;

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

@@ -0,0 +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;

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

@@ -0,0 +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;