@depup/firebase__database 1.1.1-depup.0

package/dist/src/api/ServerValue.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Returns a placeholder value for auto-populating the current timestamp (time
+ * since the Unix epoch, in milliseconds) as determined by the Firebase
+ * servers.
+ */
+export declare function serverTimestamp(): object;
+/**
+ * Returns a placeholder value that can be used to atomically increment the
+ * current database value by the provided delta.
+ *
+ * @param delta - the amount to modify the current value atomically.
+ * @returns A placeholder value for modifying data atomically server-side.
+ */
+export declare function increment(delta: number): object;

package/dist/src/api/Transaction.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { DatabaseReference } from './Reference';
+import { DataSnapshot } from './Reference_impl';
+/** An options object to configure transactions. */
+export interface TransactionOptions {
+    /**
+     * By default, events are raised each time the transaction update function
+     * runs. So if it is run multiple times, you may see intermediate states. You
+     * can set this to false to suppress these intermediate states and instead
+     * wait until the transaction has completed before events are raised.
+     */
+    readonly applyLocally?: boolean;
+}
+/**
+ * A type for the resolve value of {@link runTransaction}.
+ */
+export declare class TransactionResult {
+    /** Whether the transaction was successfully committed. */
+    readonly committed: boolean;
+    /** The resulting data snapshot. */
+    readonly snapshot: DataSnapshot;
+    /** @hideconstructor */
+    constructor(
+    /** Whether the transaction was successfully committed. */
+    committed: boolean, 
+    /** The resulting data snapshot. */
+    snapshot: DataSnapshot);
+    /** Returns a JSON-serializable representation of this object. */
+    toJSON(): object;
+}
+/**
+ * Atomically modifies the data at this location.
+ *
+ * Atomically modify the data at this location. Unlike a normal `set()`, which
+ * just overwrites the data regardless of its previous value, `runTransaction()` is
+ * used to modify the existing value to a new value, ensuring there are no
+ * conflicts with other clients writing to the same location at the same time.
+ *
+ * To accomplish this, you pass `runTransaction()` an update function which is
+ * used to transform the current value into a new value. If another client
+ * writes to the location before your new value is successfully written, your
+ * update function will be called again with the new current value, and the
+ * write will be retried. This will happen repeatedly until your write succeeds
+ * without conflict or you abort the transaction by not returning a value from
+ * your update function.
+ *
+ * Note: Modifying data with `set()` will cancel any pending transactions at
+ * that location, so extreme care should be taken if mixing `set()` and
+ * `runTransaction()` to update the same data.
+ *
+ * Note: When using transactions with Security and Firebase Rules in place, be
+ * aware that a client needs `.read` access in addition to `.write` access in
+ * order to perform a transaction. This is because the client-side nature of
+ * transactions requires the client to read the data in order to transactionally
+ * update it.
+ *
+ * @param ref - The location to atomically modify.
+ * @param transactionUpdate - A developer-supplied function which will be passed
+ * the current data stored at this location (as a JavaScript object). The
+ * function should return the new value it would like written (as a JavaScript
+ * object). If `undefined` is returned (i.e. you return with no arguments) the
+ * transaction will be aborted and the data at this location will not be
+ * modified.
+ * @param options - An options object to configure transactions.
+ * @returns A `Promise` that can optionally be used instead of the `onComplete`
+ * callback to handle success and failure.
+ */
+export declare function runTransaction(ref: DatabaseReference, transactionUpdate: (currentData: any) => unknown, options?: TransactionOptions): Promise<TransactionResult>;

package/dist/src/api/test_access.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @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 { PersistentConnection } from '../core/PersistentConnection';
+import { RepoInfo } from '../core/RepoInfo';
+import { Connection } from '../realtime/Connection';
+export declare const DataConnection: typeof PersistentConnection;
+export declare const RealTimeConnection: typeof Connection;
+/**
+ * @internal
+ */
+export declare const hijackHash: (newHash: () => string) => () => void;
+export declare const ConnectionTarget: typeof RepoInfo;
+/**
+ * Forces the RepoManager to create Repos that use ReadonlyRestClient instead of PersistentConnection.
+ * @internal
+ */
+export declare const forceRestClient: (forceRestClient: boolean) => void;

