@firebase/data-connect 0.5.0 → 0.6.0-20260408221811

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

@@ -0,0 +1,138 @@
+/**
+ * @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 { Extensions } from '../index';
+/**
+ * Shape of response from the server.
+ * @internal
+ */
+export interface DataConnectStreamResponse<Data> {
+    requestId: string;
+    data: Data;
+    extensions: Extensions;
+    dataEtag: string;
+    errors: Error[];
+    cancelled: boolean;
+}
+/**
+ * Base interface for stream request payloads sent over the stream to the server.
+ * @internal
+ */
+export interface StreamRequest {
+    /** monotonically increasing request ID */
+    requestId: string;
+    /** connectorResourcePath - only required on initial connection */
+    name?: string;
+    /** optional headers for this request, for authentication + telemetry */
+    headers?: StreamRequestHeaders;
+    /** received from server on previous response, included to optimize bandwidth */
+    dataEtag?: string;
+}
+/**
+ * Optional headers for a stream request, for authentication + telemetry
+ * @internal
+ */
+export interface StreamRequestHeaders {
+    /** used to initially authenticate or re-authenticate */
+    authToken?: string;
+    /** used to initially authenticate or re-authenticate */
+    appCheckToken?: string;
+    /** SDK telemetry header */
+    'X-Goog-Api-Client'?: string;
+    /** firebase appid */
+    'x-firebase-gmpid'?: string;
+}
+/**
+ * Fields for an execute request payload.
+ * @internal
+ */
+interface ExecuteRequestKind<Variables> {
+    operationName: string;
+    variables?: Variables;
+}
+/**
+ * Fields for a subscribe request payload.
+ * @internal
+ */
+interface SubscribeRequestKind<Variables> {
+    operationName: string;
+    variables?: Variables;
+}
+/**
+ * Fields for a resume request payload.
+ * @internal
+ */
+interface ResumeRequestKind {
+}
+/**
+ * Fields for a cancel request payload.
+ * @internal
+ */
+interface CancelRequestKind {
+}
+/**
+ * Fields for a subscribe request payload.
+ * @internal
+ */
+export interface SubscribeStreamRequest<Variables> extends StreamRequest {
+    subscribe: SubscribeRequestKind<Variables>;
+    execute?: never;
+    resume?: never;
+    cancel?: never;
+}
+/**
+ * Fields for an execute request payload.
+ * @internal
+ */
+export interface ExecuteStreamRequest<Variables> extends StreamRequest {
+    execute: ExecuteRequestKind<Variables>;
+    subscribe?: never;
+    resume?: never;
+    cancel?: never;
+}
+/**
+ * Fields for a resume (subscribe) request payload.
+ * @internal
+ */
+export interface ResumeStreamRequest extends StreamRequest {
+    resume: ResumeRequestKind;
+    subscribe?: never;
+    execute?: never;
+    cancel?: never;
+}
+/**
+ * Fields for a cancel (unsubscribe) request payload.
+ * @internal
+ */
+export interface CancelStreamRequest extends StreamRequest {
+    cancel: CancelRequestKind;
+    subscribe?: never;
+    execute?: never;
+    resume?: never;
+}
+/**
+ * Shape of the request body to be sent over the stream to the server.
+ * @internal
+ */
+export type DataConnectStreamRequest<Variables> = ExecuteStreamRequest<Variables> | SubscribeStreamRequest<Variables> | ResumeStreamRequest | CancelStreamRequest;
+/**
+ * Determines whether the provided request to execute a query is an execution request or a resume
+ * request
+ * @returns true if the requestBody is a resume request
+ * @internal
+ */
+export declare function queryRequestIsResume<Variables>(requestBody: ExecuteStreamRequest<Variables> | ResumeStreamRequest): requestBody is ResumeStreamRequest;
+export {};

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

