@firebase/data-connect 0.0.2-dataconnect-preview.877f8b7d0 → 0.0.3-canary.beaa4dffb

package/dist/index.esm5.js

@@ -5,7 +5,7 @@ import { FirebaseError } from '@firebase/util';
 import { Logger } from '@firebase/logger';
 
 var name = "@firebase/data-connect";
-var version = "0.0.2-dataconnect-preview.877f8b7d0";
+var version = "0.0.3-canary.beaa4dffb";
 
 /**
  * @license
@@ -33,6 +33,63 @@ function setSDKVersion(version) {
     SDK_VERSION = version;
 }
 
+/**
+ * @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.
+ */
+/**
+ * @internal
+ * Abstraction around AppCheck's token fetching capabilities.
+ */
+var AppCheckTokenProvider = /** @class */ (function () {
+    function AppCheckTokenProvider(appName_, appCheckProvider) {
+        var _this = this;
+        this.appName_ = appName_;
+        this.appCheckProvider = appCheckProvider;
+        this.appCheck = appCheckProvider === null || appCheckProvider === void 0 ? void 0 : appCheckProvider.getImmediate({ optional: true });
+        if (!this.appCheck) {
+            void (appCheckProvider === null || appCheckProvider === void 0 ? void 0 : appCheckProvider.get().then(function (appCheck) { return (_this.appCheck = appCheck); }).catch());
+        }
+    }
+    AppCheckTokenProvider.prototype.getToken = function (forceRefresh) {
+        var _this = this;
+        if (!this.appCheck) {
+            return new Promise(function (resolve, reject) {
+                // Support delayed initialization of FirebaseAppCheck. This allows our
+                // customers to initialize the RTDB SDK before initializing Firebase
+                // AppCheck and ensures that all requests are authenticated if a token
+                // becomes available before the timoeout below expires.
+                setTimeout(function () {
+                    if (_this.appCheck) {
+                        _this.getToken(forceRefresh).then(resolve, reject);
+                    }
+                    else {
+                        resolve(null);
+                    }
+                }, 0);
+            });
+        }
+        return this.appCheck.getToken(forceRefresh);
+    };
+    AppCheckTokenProvider.prototype.addTokenChangeListener = function (listener) {
+        var _a;
+        void ((_a = this.appCheckProvider) === null || _a === void 0 ? void 0 : _a.get().then(function (appCheck) { return appCheck.addTokenListener(listener); }));
+    };
+    return AppCheckTokenProvider;
+}());
+
 /**
  * @license
  * Copyright 2024 Google LLC
@@ -55,7 +112,8 @@ var Code = {
     NOT_INITIALIZED: 'not-initialized',
     NOT_SUPPORTED: 'not-supported',
     INVALID_ARGUMENT: 'invalid-argument',
-    PARTIAL_ERROR: 'partial-error'
+    PARTIAL_ERROR: 'partial-error',
+    UNAUTHORIZED: 'unauthorized'
 };
 /** An error returned by a DataConnect operation. */
 var DataConnectError = /** @class */ (function (_super) {
@@ -125,6 +183,7 @@ function logError(msg) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+// @internal
 var FirebaseAuthProvider = /** @class */ (function () {
     function FirebaseAuthProvider(_appName, _options, _authProvider) {
         var _this = this;
@@ -169,7 +228,8 @@ var FirebaseAuthProvider = /** @class */ (function () {
     FirebaseAuthProvider.prototype.removeTokenChangeListener = function (listener) {
         this._authProvider
             .get()
-            .then(function (auth) { return auth.removeAuthTokenListener(listener); });
+            .then(function (auth) { return auth.removeAuthTokenListener(listener); })
+            .catch(function (err) { return logError(err); });
     };
     return FirebaseAuthProvider;
 }());
@@ -412,7 +472,7 @@ function urlBuilder(projectConfig, transportOptions) {
         logError('Port type is of an invalid type');
         throw new DataConnectError(Code.INVALID_ARGUMENT, 'Incorrect type for port passed in!');
     }
-    return "".concat(baseUrl, "/v1alpha/projects/").concat(project, "/locations/").concat(location, "/services/").concat(service, "/connectors/").concat(connector);
+    return "".concat(baseUrl, "/v1beta/projects/").concat(project, "/locations/").concat(location, "/services/").concat(service, "/connectors/").concat(connector);
 }
 function addToken(url, apiKey) {
     if (!apiKey) {
@@ -440,18 +500,32 @@ function addToken(url, apiKey) {
  * limitations under the License.
  */
 var connectFetch = globalThis.fetch;
-function dcFetch(url, body, _a, accessToken) {
+function getGoogApiClientValue(_isUsingGen) {
+    var str = 'gl-js/ fire/' + SDK_VERSION;
+    if (_isUsingGen) {
+        str += ' web/gen';
+    }
+    return str;
+}
+function dcFetch(url, body, _a, appId, accessToken, appCheckToken, _isUsingGen) {
     var _this = this;
     var signal = _a.signal;
     if (!connectFetch) {
         throw new DataConnectError(Code.OTHER, 'No Fetch Implementation detected!');
     }
     var headers = {
-        'Content-Type': 'application/json'
+        'Content-Type': 'application/json',
+        'X-Goog-Api-Client': getGoogApiClientValue(_isUsingGen)
     };
     if (accessToken) {
         headers['X-Firebase-Auth-Token'] = accessToken;
     }
+    if (appId) {
+        headers['x-firebase-gmpid'] = appId;
+    }
+    if (appCheckToken) {
+        headers['X-Firebase-AppCheck'] = appCheckToken;
+    }
     var bodyStr = JSON.stringify(body);
     logDebug("Making request out to ".concat(url, " with body: ").concat(bodyStr));
     return connectFetch(url, {
@@ -459,11 +533,12 @@ function dcFetch(url, body, _a, accessToken) {
         method: 'POST',
         headers: headers,
         signal: signal
-    }).catch(function (err) {
-        throw new DataConnectError(Code.OTHER, "Failed to fetch: " + JSON.stringify(err));
+    })
+        .catch(function (err) {
+        throw new DataConnectError(Code.OTHER, 'Failed to fetch: ' + JSON.stringify(err));
     })
         .then(function (response) { return __awaiter(_this, void 0, void 0, function () {
-        var jsonResponse, e_1;
+        var jsonResponse, e_1, message;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
@@ -479,9 +554,13 @@ function dcFetch(url, body, _a, accessToken) {
                     e_1 = _a.sent();
                     throw new DataConnectError(Code.OTHER, JSON.stringify(e_1));
                 case 4:
+                    message = getMessage(jsonResponse);
                     if (response.status >= 400) {
                         logError('Error while performing request: ' + JSON.stringify(jsonResponse));
-                        throw new DataConnectError(Code.OTHER, JSON.stringify(jsonResponse));
+                        if (response.status === 401) {
+                            throw new DataConnectError(Code.UNAUTHORIZED, message);
+                        }
+                        throw new DataConnectError(Code.OTHER, message);
                     }
                     return [2 /*return*/, jsonResponse];
             }
@@ -495,6 +574,12 @@ function dcFetch(url, body, _a, accessToken) {
         }
         return res;
     });
+}
+function getMessage(obj) {
+    if ('message' in obj) {
+        return obj.message;
+    }
+    return JSON.stringify(obj);
 }
 
 /**
@@ -514,42 +599,48 @@ function dcFetch(url, body, _a, accessToken) {
  * limitations under the License.
  */
 var RESTTransport = /** @class */ (function () {
-    function RESTTransport(options, apiKey, authProvider, transportOptions) {
+    function RESTTransport(options, apiKey, appId, authProvider, appCheckProvider, transportOptions, _isUsingGen) {
+        if (_isUsingGen === void 0) { _isUsingGen = false; }
         var _this = this;
-        var _a;
+        var _a, _b;
         this.apiKey = apiKey;
+        this.appId = appId;
         this.authProvider = authProvider;
+        this.appCheckProvider = appCheckProvider;
+        this._isUsingGen = _isUsingGen;
         this._host = '';
         this._location = 'l';
         this._connectorName = '';
         this._secure = true;
         this._project = 'p';
         this._accessToken = null;
-        this._authInitialized = false;
+        this._appCheckToken = null;
+        this._lastToken = null;
         // TODO(mtewani): Update U to include shape of body defined in line 13.
         this.invokeQuery = function (queryName, body) {
             var abortController = new AbortController();
             // TODO(mtewani): Update to proper value
-            var withAuth = _this.getWithAuth().then(function () {
+            var withAuth = _this.withRetry(function () {
                 return dcFetch(addToken("".concat(_this.endpointUrl, ":executeQuery"), _this.apiKey), {
                     name: "projects/".concat(_this._project, "/locations/").concat(_this._location, "/services/").concat(_this._serviceName, "/connectors/").concat(_this._connectorName),
                     operationName: queryName,
                     variables: body
                 }, // TODO(mtewani): This is a patch, fix this.
-                abortController, _this._accessToken);
+                abortController, _this.appId, _this._accessToken, _this._appCheckToken, _this._isUsingGen);
             });
             return {
-                then: withAuth.then.bind(withAuth)
+                then: withAuth.then.bind(withAuth),
+                catch: withAuth.catch.bind(withAuth)
             };
         };
         this.invokeMutation = function (mutationName, body) {
             var abortController = new AbortController();
-            var taskResult = _this.getWithAuth().then(function () {
+            var taskResult = _this.withRetry(function () {
                 return dcFetch(addToken("".concat(_this.endpointUrl, ":executeMutation"), _this.apiKey), {
                     name: "projects/".concat(_this._project, "/locations/").concat(_this._location, "/services/").concat(_this._serviceName, "/connectors/").concat(_this._connectorName),
                     operationName: mutationName,
                     variables: body
-                }, abortController, _this._accessToken);
+                }, abortController, _this.appId, _this._accessToken, _this._appCheckToken, _this._isUsingGen);
             });
             return {
                 then: taskResult.then.bind(taskResult),
@@ -583,6 +674,11 @@ var RESTTransport = /** @class */ (function () {
             logDebug("New Token Available: ".concat(token));
             _this._accessToken = token;
         });
+        (_b = this.appCheckProvider) === null || _b === void 0 ? void 0 : _b.addTokenChangeListener(function (result) {
+            var token = result.token;
+            logDebug("New App Check Token Available: ".concat(token));
+            _this._appCheckToken = token;
+        });
     }
     Object.defineProperty(RESTTransport.prototype, "endpointUrl", {
         get: function () {
@@ -608,28 +704,69 @@ var RESTTransport = /** @class */ (function () {
     RESTTransport.prototype.onTokenChanged = function (newToken) {
         this._accessToken = newToken;
     };
-    RESTTransport.prototype.getWithAuth = function () {
-        var _this = this;
-        var starterPromise = new Promise(function (resolve) {
-            return resolve(_this._accessToken);
+    RESTTransport.prototype.getWithAuth = function (forceToken) {
+        var _a;
+        if (forceToken === void 0) { forceToken = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var starterPromise, _b;
+            var _this = this;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        starterPromise = new Promise(function (resolve) {
+                            return resolve(_this._accessToken);
+                        });
+                        if (!this.appCheckProvider) return [3 /*break*/, 2];
+                        _b = this;
+                        return [4 /*yield*/, this.appCheckProvider.getToken()];
+                    case 1:
+                        _b._appCheckToken = (_a = (_c.sent())) === null || _a === void 0 ? void 0 : _a.token;
+                        _c.label = 2;
+                    case 2:
+                        if (this.authProvider) {
+                            starterPromise = this.authProvider
+                                .getToken(/*forceToken=*/ forceToken)
+                                .then(function (data) {
+                                if (!data) {
+                                    return null;
+                                }
+                                _this._accessToken = data.accessToken;
+                                return _this._accessToken;
+                            });
+                        }
+                        else {
+                            starterPromise = new Promise(function (resolve) { return resolve(''); });
+                        }
+                        return [2 /*return*/, starterPromise];
+                }
+            });
         });
-        if (!this._authInitialized) {
-            if (this.authProvider) {
-                starterPromise = this.authProvider
-                    .getToken(/*forceToken=*/ false)
-                    .then(function (data) {
-                    if (!data) {
-                        return null;
-                    }
-                    _this._accessToken = data.accessToken;
-                    return _this._accessToken;
-                });
-            }
-            else {
-                starterPromise = new Promise(function (resolve) { return resolve(''); });
+    };
+    RESTTransport.prototype._setLastToken = function (lastToken) {
+        this._lastToken = lastToken;
+    };
+    RESTTransport.prototype.withRetry = function (promiseFactory, retry) {
+        var _this = this;
+        if (retry === void 0) { retry = false; }
+        var isNewToken = false;
+        return this.getWithAuth(retry)
+            .then(function (res) {
+            isNewToken = _this._lastToken !== res;
+            _this._lastToken = res;
+            return res;
+        })
+            .then(promiseFactory)
+            .catch(function (err) {
+            // Only retry if the result is unauthorized and the last token isn't the same as the new one.
+            if ('code' in err &&
+                err.code === Code.UNAUTHORIZED &&
+                !retry &&
+                isNewToken) {
+                logDebug('Retrying due to unauthorized');
+                return _this.withRetry(promiseFactory, true);
             }
-        }
-        return starterPromise;
+            throw err;
+        });
     };
     return RESTTransport;
 }());
@@ -650,16 +787,26 @@ var RESTTransport = /** @class */ (function () {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-function mutationRef(dcInstance, queryName, variables) {
+/**
+ *
+ * @param dcInstance Data Connect instance
+ * @param mutationName name of mutation
+ * @param variables variables to send with mutation
+ * @returns `MutationRef`
+ */
+function mutationRef(dcInstance, mutationName, variables) {
     dcInstance.setInitialized();
     var ref = {
         dataConnect: dcInstance,
-        name: queryName,
+        name: mutationName,
         refType: MUTATION_STR,
         variables: variables
     };
     return ref;
 }
+/**
+ * @internal
+ */
 var MutationManager = /** @class */ (function () {
     function MutationManager(_transport) {
         this._transport = _transport;
@@ -681,6 +828,11 @@ var MutationManager = /** @class */ (function () {
     };
     return MutationManager;
 }());
+/**
+ * Execute Mutation
+ * @param mutationRef mutation to execute
+ * @returns `MutationRef`
+ */
 function executeMutation(mutationRef) {
     return mutationRef.dataConnect._mutationManager.executeMutation(mutationRef);
 }
@@ -715,15 +867,21 @@ function parseOptions(fullHost) {
     var port = Number(portAsString);
     return { host: host, port: port, sslEnabled: isSecure };
 }
+/**
+ * Class representing Firebase Data Connect
+ */
 var DataConnect = /** @class */ (function () {
+    // @internal
     function DataConnect(app, 
     // TODO(mtewani): Replace with _dataConnectOptions in the future
-    dataConnectOptions, _authProvider) {
+    dataConnectOptions, _authProvider, _appCheckProvider) {
         this.app = app;
         this.dataConnectOptions = dataConnectOptions;
         this._authProvider = _authProvider;
+        this._appCheckProvider = _appCheckProvider;
         this.isEmulator = false;
-        this.initialized = false;
+        this._initialized = false;
+        this._isUsingGeneratedSdk = false;
         if (typeof process !== 'undefined' && process.env) {
             var host = process.env[FIREBASE_DATA_CONNECT_EMULATOR_HOST_VAR];
             if (host) {
@@ -733,17 +891,25 @@ var DataConnect = /** @class */ (function () {
             }
         }
     }
+    // @internal
+    DataConnect.prototype._useGeneratedSdk = function () {
+        if (!this._isUsingGeneratedSdk) {
+            this._isUsingGeneratedSdk = true;
+        }
+    };
     DataConnect.prototype._delete = function () {
         _removeServiceInstance(this.app, 'data-connect', JSON.stringify(this.getSettings()));
         return Promise.resolve();
     };
+    // @internal
     DataConnect.prototype.getSettings = function () {
         var copy = JSON.parse(JSON.stringify(this.dataConnectOptions));
         delete copy.projectId;
         return copy;
     };
+    // @internal
     DataConnect.prototype.setInitialized = function () {
-        if (this.initialized) {
+        if (this._initialized) {
             return;
         }
         if (this._transportClass === undefined) {
@@ -753,16 +919,20 @@ var DataConnect = /** @class */ (function () {
         if (this._authProvider) {
             this._authTokenProvider = new FirebaseAuthProvider(this.app.name, this.app.options, this._authProvider);
         }
-        this.initialized = true;
-        this._transport = new this._transportClass(this.dataConnectOptions, this.app.options.apiKey, this._authTokenProvider);
+        if (this._appCheckProvider) {
+            this._appCheckTokenProvider = new AppCheckTokenProvider(this.app.name, this._appCheckProvider);
+        }
+        this._initialized = true;
+        this._transport = new this._transportClass(this.dataConnectOptions, this.app.options.apiKey, this.app.options.appId, this._authTokenProvider, this._appCheckTokenProvider, undefined, this._isUsingGeneratedSdk);
         if (this._transportOptions) {
             this._transport.useEmulator(this._transportOptions.host, this._transportOptions.port, this._transportOptions.sslEnabled);
         }
         this._queryManager = new QueryManager(this._transport);
         this._mutationManager = new MutationManager(this._transport);
     };
+    // @internal
     DataConnect.prototype.enableEmulator = function (transportOptions) {
-        if (this.initialized) {
+        if (this._initialized) {
             logError('enableEmulator called after initialization');
             throw new DataConnectError(Code.ALREADY_INITIALIZED, 'DataConnect instance already initialized!');
         }
@@ -771,6 +941,13 @@ var DataConnect = /** @class */ (function () {
     };
     return DataConnect;
 }());
+/**
+ * Connect to the DataConnect Emulator
+ * @param dc Data Connect instance
+ * @param host host of emulator server
+ * @param port port of emulator server
+ * @param sslEnabled use https
+ */
 function connectDataConnectEmulator(dc, host, port, sslEnabled) {
     if (sslEnabled === void 0) { sslEnabled = false; }
     dc.enableEmulator({ host: host, port: port, sslEnabled: sslEnabled });
@@ -786,7 +963,7 @@ function getDataConnect(appOrOptions, optionalOptions) {
         dcOptions = optionalOptions;
         app = appOrOptions;
     }
-    if (!app) {
+    if (!app || Object.keys(app).length === 0) {
         app = getApp();
     }
     var provider = _getProvider(app, 'data-connect');
@@ -800,9 +977,7 @@ function getDataConnect(appOrOptions, optionalOptions) {
             return dcInstance;
         }
     }
-    if (!dcOptions) {
-        throw new DataConnectError(Code.INVALID_ARGUMENT, 'DC Option Required');
-    }
+    validateDCOptions(dcOptions);
     logDebug('Creating new DataConnect instance');
     // Initialize with options.
     return provider.initialize({
@@ -810,6 +985,29 @@ function getDataConnect(appOrOptions, optionalOptions) {
         options: dcOptions
     });
 }
+/**
+ *
+ * @param dcOptions
+ * @returns {void}
+ * @internal
+ */
+function validateDCOptions(dcOptions) {
+    var fields = ['connector', 'location', 'service'];
+    if (!dcOptions) {
+        throw new DataConnectError(Code.INVALID_ARGUMENT, 'DC Option Required');
+    }
+    fields.forEach(function (field) {
+        if (dcOptions[field] === null || dcOptions[field] === undefined) {
+            throw new DataConnectError(Code.INVALID_ARGUMENT, "".concat(field, " Required"));
+        }
+    });
+    return true;
+}
+/**
+ * Delete DataConnect instance
+ * @param dataConnect DataConnect instance
+ * @returns
+ */
 function terminate(dataConnect) {
     return dataConnect._delete();
     // TODO(mtewani): Stop pending tasks
@@ -821,11 +1019,15 @@ function registerDataConnect(variant) {
         var settings = _a.instanceIdentifier, options = _a.options;
         var app = container.getProvider('app').getImmediate();
         var authProvider = container.getProvider('auth-internal');
+        var appCheckProvider = container.getProvider('app-check-internal');
         var newOpts = options;
         if (settings) {
             newOpts = JSON.parse(settings);
         }
-        return new DataConnect(app, __assign(__assign({}, newOpts), { projectId: app.options.projectId }), authProvider);
+        if (!app.options.projectId) {
+            throw new DataConnectError(Code.INVALID_ARGUMENT, 'Project ID must be provided. Did you pass in a proper projectId to initializeApp?');
+        }
+        return new DataConnect(app, __assign(__assign({}, newOpts), { projectId: app.options.projectId }), authProvider, appCheckProvider);
     }, "PUBLIC" /* ComponentType.PUBLIC */).setMultipleInstances(true));
     registerVersion(name, version, variant);
     // BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation
@@ -848,9 +1050,22 @@ function registerDataConnect(variant) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+/**
+ * Execute Query
+ * @param queryRef query to execute.
+ * @returns `QueryPromise`
+ */
 function executeQuery(queryRef) {
     return queryRef.dataConnect._queryManager.executeQuery(queryRef);
 }
+/**
+ * Execute Query
+ * @param dcInstance Data Connect instance to use.
+ * @param queryName Query to execute
+ * @param variables Variables to execute with
+ * @param initialCache initial cache to use for client hydration
+ * @returns `QueryRef`
+ */
 function queryRef(dcInstance, queryName, variables, initialCache) {
     dcInstance.setInitialized();
     dcInstance._queryManager.track(queryName, variables, initialCache);
@@ -861,6 +1076,11 @@ function queryRef(dcInstance, queryName, variables, initialCache) {
         variables: variables
     };
 }
+/**
+ * Converts serialized ref to query ref
+ * @param serializedRef ref to convert to `QueryRef`
+ * @returns `QueryRef`
+ */
 function toQueryRef(serializedRef) {
     var _a = serializedRef.refInfo, name = _a.name, variables = _a.variables, connectorConfig = _a.connectorConfig;
     return queryRef(getDataConnect(connectorConfig), name, variables);
@@ -882,6 +1102,57 @@ function toQueryRef(serializedRef) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+/**
+ * The generated SDK will allow the user to pass in either the variable or the data connect instance with the variable,
+ * and this function validates the variables and returns back the DataConnect instance and variables based on the arguments passed in.
+ * @param connectorConfig
+ * @param dcOrVars
+ * @param vars
+ * @param validateVars
+ * @returns {DataConnect} and {Variables} instance
+ * @internal
+ */
+function validateArgs(connectorConfig, dcOrVars, vars, validateVars) {
+    var dcInstance;
+    var realVars;
+    if (dcOrVars && 'enableEmulator' in dcOrVars) {
+        dcInstance = dcOrVars;
+        realVars = vars;
+    }
+    else {
+        dcInstance = getDataConnect(connectorConfig);
+        realVars = dcOrVars;
+    }
+    if (!dcInstance || (!realVars && validateVars)) {
+        throw new DataConnectError(Code.INVALID_ARGUMENT, 'Variables required.');
+    }
+    return { dc: dcInstance, vars: realVars };
+}
+
+/**
+ * @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.
+ */
+/**
+ * Subscribe to a `QueryRef`
+ * @param queryRefOrSerializedResult query ref or serialized result.
+ * @param observerOrOnNext observer object or next function.
+ * @param onError Callback to call when error gets thrown.
+ * @param onComplete Called when subscription completes.
+ * @returns `SubscriptionOptions`
+ */
 function subscribe(queryRefOrSerializedResult, observerOrOnNext, onError, onComplete) {
     var ref;
     var initialCache;
@@ -920,5 +1191,5 @@ function subscribe(queryRefOrSerializedResult, observerOrOnNext, onError, onComp
  */
 registerDataConnect();
 
-export { DataConnect, FIREBASE_DATA_CONNECT_EMULATOR_HOST_VAR, FirebaseAuthProvider, MUTATION_STR, MutationManager, QUERY_STR, SOURCE_CACHE, SOURCE_SERVER, connectDataConnectEmulator, executeMutation, executeQuery, getDataConnect, mutationRef, parseOptions, queryRef, setLogLevel, subscribe, terminate, toQueryRef };
+export { DataConnect, MUTATION_STR, MutationManager, QUERY_STR, SOURCE_CACHE, SOURCE_SERVER, connectDataConnectEmulator, executeMutation, executeQuery, getDataConnect, mutationRef, parseOptions, queryRef, setLogLevel, subscribe, terminate, toQueryRef, validateArgs, validateDCOptions };
 //# sourceMappingURL=index.esm5.js.map