package/dist/src/api.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @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.
+ */
+export * from './api.standalone';
+export { getDatabase } from './api/Database';

package/dist/src/api.standalone.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @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.
+ */
+export { Database, EmulatorMockTokenOptions, enableLogging, goOffline, goOnline, forceWebSockets, forceLongPolling, connectDatabaseEmulator } from './api/Database';
+export { Query, DatabaseReference, ListenOptions, Unsubscribe, ThenableReference } from './api/Reference';
+export { OnDisconnect } from './api/OnDisconnect';
+export { DataSnapshot, EventType, IteratedDataSnapshot, QueryConstraint, QueryConstraintType, endAt, endBefore, equalTo, get, limitToFirst, limitToLast, off, onChildAdded, onChildChanged, onChildMoved, onChildRemoved, onDisconnect, onValue, orderByChild, orderByKey, orderByPriority, orderByValue, push, query, ref, refFromURL, remove, set, setPriority, setWithPriority, startAfter, startAt, update, child } from './api/Reference_impl';
+export { increment, serverTimestamp } from './api/ServerValue';
+export { runTransaction, TransactionOptions, TransactionResult } from './api/Transaction';
+export { setSDKVersion as _setSDKVersion } from './core/version';
+export { ReferenceImpl as _ReferenceImpl, QueryImpl as _QueryImpl } from './api/Reference_impl';
+export { repoManagerDatabaseFromApp as _repoManagerDatabaseFromApp } from './api/Database';
+export { validatePathString as _validatePathString, validateWritablePath as _validateWritablePath } from './core/util/validation';
+export { UserCallback as _UserCallback } from './core/view/EventRegistration';
+export { QueryParams as _QueryParams } from './core/view/QueryParams';
+export { hijackHash as _TEST_ACCESS_hijackHash, forceRestClient as _TEST_ACCESS_forceRestClient } from './api/test_access';
+export * from './internal/index';

package/dist/src/core/AppCheckTokenProvider.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @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 { FirebaseApp } from '@firebase/app';
+import { AppCheckInternalComponentName, AppCheckTokenListener, AppCheckTokenResult } from '@firebase/app-check-interop-types';
+import { Provider } from '@firebase/component';
+/**
+ * Abstraction around AppCheck's token fetching capabilities.
+ */
+export declare class AppCheckTokenProvider {
+    private appCheckProvider?;
+    private appCheck?;
+    private serverAppAppCheckToken?;
+    private appName;
+    constructor(app: FirebaseApp, appCheckProvider?: Provider<AppCheckInternalComponentName>);
+    getToken(forceRefresh?: boolean): Promise<AppCheckTokenResult>;
+    addTokenChangeListener(listener: AppCheckTokenListener): void;
+    notifyForInvalidToken(): void;
+}