@@ -0,0 +1,179 @@
+/**
+ * @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 { DataConnectOptions, TransportOptions } from '../api/DataConnect';
+import { AppCheckTokenProvider } from '../core/AppCheckTokenProvider';
+import { AuthTokenProvider } from '../core/FirebaseAuthProvider';
+/**
+ * enum representing different flavors of the SDK used by developers
+ * use the CallerSdkType for type-checking, and the CallerSdkTypeEnum for value-checking/assigning
+ */
+export type CallerSdkType = 'Base' | 'Generated' | 'TanstackReactCore' | 'GeneratedReact' | 'TanstackAngularCore' | 'GeneratedAngular';
+export declare const CallerSdkTypeEnum: {
+    readonly Base: "Base";
+    readonly Generated: "Generated";
+    readonly TanstackReactCore: "TanstackReactCore";
+    readonly GeneratedReact: "GeneratedReact";
+    readonly TanstackAngularCore: "TanstackAngularCore";
+    readonly GeneratedAngular: "GeneratedAngular";
+};
+export interface DataConnectEntityArray {
+    entityIds: string[];
+}
+export interface DataConnectSingleEntity {
+    entityId: string;
+}
+export type DataConnectExtension = {
+    path: Array<string | number>;
+} & (DataConnectEntityArray | DataConnectSingleEntity);
+/** @internal */
+export interface DataConnectMaxAge {
+    maxAge: string;
+}
+/** @internal */
+export type DataConnectExtensionWithMaxAge = {
+    path: Array<string | number>;
+} & (DataConnectEntityArray | DataConnectSingleEntity | DataConnectMaxAge);
+export interface Extensions {
+    dataConnect?: DataConnectExtension[];
+}
+/** @internal */
+export interface ExtensionsWithMaxAge {
+    dataConnect?: DataConnectExtensionWithMaxAge[];
+}
+/** @internal */
+export interface DataConnectResponse<T> {
+    data: T;
+    errors: Error[];
+    extensions: Extensions;
+}
+/** @internal */
+export interface DataConnectResponseWithMaxAge<T> {
+    data: T;
+    errors: Error[];
+    extensions: ExtensionsWithMaxAge;
+}
+/**
+ * Observer defined by the Query Layer for receiving notifications from the Transport Layer.
+ * @internal
+ */
+export interface SubscribeObserver<Data> {
+    onData(response: DataConnectResponse<Data>): Promise<void> | void;
+    onDisconnect(code: string, reason: string): void;
+    onError(error: Error): void;
+}
+/**
+ * Interface defining the external API of the transport layer.
+ * @internal
+ */
+export interface DataConnectTransportInterface {
+    /**
+     * Invoke a query execution request.
+     * @param queryName The name of the query to execute.
+     * @param body The variables associated with the query.
+     * @returns A promise resolving to the DataConnectResponse.
+     */
+    invokeQuery<Data, Variables>(queryName: string, body?: Variables): Promise<DataConnectResponseWithMaxAge<Data>>;
+    /**
+     * Invoke a mutation execution request.
+     * @param queryName The name of the mutation to execute.
+     * @param body The variables associated with the mutation.
+     * @returns A promise resolving to the DataConnectResponse.
+     */
+    invokeMutation<Data, Variables>(queryName: string, body?: Variables): Promise<DataConnectResponse<Data>>;
+    /**
+     * Subscribes to a query to receive push notifications of updates.
+     * @param observer the observer passed to the transport layer to notify the query layer of events.
+     * @param queryName The name of the query to subscribe to.
+     * @param body The variables associated with the subscription.
+     */
+    invokeSubscribe<Data, Variables>(observer: SubscribeObserver<Data>, queryName: string, body?: Variables): void;
+    /**
+     * Unsubscribes from an active subscription.
+     * @param queryName The name of the query to unsubscribe from.
+     * @param body The variables associated with the subscription.
+     */
+    invokeUnsubscribe<Variables>(queryName: string, body?: Variables): void;
+    /**
+     * Configures the transport to use a local Data Connect emulator.
+     * @param host The host address of the emulator (e.g., '127.0.0.1').
+     * @param port The port number the emulator is listening on.
+     * @param sslEnabled Whether to use SSL (HTTPS/WSS) for the emulator connection.
+     */
+    useEmulator(host: string, port?: number, sslEnabled?: boolean): void;
+    /**
+     * Callback invoked when the Firebase Auth token is refreshed or changed. Note that this callback
+     * is called immediately asynchronously when the Auth Provider is initialized to provide
+     * the initial auth state.
+     * @param token The new access token or null if signed out.
+     */
+    onAuthTokenChanged: (token: string | null) => void;
+    /**
+     * Internal method to set the SDK type for metrics and logging purposes.
+     * @param callerSdkType The type of SDK making the call (e.g., generated vs base).
+     */
+    _setCallerSdkType(callerSdkType: CallerSdkType): void;
+}
+/**
+ * Type signature of a transport class constructor.
+ * @internal
+ */
+export type TransportClass = new (options: DataConnectOptions, apiKey?: string, appId?: string, authProvider?: AuthTokenProvider, appCheckProvider?: AppCheckTokenProvider, transportOptions?: TransportOptions, _isUsingGen?: boolean, _callerSdkType?: CallerSdkType) => DataConnectTransportInterface;
+/**
+ * Constructs the value for the X-Goog-Api-Client header
+ * @internal
+ */
+export declare function getGoogApiClientValue(isUsingGen: boolean, callerSdkType: CallerSdkType): string;
+/**
+ * The base class for all DataConnectTransportInterface implementations. Handles common logic such as
+ * URL construction, auth token management, and emulator usage. Concrete transport implementations
+ * should extend this class and implement the abstract {@link DataConnectTransportInterface} methods.
+ * @internal
+ */
+export declare abstract class AbstractDataConnectTransport implements DataConnectTransportInterface {
+    protected apiKey?: string | undefined;
+    protected appId?: (string | null) | undefined;
+    protected authProvider?: AuthTokenProvider | undefined;
+    protected appCheckProvider?: AppCheckTokenProvider | undefined;
+    protected _isUsingGen: boolean;
+    protected _callerSdkType: CallerSdkType;
+    protected _host: string;
+    protected _port: number | undefined;
+    protected _location: string;
+    protected _connectorName: string;
+    /** The resource path for requests from this Data Connect instance. */
+    protected _connectorResourcePath: string;
+    protected _secure: boolean;
+    protected _project: string;
+    protected _serviceName: string;
+    protected _authToken: string | null;
+    protected _appCheckToken: string | null | undefined;
+    protected _lastToken: string | null;
+    protected _isUsingEmulator: boolean;
+    constructor(options: DataConnectOptions, apiKey?: string | undefined, appId?: (string | null) | undefined, authProvider?: AuthTokenProvider | undefined, appCheckProvider?: AppCheckTokenProvider | undefined, transportOptions?: TransportOptions | undefined, _isUsingGen?: boolean, _callerSdkType?: CallerSdkType);
+    /** Get the endpoint URL this transport should use to communicate with the backend. */
+    abstract get endpointUrl(): string;
+    useEmulator(host: string, port?: number, isSecure?: boolean): void;
+    getWithAuth(forceToken?: boolean): Promise<string | null>;
+    withRetry<T>(promiseFactory: () => Promise<DataConnectResponse<T>>, retry?: boolean): Promise<DataConnectResponse<T>>;
+    _setLastToken(lastToken: string | null): void;
+    abstract invokeQuery<Data, Variables>(queryName: string, body?: Variables): Promise<DataConnectResponseWithMaxAge<Data>>;
+    abstract invokeMutation<Data, Variables>(queryName: string, body?: Variables): Promise<DataConnectResponse<Data>>;
+    abstract invokeSubscribe<Data, Variables>(observer: SubscribeObserver<Data>, queryName: string, body?: Variables): void;
+    abstract invokeUnsubscribe<Variables>(queryName: string, variables: Variables): void;
+    abstract onAuthTokenChanged(newToken: string | null): void;
+    _setCallerSdkType(callerSdkType: CallerSdkType): void;
+}

