@firebase/data-connect 0.5.0 → 0.6.0-20260409172004

package/dist/node-esm/src/api/Mutation.d.ts

@@ -14,7 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { DataConnectTransport } from '../network/transport';
+import { DataConnectTransportInterface } from '../network';
 import { DataConnect } from './DataConnect';
 import { DataConnectResult, MUTATION_STR, OperationRef } from './Reference';
 export interface MutationRef<Data, Variables> extends OperationRef<Data, Variables> {
@@ -39,7 +39,7 @@ export declare function mutationRef<Data, Variables>(dcInstance: DataConnect, mu
 export declare class MutationManager {
     private _transport;
     private _inflight;
-    constructor(_transport: DataConnectTransport);
+    constructor(_transport: DataConnectTransportInterface);
     executeMutation<Data, Variables>(mutationRef: MutationRef<Data, Variables>): MutationPromise<Data, Variables>;
 }
 /**

package/dist/node-esm/src/api/query.d.ts

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 import { ExecuteQueryOptions } from '../core/query/queryOptions';
-import { DataConnectExtensionWithMaxAge } from '../network/transport';
+import { DataConnectExtensionWithMaxAge } from '../network';
 import { DataConnect } from './DataConnect';
 import { OperationRef, QUERY_STR, DataConnectResult, SerializedRef } from './Reference';
 /**

package/dist/node-esm/src/core/query/QueryManager.d.ts

@@ -18,8 +18,7 @@ import { type DataConnect } from '../../api/DataConnect';
 import { QueryRef, QueryResult } from '../../api/query';
 import { SerializedRef, DataSource } from '../../api/Reference';
 import { DataConnectCache } from '../../cache/Cache';
-import { DataConnectTransport } from '../../network';
-import { DataConnectExtensionWithMaxAge } from '../../network/transport';
+import { DataConnectTransportInterface, DataConnectExtensionWithMaxAge } from '../../network';
 import { OnCompleteSubscription, OnErrorSubscription, OnResultSubscription } from './subscribe';
 export declare function getRefSerializer<Data, Variables>(queryRef: QueryRef<Data, Variables>, data: Data, source: DataSource, fetchTime: string): () => SerializedRef<Data, Variables>;
 export declare class QueryManager {
@@ -28,8 +27,12 @@ export declare class QueryManager {
     private cache?;
     preferCacheResults<Data, Variables>(queryRef: QueryRef<Data, Variables>, allowStale?: boolean): Promise<QueryResult<Data, Variables>>;
     private callbacks;
+    /**
+     * Map of serialized query keys to most recent Query Result. Used as a simple fallback cache
+     * for subsciptions if caching is not enabled.
+     */
     private subscriptionCache;
-    constructor(transport: DataConnectTransport, dc: DataConnect, cache?: DataConnectCache | undefined);
+    constructor(transport: DataConnectTransportInterface, dc: DataConnect, cache?: DataConnectCache | undefined);
     private queue;
     waitForQueuedWrites(): Promise<void>;
     updateSSR<Data, Variables>(updatedData: QueryResult<Data, Variables>): void;
@@ -40,8 +43,24 @@ export declare class QueryManager {
     publishErrorToSubscribers(key: string, err: unknown): void;
     getFromResultTreeCache<Data, Variables>(queryRef: QueryRef<Data, Variables>, allowStale?: boolean): Promise<QueryResult<Data, Variables> | null>;
     getFromSubscriberCache<Data, Variables>(queryRef: QueryRef<Data, Variables>): Promise<QueryResult<Data, Variables> | undefined>;
+    /** Call the registered onNext callbacks for the given key */
     publishDataToSubscribers(key: string, queryResult: QueryResult<unknown, unknown>): void;
     publishCacheResultsToSubscribers(impactedQueries: string[], fetchTime: string): Promise<void>;
     enableEmulator(host: string, port: number): void;
+    /**
+     * Create a new {@link SubscribeObserver} for the given QueryRef. This will be passed to
+     * {@link DataConnectTransportInterface.invokeSubscribe | invokeSubscribe()} to notify the query
+     * layer of data update notifications or if the stream disconnected.
+     */
+    private makeSubscribeObserver;
+    /**
+     * Handle a data update notification from the stream. Notify subscribers of results/errors, and
+     * update the cache.
+     */
+    private handleStreamNotification;
+    /**
+     * Handle a disconnect from the stream. Unsubscribe all callbacks for the given key.
+     */
+    private handleStreamDisconnect;
 }
 export declare function getMaxAgeFromExtensions(extensions: DataConnectExtensionWithMaxAge[] | undefined): number | undefined;

package/dist/node-esm/src/network/index.d.ts

@@ -14,4 +14,4 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export { CallerSdkType, CallerSdkTypeEnum, DataConnectTransport, DataConnectEntityArray, DataConnectSingleEntity, DataConnectExtension, Extensions, TransportClass } from './transport';
+export * from './transport';

package/dist/node-esm/src/network/manager.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @license
+ * Copyright 2026 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 { DataConnectOptions, TransportOptions } from '../api/DataConnect';
+import { AppCheckTokenProvider } from '../core/AppCheckTokenProvider';
+import { AuthTokenProvider } from '../core/FirebaseAuthProvider';
+import { CallerSdkType, DataConnectResponse, DataConnectResponseWithMaxAge, DataConnectTransportInterface, SubscribeObserver } from './transport';
+/**
+ * Entry point for the transport layer. Manages routing between transport implementations.
+ * @internal
+ */
+export declare class DataConnectTransportManager implements DataConnectTransportInterface {
+    private options;
+    private apiKey?;
+    private appId?;
+    private authProvider?;
+    private appCheckProvider?;
+    private transportOptions?;
+    private _isUsingGen;
+    private _callerSdkType?;
+    private restTransport;
+    private streamTransport?;
+    private isUsingEmulator;
+    constructor(options: DataConnectOptions, apiKey?: string | undefined, appId?: (string | null) | undefined, authProvider?: AuthTokenProvider | undefined, appCheckProvider?: AppCheckTokenProvider | undefined, transportOptions?: TransportOptions | undefined, _isUsingGen?: boolean, _callerSdkType?: CallerSdkType | undefined);
+    /**
+     * Initializes the stream transport if it hasn't been already.
+     */
+    private initStreamTransport;
+    /**
+     * Returns true if the stream is in a healthy, ready connection state and has active subscriptions.
+     */
+    private executeShouldUseStream;
+    /**
+     * Prefer to use Streaming Transport connection when one is available.
+     * @inheritdoc
+     */
+    invokeQuery<Data, Variables>(queryName: string, body?: Variables): Promise<DataConnectResponseWithMaxAge<Data>>;
+    /**
+     * Prefer to use Streaming Transport connection when one is available.
+     * @inheritdoc
+     */
+    invokeMutation<Data, Variables>(queryName: string, body?: Variables): Promise<DataConnectResponse<Data>>;
+    invokeSubscribe<Data, Variables>(observer: SubscribeObserver<Data>, queryName: string, body?: Variables): void;
+    invokeUnsubscribe<Variables>(queryName: string, body?: Variables): void;
+    useEmulator(host: string, port?: number, sslEnabled?: boolean): void;
+    onAuthTokenChanged(token: string | null): void;
+    _setCallerSdkType(callerSdkType: CallerSdkType): void;
+}

package/dist/node-esm/src/network/{fetch.d.ts → rest/fetch.d.ts}

@@ -14,11 +14,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { CallerSdkType, DataConnectResponse } from './transport';
+import { CallerSdkType, DataConnectResponse } from '..';
+/**
+ * This function is ONLY used for testing and for ensuring compatability in environments which may
+ * be using a poyfill and/or bundlers. It should not be called by users of the Firebase JS SDK.
+ * @internal
+ */
 export declare function initializeFetch(fetchImpl: typeof fetch): void;
-export interface DataConnectFetchBody<T> {
+export interface DataConnectFetchBody<Variables> {
     name: string;
     operationName: string;
-    variables: T;
+    variables: Variables;
 }
-export declare function dcFetch<T, U>(url: string, body: DataConnectFetchBody<U>, { signal }: AbortController, appId: string | null | undefined, accessToken: string | null, appCheckToken: string | null | undefined, _isUsingGen: boolean, _callerSdkType: CallerSdkType, _isUsingEmulator: boolean): Promise<DataConnectResponse<T>>;
+export declare function dcFetch<Data, Variables>(url: string, body: DataConnectFetchBody<Variables>, { signal }: AbortController, appId: string | null | undefined, accessToken: string | null, appCheckToken: string | null | undefined, _isUsingGen: boolean, _callerSdkType: CallerSdkType, _isUsingEmulator: boolean): Promise<DataConnectResponse<Data>>;

package/dist/node-esm/src/network/rest/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2026 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 './fetch';
+export * from './restTransport';

package/dist/node-esm/src/network/rest/restTransport.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2024 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 { CallerSdkType, DataConnectResponse, DataConnectResponseWithMaxAge, AbstractDataConnectTransport, SubscribeObserver } from '..';
+import { DataConnectOptions, TransportOptions } from '../../api/DataConnect';
+import { AppCheckTokenProvider } from '../../core/AppCheckTokenProvider';
+import { AuthTokenProvider } from '../../core/FirebaseAuthProvider';
+/**
+ * Fetch-based REST implementation of {@link AbstractDataConnectTransport}.
+ * @internal
+ */
+export declare class RESTTransport extends AbstractDataConnectTransport {
+    constructor(options: DataConnectOptions, apiKey?: string | undefined, appId?: string | null, authProvider?: AuthTokenProvider | undefined, appCheckProvider?: AppCheckTokenProvider | undefined, transportOptions?: TransportOptions | undefined, _isUsingGen?: boolean, _callerSdkType?: CallerSdkType);
+    get endpointUrl(): string;
+    invokeQuery: <Data, Variables>(queryName: string, body?: Variables) => Promise<DataConnectResponseWithMaxAge<Data>>;
+    invokeMutation: <Data, Variables>(queryName: string, body?: Variables) => Promise<DataConnectResponse<Data>>;
+    invokeSubscribe<Data, Variables>(observer: SubscribeObserver<Data>, queryName: string, body?: Variables): void;
+    invokeUnsubscribe<Variables>(queryName: string, body?: Variables): void;
+    onAuthTokenChanged(newToken: string | null): void;
+}

package/dist/node-esm/src/network/stream/streamTransport.d.ts

@@ -0,0 +1,243 @@
+/**
+ * @license
+ * Copyright 2026 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 { AbstractDataConnectTransport, DataConnectResponse, SubscribeObserver } from '../transport';
+import { DataConnectStreamRequest } from './wire';
+/**
+ * The base class for all {@link DataConnectStreamTransport | Stream Transport} implementations.
+ * Handles management of logical streams (requests), authentication, data routing to query layer, etc.
+ * @internal
+ */
+export declare abstract class AbstractDataConnectStreamTransport extends AbstractDataConnectTransport {
+    /** Optional callback invoked when the stream closes gracefully. */
+    onGracefulStreamClose?: () => void;
+    /** True if the physical stream connection is fully open and ready to transmit data. */
+    abstract get streamIsReady(): boolean;
+    /** Is the stream currently waiting to close connection? */
+    get isPendingClose(): boolean;
+    private pendingClose;
+    /** True if the transport is unable to connect to the server */
+    isUnableToConnect: boolean;
+    /** True if there are active subscriptions on the stream */
+    get hasActiveSubscriptions(): boolean;
+    /** True if there are active execute or mutation requests on the stream */
+    get hasActiveExecuteRequests(): boolean;
+    /**
+     * Open a physical connection to the server.
+     * @returns a promise which resolves when the connection is ready, or rejects if it fails to open.
+     */
+    protected abstract openConnection(): Promise<void>;
+    /**
+     * Close the physical connection with the server. Handles no cleanup - simply closes the
+     * implementation-specific connection.
+     * @returns a promise which resolves when the connection is closed, or rejects if it fails to close.
+     * On failure to close, the connection is still considered closed.
+     */
+    protected abstract closeConnection(): Promise<void>;
+    /**
+     * Queue a message to be sent over the stream.
+     * @param requestBody The body of the message to be sent.
+     * @throws DataConnectError if sending fails.
+     */
+    protected abstract sendMessage<Variables>(requestBody: DataConnectStreamRequest<Variables>): Promise<void>;
+    /**
+     * Ensures that that there is an open connection. If there is none, it initiates a new one.
+     * If a connection attempt is already in progress, it returns the existing connection promise.
+     * @returns A promise that resolves when the stream is open and ready.
+     */
+    protected abstract ensureConnection(): Promise<void>;
+    /** The request ID of the next message to be sent. Monotonically increasing sequence number. */
+    private requestNumber;
+    /**
+     * Generates and returns the next request ID.
+     */
+    private nextRequestId;
+    /**
+     * Map of query/variables to their active execute/resume request bodies.
+     */
+    private activeQueryExecuteRequests;
+    /**
+     * Map of mutation/variables to their active execute request bodies.
+     */
+    private activeMutationExecuteRequests;
+    /**
+     * Map of query/variables to their active subscribe request bodies.
+     */
+    private activeSubscribeRequests;
+    /**
+     * Map of active execution RequestIds and their corresponding Promises and resolvers.
+     */
+    private executeRequestPromises;
+    /**
+     * Map of active subscription RequestIds and their corresponding observers.
+     */
+    private subscribeObservers;
+    /** current close timeout from setTimeout(), if any */
+    private closeTimeout;
+    /** has the close timeout finished? */
+    private closeTimeoutFinished;
+    /** current auth uid. used to detect if a different user logs in */
+    private authUid;
+    /** Flag to ensure we wait for the initial auth state once per connection attempt. */
+    private hasWaitedForInitialAuth;
+    /**
+     * Tracks a query execution request, storing the request body and creating and storing a promise that
+     * will be resolved when the response is received.
+     * @returns The reject function and the response promise.
+     *
+     * @remarks
+     * This method returns a promise, but is synchronous.
+     */
+    private trackQueryExecuteRequest;
+    /**
+     * Tracks a mutation execution request, storing the request body and creating and storing a promise
+     * that will be resolved when the response is received.
+     * @returns The reject function and the response promise.
+     *
+     * @remarks
+     * This method returns a promise, but is synchronous.
+     */
+    private trackMutationExecuteRequest;
+    /**
+     * Tracks a subscribe request, storing the request body and the notification observer.
+     * @remarks
+     * This method is synchronous.
+     */
+    private trackSubscribeRequest;
+    /**
+     * Cleans up the query execute request tracking data structures, deleting the tracked request and
+     * it's associated promise.
+     */
+    private cleanupQueryExecuteRequest;
+    /**
+     * Cleans up the mutation execute request tracking data structures, deleting the tracked request and
+     * it's associated promise.
+     */
+    private cleanupMutationExecuteRequest;
+    /**
+     * Cleans up the subscribe request tracking data structures, deleting the tracked request and
+     * it's associated promise.
+     */
+    private cleanupSubscribeRequest;
+    /**
+     * Tracks if the next message to be sent is the first message of the stream.
+     */
+    private isFirstStreamMessage;
+    /**
+     * Tracks the last auth token sent to the server.
+     * Used to detect if the token has changed and needs to be resent.
+     */
+    private lastSentAuthToken;
+    /**
+     * Indicates whether we should include the auth token in the next message.
+     * Only true if there is an auth token and it is different from the last sent auth token, or this
+     * is the first message.
+     */
+    private get shouldIncludeAuth();
+    /**
+     * Called by the concrete transport implementation when the physical connection is ready.
+     */
+    protected onConnectionReady(): void;
+    /**
+     * Attempt to close the connection. Will only close if there are no active requests preventing it
+     * from doing so.
+     */
+    private attemptClose;
+    /**
+     * Begin closing the connection. Waits for and cleans up all active requests, and waits for
+     * {@link IDLE_CONNECTION_TIMEOUT_MS}. This is a graceful close - it will be called when there are
+     * no more active subscriptions, so there's no need to cleanup.
+     */
+    private prepareToCloseGracefully;
+    /**
+     * Cancel closing the connection.
+     */
+    private cancelClose;
+    /**
+     * Reject all active execute promises and notify all subscribe observers with the given error.
+     * Clear active request tracking maps without cancelling or re-invoking any requests.
+     */
+    private rejectAllActiveRequests;
+    /**
+     * Called by concrete implementations when the stream is successfully closed, gracefully or otherwise.
+     */
+    protected onStreamClose(code: number, reason: string): void;
+    /**
+     * Prepares a stream request message by adding necessary headers and metadata.
+     * If this is the first message on the stream, it includes the resource name, auth token, and App Check token.
+     * If the auth token has refreshed since the last message, it includes the new auth token.
+     *
+     * This method is called by the concrete transport implementation before sending a message.
+     *
+     * @returns the requestBody, with attached headers and initial request fields
+     */
+    protected prepareMessage<Variables, StreamBody extends DataConnectStreamRequest<Variables>>(requestBody: StreamBody): StreamBody;
+    /**
+     * Sends a request message to the server via the concrete implementation.
+     * Ensures the connection is ready and prepares the message before sending.
+     * @returns A promise that resolves when the request message has been sent.
+     */
+    private sendRequestMessage;
+    /**
+     * Helper to generate a consistent string key for the tracking maps.
+     */
+    private getMapKey;
+    /**
+     * Recursively sorts the keys of an object.
+     */
+    private sortObjectKeys;
+    /**
+     * @inheritdoc
+     * @remarks
+     * This method synchronously updates the request tracking data structures before sending any message.
+     * If any asynchronous functionality is added to this function, it MUST be done in a way that
+     * preserves the synchronous update of the tracking data structures before the method returns.
+     */
+    invokeQuery<Data, Variables>(queryName: string, variables?: Variables): Promise<DataConnectResponse<Data>>;
+    /**
+     * @inheritdoc
+     * @remarks
+     * This method synchronously updates the request tracking data structures before sending any message.
+     * If any asynchronous functionality is added to this function, it MUST be done in a way that
+     * preserves the synchronous update of the tracking data structures before the method returns.
+     */
+    invokeMutation<Data, Variables>(mutationName: string, variables?: Variables): Promise<DataConnectResponse<Data>>;
+    /**
+     * @inheritdoc
+     * @remarks
+     * This method synchronously updates the request tracking data structures before sending any message
+     * or cancelling the closing of the stream. If any asynchronous functionality is added to this function,
+     * it MUST be done in a way that preserves the synchronous update of the tracking data structures
+     * before the method returns.
+     */
+    invokeSubscribe<Data, Variables>(observer: SubscribeObserver<Data>, queryName: string, variables: Variables): void;
+    /**
+     * @inheritdoc
+     * @remarks
+     * This method synchronously updates the request tracking data structures before sending any message.
+     * If any asynchronous functionality is added to this function, it MUST be done in a way that
+     * preserves the synchronous update of the tracking data structures before the method returns.
+     */
+    invokeUnsubscribe<Variables>(queryName: string, variables: Variables): void;
+    onAuthTokenChanged(newToken: string | null): void;
+    /**
+     * Handle a response message from the server. Called by the connection-specific implementation after
+     * it's transformed a message from the server into a {@link DataConnectResponse}.
+     * @param requestId the requestId associated with this response.
+     * @param response the response from the server.
+     */
+    protected handleResponse<Data>(requestId: string, response: DataConnectResponse<Data>): Promise<void>;
+}

package/dist/node-esm/src/network/stream/websocket.d.ts

@@ -0,0 +1,90 @@
+/**
+ * @license
+ * Copyright 2026 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 { DataConnectOptions, TransportOptions } from '../../api/DataConnect';
+import { AppCheckTokenProvider } from '../../core/AppCheckTokenProvider';
+import { AuthTokenProvider } from '../../core/FirebaseAuthProvider';
+import { CallerSdkType } from '../transport';
+import { AbstractDataConnectStreamTransport } from './streamTransport';
+import { DataConnectStreamRequest } from './wire';
+/**
+ * This function is ONLY used for testing and for ensuring compatability in environments which may
+ * be using a poyfill and/or bundlers. It should not be called by users of the Firebase JS SDK.
+ * @internal
+ */
+export declare function initializeWebSocket(webSocketImpl: typeof WebSocket): void;
+/**
+ * The code used to close the WebSocket connection.
+ * This is a protocol-level code, and is not the same as the {@link Code | DataConnect error code}.
+ * @internal
+ */
+export declare const WEBSOCKET_CLOSE_CODE = 1000;
+/**
+ * An {@link AbstractDataConnectStreamTransport | Stream Transport} implementation that uses {@link WebSocket | WebSockets} to stream requests and responses.
+ * This class handles the lifecycle of the WebSocket connection, including automatic
+ * reconnection and request correlation.
+ * @internal
+ */
+export declare class WebSocketTransport extends AbstractDataConnectStreamTransport {
+    protected apiKey?: string | undefined;
+    protected appId?: (string | null) | undefined;
+    protected authProvider?: AuthTokenProvider | undefined;
+    protected appCheckProvider?: AppCheckTokenProvider | undefined;
+    protected _isUsingGen: boolean;
+    protected _callerSdkType: CallerSdkType;
+    get endpointUrl(): string;
+    /** Decodes binary WebSocket responses to strings */
+    private decoder;
+    /**
+     * Decodes a WebSocket response from a Uint8Array to a JSON object.
+     * Emulator does not send messages as Uint8Arrays, but prod does.
+     */
+    private decodeBinaryResponse;
+    /** The current connection to the server. Undefined if disconnected. */
+    private connection;
+    get streamIsReady(): boolean;
+    /**
+     * Current connection attempt. If null, we are not currently attemping to connect (not connected,
+     * or already connected). Will be resolved or rejected when the connection is opened or fails to open.
+     */
+    private connectionAttempt;
+    constructor(options: DataConnectOptions, apiKey?: string | undefined, appId?: (string | null) | undefined, authProvider?: AuthTokenProvider | undefined, appCheckProvider?: AppCheckTokenProvider | undefined, transportOptions?: TransportOptions | undefined, _isUsingGen?: boolean, _callerSdkType?: CallerSdkType);
+    protected ensureConnection(): Promise<void>;
+    protected openConnection(): Promise<void>;
+    protected closeConnection(code?: number, reason?: string): Promise<void>;
+    /**
+     * Handle a disconnection from the server. Initiates graceful clean up and reconnection attempts.
+     * @param ev the {@link CloseEvent} that closed the WebSocket.
+     */
+    private handleWebsocketDisconnect;
+    /**
+     * Handle an error that occurred on the WebSocket. Close the connection and reject all active requests.
+     */
+    private handleError;
+    protected sendMessage<Variables>(requestBody: DataConnectStreamRequest<Variables>): Promise<void>;
+    /**
+     * Handles incoming WebSocket messages.
+     * @param ev The {@link MessageEvent} from the WebSocket.
+     */
+    private handleWebSocketMessage;
+    /**
+     * Parse a response from the server. Assert that it has a {@link DataConnectStreamResponse.requestId | requestId}.
+     * @param data the message from the server to be parsed
+     * @returns the parsed message as a {@link DataConnectStreamResponse}
+     * @throws {DataConnectError} if parsing fails or message is malformed.
+     */
+    private parseWebSocketData;
+}