package/dist/src/core/AuthTokenProvider.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @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 { FirebaseAuthTokenData } from '@firebase/app-types/private';
+import { FirebaseAuthInternalName } from '@firebase/auth-interop-types';
+import { Provider } from '@firebase/component';
+export interface AuthTokenProvider {
+    getToken(forceRefresh: boolean): Promise<FirebaseAuthTokenData>;
+    addTokenChangeListener(listener: (token: string | null) => void): void;
+    removeTokenChangeListener(listener: (token: string | null) => void): void;
+    notifyForInvalidToken(): void;
+}
+/**
+ * Abstraction around FirebaseApp's token fetching capabilities.
+ */
+export declare class FirebaseAuthTokenProvider implements AuthTokenProvider {
+    private appName_;
+    private firebaseOptions_;
+    private authProvider_;
+    private auth_;
+    constructor(appName_: string, firebaseOptions_: object, authProvider_: Provider<FirebaseAuthInternalName>);
+    getToken(forceRefresh: boolean): Promise<FirebaseAuthTokenData>;
+    addTokenChangeListener(listener: (token: string | null) => void): void;
+    removeTokenChangeListener(listener: (token: string | null) => void): void;
+    notifyForInvalidToken(): void;
+}
+export declare class EmulatorTokenProvider implements AuthTokenProvider {
+    private accessToken;
+    /** A string that is treated as an admin access token by the RTDB emulator. Used by Admin SDK. */
+    static OWNER: string;
+    constructor(accessToken: string);
+    getToken(forceRefresh: boolean): Promise<FirebaseAuthTokenData>;
+    addTokenChangeListener(listener: (token: string | null) => void): void;
+    removeTokenChangeListener(listener: (token: string | null) => void): void;
+    notifyForInvalidToken(): void;
+}

package/dist/src/core/CompoundWrite.d.ts

@@ -0,0 +1,81 @@
+/**
+ * @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 { NamedNode, Node } from './snap/Node';
+import { ImmutableTree } from './util/ImmutableTree';
+import { Path } from './util/Path';
+/**
+ * This class holds a collection of writes that can be applied to nodes in unison. It abstracts away the logic with
+ * dealing with priority writes and multiple nested writes. At any given path there is only allowed to be one write
+ * modifying that path. Any write to an existing path or shadowing an existing path will modify that existing write
+ * to reflect the write added.
+ */
+export declare class CompoundWrite {
+    writeTree_: ImmutableTree<Node>;
+    constructor(writeTree_: ImmutableTree<Node>);
+    static empty(): CompoundWrite;
+}
+export declare function compoundWriteAddWrite(compoundWrite: CompoundWrite, path: Path, node: Node): CompoundWrite;
+export declare function compoundWriteAddWrites(compoundWrite: CompoundWrite, path: Path, updates: {
+    [name: string]: Node;
+}): CompoundWrite;
+/**
+ * Will remove a write at the given path and deeper paths. This will <em>not</em> modify a write at a higher
+ * location, which must be removed by calling this method with that path.
+ *
+ * @param compoundWrite - The CompoundWrite to remove.
+ * @param path - The path at which a write and all deeper writes should be removed
+ * @returns The new CompoundWrite with the removed path
+ */
+export declare function compoundWriteRemoveWrite(compoundWrite: CompoundWrite, path: Path): CompoundWrite;
+/**
+ * Returns whether this CompoundWrite will fully overwrite a node at a given location and can therefore be
+ * considered "complete".
+ *
+ * @param compoundWrite - The CompoundWrite to check.
+ * @param path - The path to check for
+ * @returns Whether there is a complete write at that path
+ */
+export declare function compoundWriteHasCompleteWrite(compoundWrite: CompoundWrite, path: Path): boolean;
+/**
+ * Returns a node for a path if and only if the node is a "complete" overwrite at that path. This will not aggregate
+ * writes from deeper paths, but will return child nodes from a more shallow path.
+ *
+ * @param compoundWrite - The CompoundWrite to get the node from.
+ * @param path - The path to get a complete write
+ * @returns The node if complete at that path, or null otherwise.
+ */
+export declare function compoundWriteGetCompleteNode(compoundWrite: CompoundWrite, path: Path): Node | null;
+/**
+ * Returns all children that are guaranteed to be a complete overwrite.
+ *
+ * @param compoundWrite - The CompoundWrite to get children from.
+ * @returns A list of all complete children.
+ */
+export declare function compoundWriteGetCompleteChildren(compoundWrite: CompoundWrite): NamedNode[];
+export declare function compoundWriteChildCompoundWrite(compoundWrite: CompoundWrite, path: Path): CompoundWrite;
+/**
+ * Returns true if this CompoundWrite is empty and therefore does not modify any nodes.
+ * @returns Whether this CompoundWrite is empty
+ */
+export declare function compoundWriteIsEmpty(compoundWrite: CompoundWrite): boolean;
+/**
+ * Applies this CompoundWrite to a node. The node is returned with all writes from this CompoundWrite applied to the
+ * node
+ * @param node - The node to apply this CompoundWrite to
+ * @returns The node with all writes applied
+ */
+export declare function compoundWriteApply(compoundWrite: CompoundWrite, node: Node): Node;