package/dist/node-esm/src/util/url.d.ts

@@ -16,5 +16,7 @@
  */
 import { DataConnectOptions, TransportOptions } from '../api/DataConnect';
 export declare const PROD_HOST = "firebasedataconnect.googleapis.com";
-export declare function urlBuilder(projectConfig: DataConnectOptions, transportOptions: TransportOptions): string;
+export declare const WEBSOCKET_PATH = "ws/google.firebase.dataconnect.v1.ConnectorStreamService";
+export declare function restUrlBuilder(projectConfig: DataConnectOptions, transportOptions: TransportOptions): string;
+export declare function websocketUrlBuilder(projectConfig: DataConnectOptions, transportOptions: TransportOptions): string;
 export declare function addToken(url: string, apiKey?: string): string;

package/dist/private.d.ts

@@ -15,6 +15,8 @@ import { FirebaseError } from '@firebase/util';
 import { LogLevelString } from '@firebase/logger';
 import { Provider } from '@firebase/component';
 
+/* Excluded from this release type: AbstractDataConnectTransport */
+
 /* Excluded from this release type: AppCheckTokenProvider */
 
 /* Excluded from this release type: areTransportOptionsEqual */
@@ -179,11 +181,7 @@ export declare interface DataConnectOptions extends ConnectorConfig {
     projectId: string;
 }
 