package/dist/src/core/PersistentConnection.d.ts

@@ -0,0 +1,135 @@
+/**
+ * @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 { AppCheckTokenProvider } from './AppCheckTokenProvider';
+import { AuthTokenProvider } from './AuthTokenProvider';
+import { RepoInfo } from './RepoInfo';
+import { ServerActions } from './ServerActions';
+import { QueryContext } from './view/EventRegistration';
+/**
+ * Firebase connection.  Abstracts wire protocol and handles reconnecting.
+ *
+ * NOTE: All JSON objects sent to the realtime connection must have property names enclosed
+ * in quotes to make sure the closure compiler does not minify them.
+ */
+export declare class PersistentConnection extends ServerActions {
+    private repoInfo_;
+    private applicationId_;
+    private onDataUpdate_;
+    private onConnectStatus_;
+    private onServerInfoUpdate_;
+    private authTokenProvider_;
+    private appCheckTokenProvider_;
+    private authOverride_?;
+    id: number;
+    private log_;
+    private interruptReasons_;
+    private readonly listens;
+    private outstandingPuts_;
+    private outstandingGets_;
+    private outstandingPutCount_;
+    private outstandingGetCount_;
+    private onDisconnectRequestQueue_;
+    private connected_;
+    private reconnectDelay_;
+    private maxReconnectDelay_;
+    private securityDebugCallback_;
+    lastSessionId: string | null;
+    private establishConnectionTimer_;
+    private visible_;
+    private requestCBHash_;
+    private requestNumber_;
+    private realtime_;
+    private authToken_;
+    private appCheckToken_;
+    private forceTokenRefresh_;
+    private invalidAuthTokenCount_;
+    private invalidAppCheckTokenCount_;
+    private firstConnection_;
+    private lastConnectionAttemptTime_;
+    private lastConnectionEstablishedTime_;
+    private static nextPersistentConnectionId_;
+    /**
+     * Counter for number of connections created. Mainly used for tagging in the logs
+     */
+    private static nextConnectionId_;
+    /**
+     * @param repoInfo_ - Data about the namespace we are connecting to
+     * @param applicationId_ - The Firebase App ID for this project
+     * @param onDataUpdate_ - A callback for new data from the server
+     */
+    constructor(repoInfo_: RepoInfo, applicationId_: string, onDataUpdate_: (a: string, b: unknown, c: boolean, d: number | null) => void, onConnectStatus_: (a: boolean) => void, onServerInfoUpdate_: (a: unknown) => void, authTokenProvider_: AuthTokenProvider, appCheckTokenProvider_: AppCheckTokenProvider, authOverride_?: object | null);
+    protected sendRequest(action: string, body: unknown, onResponse?: (a: unknown) => void): void;
+    get(query: QueryContext): Promise<string>;
+    listen(query: QueryContext, currentHashFn: () => string, tag: number | null, onComplete: (a: string, b: unknown) => void): void;
+    private sendGet_;
+    private sendListen_;
+    private static warnOnListenWarnings_;
+    refreshAuthToken(token: string): void;
+    private reduceReconnectDelayIfAdminCredential_;
+    refreshAppCheckToken(token: string | null): void;
+    /**
+     * Attempts to authenticate with the given credentials. If the authentication attempt fails, it's triggered like
+     * a auth revoked (the connection is closed).
+     */
+    tryAuth(): void;
+    /**
+     * Attempts to authenticate with the given token. If the authentication
+     * attempt fails, it's triggered like the token was revoked (the connection is
+     * closed).
+     */
+    tryAppCheck(): void;
+    /**
+     * @inheritDoc
+     */
+    unlisten(query: QueryContext, tag: number | null): void;
+    private sendUnlisten_;
+    onDisconnectPut(pathString: string, data: unknown, onComplete?: (a: string, b: string) => void): void;
+    onDisconnectMerge(pathString: string, data: unknown, onComplete?: (a: string, b: string) => void): void;
+    onDisconnectCancel(pathString: string, onComplete?: (a: string, b: string) => void): void;
+    private sendOnDisconnect_;
+    put(pathString: string, data: unknown, onComplete?: (a: string, b: string) => void, hash?: string): void;
+    merge(pathString: string, data: unknown, onComplete: (a: string, b: string | null) => void, hash?: string): void;
+    putInternal(action: string, pathString: string, data: unknown, onComplete: (a: string, b: string | null) => void, hash?: string): void;
+    private sendPut_;
+    reportStats(stats: {
+        [k: string]: unknown;
+    }): void;
+    private onDataMessage_;
+    private onDataPush_;
+    private onReady_;
+    private scheduleConnect_;
+    private initConnection_;
+    private onVisible_;
+    private onOnline_;
+    private onRealtimeDisconnect_;
+    private establishConnection_;
+    interrupt(reason: string): void;
+    resume(reason: string): void;
+    private handleTimestamp_;
+    private cancelSentTransactions_;
+    private onListenRevoked_;
+    private removeListen_;
+    private onAuthRevoked_;
+    private onAppCheckRevoked_;
+    private onSecurityDebugPacket_;
+    private restoreState_;
+    /**
+     * Sends client stats for first connection
+     */
+    private sendConnectStats_;
+    private shouldReconnect_;
+}