-declare interface DataConnectResponse<T> {
-    data: T;
-    errors: Error[];
-    extensions: Extensions;
-}
+/* Excluded from this release type: DataConnectResponse */
 
 /* Excluded from this release type: DataConnectResponseWithMaxAge */
 
@@ -208,7 +206,7 @@ export declare interface DataConnectSubscription<Data, Variables> {
     unsubscribe: () => void;
 }
 
-/* Excluded from this release type: DataConnectTransport */
+/* Excluded from this release type: DataConnectTransportInterface */
 
 export declare type DataSource = typeof SOURCE_CACHE | typeof SOURCE_SERVER;
 
@@ -343,6 +341,8 @@ export declare function getDataConnect(app: FirebaseApp, connectorConfig: Connec
  */
 export declare function getDataConnect(app: FirebaseApp, connectorConfig: ConnectorConfig, settings: DataConnectSettings): DataConnect;
 
+/* Excluded from this release type: getGoogApiClientValue */
+
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -484,8 +484,12 @@ 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;
@@ -496,9 +500,25 @@ 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;
 }
 
 /**
@@ -618,6 +638,8 @@ export declare function subscribe<Data, Variables>(queryRefOrSerializedResult: Q
  */
 export declare function subscribe<Data, Variables>(queryRefOrSerializedResult: QueryRef<Data, Variables> | SerializedRef<Data, Variables>, onNext: OnResultSubscription<Data, Variables>, onError?: OnErrorSubscription, onComplete?: OnCompleteSubscription): QueryUnsubscribe;
 
+/* Excluded from this release type: SubscribeObserver */
+
 /**
  * Representation of full observer options in `subscribe`
  */

package/dist/public.d.ts

@@ -106,6 +106,7 @@ export declare interface DataConnectOperationFailureResponseErrorInfo {
 export declare interface DataConnectOptions extends ConnectorConfig {
     projectId: string;
 }
+/* Excluded from this release type: DataConnectResponse */
 /* Excluded from this release type: DataConnectResponseWithMaxAge */
 export declare interface DataConnectResult<Data, Variables> extends OpResult<Data> {
     ref: OperationRef<Data, Variables>;
@@ -124,7 +125,7 @@ export declare interface DataConnectSubscription<Data, Variables> {
     errCallback?: (e?: DataConnectError) => void;
     unsubscribe: () => void;
 }
-/* Excluded from this release type: DataConnectTransport */
+/* Excluded from this release type: DataConnectTransportInterface */
 export declare type DataSource = typeof SOURCE_CACHE | typeof SOURCE_SERVER;
 /**
  * Execute Mutation
@@ -319,6 +320,7 @@ export declare function subscribe<Data, Variables>(queryRefOrSerializedResult: Q
  * @returns `SubscriptionOptions`
  */
 export declare function subscribe<Data, Variables>(queryRefOrSerializedResult: QueryRef<Data, Variables> | SerializedRef<Data, Variables>, onNext: OnResultSubscription<Data, Variables>, onError?: OnErrorSubscription, onComplete?: OnCompleteSubscription): QueryUnsubscribe;
+/* Excluded from this release type: SubscribeObserver */
 /**
  * Representation of full observer options in `subscribe`
  */

package/dist/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/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/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/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/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/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/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/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;
+}