package/dist/src/core/ReadonlyRestClient.d.ts

@@ -0,0 +1,60 @@
+/**
+ * @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 { AppCheckTokenProvider } from './AppCheckTokenProvider';
+import { AuthTokenProvider } from './AuthTokenProvider';
+import { RepoInfo } from './RepoInfo';
+import { ServerActions } from './ServerActions';
+import { QueryContext } from './view/EventRegistration';
+/**
+ * An implementation of ServerActions that communicates with the server via REST requests.
+ * This is mostly useful for compatibility with crawlers, where we don't want to spin up a full
+ * persistent connection (using WebSockets or long-polling)
+ */
+export declare class ReadonlyRestClient extends ServerActions {
+    private repoInfo_;
+    private onDataUpdate_;
+    private authTokenProvider_;
+    private appCheckTokenProvider_;
+    reportStats(stats: {
+        [k: string]: unknown;
+    }): void;
+    /** @private {function(...[*])} */
+    private log_;
+    /**
+     * We don't actually need to track listens, except to prevent us calling an onComplete for a listen
+     * that's been removed. :-/
+     */
+    private listens_;
+    static getListenId_(query: QueryContext, tag?: number | null): string;
+    /**
+     * @param repoInfo_ - Data about the namespace we are connecting to
+     * @param onDataUpdate_ - A callback for new data from the server
+     */
+    constructor(repoInfo_: RepoInfo, onDataUpdate_: (a: string, b: unknown, c: boolean, d: number | null) => void, authTokenProvider_: AuthTokenProvider, appCheckTokenProvider_: AppCheckTokenProvider);
+    /** @inheritDoc */
+    listen(query: QueryContext, currentHashFn: () => string, tag: number | null, onComplete: (a: string, b: unknown) => void): void;
+    /** @inheritDoc */
+    unlisten(query: QueryContext, tag: number | null): void;
+    get(query: QueryContext): Promise<string>;
+    /** @inheritDoc */
+    refreshAuthToken(token: string): void;
+    /**
+     * Performs a REST request to the given path, with the provided query string parameters,
+     * and any auth credentials we have.
+     */
+    private restRequest_;
+}