@depup/firebase__remote-config 0.8.1-depup.0

package/dist/esm/src/client/caching_client.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @license
+ * Copyright 2019 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 { StorageCache } from '../storage/storage_cache';
+import { FetchResponse } from '../public_types';
+import { RemoteConfigFetchClient, FetchRequest } from './remote_config_fetch_client';
+import { Storage } from '../storage/storage';
+import { Logger } from '@firebase/logger';
+/**
+ * Implements the {@link RemoteConfigClient} abstraction with success response caching.
+ *
+ * <p>Comparable to the browser's Cache API for responses, but the Cache API requires a Service
+ * Worker, which requires HTTPS, which would significantly complicate SDK installation. Also, the
+ * Cache API doesn't support matching entries by time.
+ */
+export declare class CachingClient implements RemoteConfigFetchClient {
+    private readonly client;
+    private readonly storage;
+    private readonly storageCache;
+    private readonly logger;
+    constructor(client: RemoteConfigFetchClient, storage: Storage, storageCache: StorageCache, logger: Logger);
+    /**
+     * Returns true if the age of the cached fetched configs is less than or equal to
+     * {@link Settings#minimumFetchIntervalInSeconds}.
+     *
+     * <p>This is comparable to passing `headers = { 'Cache-Control': max-age <maxAge> }` to the
+     * native Fetch API.
+     *
+     * <p>Visible for testing.
+     */
+    isCachedDataFresh(cacheMaxAgeMillis: number, lastSuccessfulFetchTimestampMillis: number | undefined): boolean;
+    fetch(request: FetchRequest): Promise<FetchResponse>;
+}

package/dist/esm/src/client/eventEmitter.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2025 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.
+ */
+/**
+ * Base class to be used if you want to emit events. Call the constructor with
+ * the set of allowed event names.
+ */
+export declare abstract class EventEmitter {
+    private allowedEvents_;
+    private listeners_;
+    constructor(allowedEvents_: string[]);
+    /**
+     * To be overridden by derived classes in order to fire an initial event when
+     * somebody subscribes for data.
+     *
+     * @returns {Array.<*>} Array of parameters to trigger initial event with.
+     */
+    abstract getInitialEvent(eventType: string): unknown[];
+    /**
+     * To be called by derived classes to trigger events.
+     */
+    protected trigger(eventType: string, ...varArgs: unknown[]): void;
+    on(eventType: string, callback: (a: unknown) => void, context: unknown): void;
+    off(eventType: string, callback: (a: unknown) => void, context: unknown): void;
+    private validateEventType_;
+}

package/dist/esm/src/client/realtime_handler.d.ts

@@ -0,0 +1,141 @@
+/**
+ * @license
+ * Copyright 2025 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 { _FirebaseInstallationsInternal } from '@firebase/installations';
+import { Logger } from '@firebase/logger';
+import { ConfigUpdateObserver } from '../public_types';
+import { Storage } from '../storage/storage';
+import { StorageCache } from '../storage/storage_cache';
+import { CachingClient } from './caching_client';
+export declare class RealtimeHandler {
+    private readonly firebaseInstallations;
+    private readonly storage;
+    private readonly sdkVersion;
+    private readonly namespace;
+    private readonly projectId;
+    private readonly apiKey;
+    private readonly appId;
+    private readonly logger;
+    private readonly storageCache;
+    private readonly cachingClient;
+    constructor(firebaseInstallations: _FirebaseInstallationsInternal, storage: Storage, sdkVersion: string, namespace: string, projectId: string, apiKey: string, appId: string, logger: Logger, storageCache: StorageCache, cachingClient: CachingClient);
+    private observers;
+    private isConnectionActive;
+    private isRealtimeDisabled;
+    private controller?;
+    private reader;
+    private httpRetriesRemaining;
+    private isInBackground;
+    private readonly decoder;
+    private isClosingConnection;
+    private setRetriesRemaining;
+    private propagateError;
+    /**
+     * Increment the number of failed stream attempts, increase the backoff duration, set the backoff
+     * end time to "backoff duration" after `lastFailedStreamTime` and persist the new
+     * values to storage metadata.
+     */
+    private updateBackoffMetadataWithLastFailedStreamConnectionTime;
+    /**
+     * Increase the backoff duration with a new end time based on Retry Interval.
+     */
+    private updateBackoffMetadataWithRetryInterval;
+    /**
+     * HTTP status code that the Realtime client should retry on.
+     */
+    private isStatusCodeRetryable;
+    /**
+     * Closes the realtime HTTP connection.
+     * Note: This method is designed to be called only once at a time.
+     * If a call is already in progress, subsequent calls will be ignored.
+     */
+    private closeRealtimeHttpConnection;
+    private resetRealtimeBackoff;
+    private resetRetryCount;
+    /**
+     * Assembles the request headers and body and executes the fetch request to
+     * establish the real-time streaming connection. This is the "worker" method
+     * that performs the actual network communication.
+     */
+    private establishRealtimeConnection;
+    private getRealtimeUrl;
+    private createRealtimeConnection;
+    /**
+     * Retries HTTP stream connection asyncly in random time intervals.
+     */
+    private retryHttpConnectionWhenBackoffEnds;
+    private setIsHttpConnectionRunning;
+    /**
+     * Combines the check and set operations to prevent multiple asynchronous
+     * calls from redundantly starting an HTTP connection. This ensures that
+     * only one attempt is made at a time.
+     */
+    private checkAndSetHttpConnectionFlagIfNotRunning;
+    private fetchResponseIsUpToDate;
+    private parseAndValidateConfigUpdateMessage;
+    private isEventListenersEmpty;
+    private getRandomInt;
+    private executeAllListenerCallbacks;
+    /**
+     * Compares two configuration objects and returns a set of keys that have changed.
+     * A key is considered changed if it's new, removed, or has a different value.
+     */
+    private getChangedParams;
+    private fetchLatestConfig;
+    private autoFetch;
+    /**
+     * Processes a stream of real-time messages for configuration updates.
+     * This method reassembles fragmented messages, validates and parses the JSON,
+     * and automatically fetches a new config if a newer template version is available.
+     * It also handles server-specified retry intervals and propagates errors for
+     * invalid messages or when real-time updates are disabled.
+     */
+    private handleNotifications;
+    private listenForNotifications;
+    /**
+     * Open the real-time connection, begin listening for updates, and auto-fetch when an update is
+     * received.
+     *
+     * If the connection is successful, this method will block on its thread while it reads the
+     * chunk-encoded HTTP body. When the connection closes, it attempts to reestablish the stream.
+     */
+    private prepareAndBeginRealtimeHttpStream;
+    /**
+     * Checks whether connection can be made or not based on some conditions
+     * @returns booelean
+     */
+    private canEstablishStreamConnection;
+    private makeRealtimeHttpConnection;
+    private beginRealtime;
+    /**
+     * Adds an observer to the realtime updates.
+     * @param observer The observer to add.
+     */
+    addObserver(observer: ConfigUpdateObserver): void;
+    /**
+     * Removes an observer from the realtime updates.
+     * @param observer The observer to remove.
+     */
+    removeObserver(observer: ConfigUpdateObserver): void;
+    /**
+     * Handles changes to the application's visibility state, managing the real-time connection.
+     *
+     * When the application is moved to the background, this method closes the existing
+     * real-time connection to save resources. When the application returns to the
+     * foreground, it attempts to re-establish the connection.
+     */
+    private onVisibilityChange;
+}

package/dist/esm/src/client/remote_config_fetch_client.d.ts

@@ -0,0 +1,104 @@
+/**
+ * @license
+ * Copyright 2019 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 { CustomSignals, FetchResponse, FetchType } from '../public_types';
+/**
+ * Defines a client, as in https://en.wikipedia.org/wiki/Client%E2%80%93server_model, for the
+ * Remote Config server (https://firebase.google.com/docs/reference/remote-config/rest).
+ *
+ * <p>Abstracts throttle, response cache and network implementation details.
+ *
+ * <p>Modeled after the native {@link GlobalFetch} interface, which is relatively modern and
+ * convenient, but simplified for Remote Config's use case.
+ *
+ * Disambiguation: {@link GlobalFetch} interface and the Remote Config service define "fetch"
+ * methods. The RestClient uses the former to make HTTP calls. This interface abstracts the latter.
+ */
+export interface RemoteConfigFetchClient {
+    /**
+     * @throws if response status is not 200 or 304.
+     */
+    fetch(request: FetchRequest): Promise<FetchResponse>;
+}
+/**
+ * Shims a minimal AbortSignal.
+ *
+ * <p>AbortController's AbortSignal conveniently decouples fetch timeout logic from other aspects
+ * of networking, such as retries. Firebase doesn't use AbortController enough to justify a
+ * polyfill recommendation, like we do with the Fetch API, but this minimal shim can easily be
+ * swapped out if/when we do.
+ */
+export declare class RemoteConfigAbortSignal {
+    listeners: Array<() => void>;
+    addEventListener(listener: () => void): void;
+    abort(): void;
+}
+/**
+ * Defines per-request inputs for the Remote Config fetch request.
+ *
+ * <p>Modeled after the native {@link Request} interface, but simplified for Remote Config's
+ * use case.
+ */
+export interface FetchRequest {
+    /**
+     * Uses cached config if it is younger than this age.
+     *
+     * <p>Required because it's defined by settings, which always have a value.
+     *
+     * <p>Comparable to passing `headers = { 'Cache-Control': max-age <maxAge> }` to the native
+     * Fetch API.
+     */
+    cacheMaxAgeMillis: number;
+    /**
+     * An event bus for the signal to abort a request.
+     *
+     * <p>Required because all requests should be abortable.
+     *
+     * <p>Comparable to the native
+     * Fetch API's "signal" field on its request configuration object
+     * https://fetch.spec.whatwg.org/#dom-requestinit-signal.
+     *
+     * <p>Disambiguation: Remote Config commonly refers to API inputs as
+     * "signals". See the private ConfigFetchRequestBody interface for those:
+     * http://google3/firebase/remote_config/web/src/core/rest_client.ts?l=14&rcl=255515243.
+     */
+    signal: RemoteConfigAbortSignal;
+    /**
+     * The ETag header value from the last response.
+     *
+     * <p>Optional in case this is the first request.
+     *
+     * <p>Comparable to passing `headers = { 'If-None-Match': <eTag> }` to the native Fetch API.
+     */
+    eTag?: string;
+    /** The custom signals stored for the app instance.
+     *
+     * <p>Optional in case no custom signals are set for the instance.
+     */
+    customSignals?: CustomSignals;
+    /**
+     * The type of fetch to perform, such as a regular fetch or a real-time fetch.
+     *
+     * Optional as not all fetch requests need to be distinguished.
+     */
+    fetchType?: FetchType;
+    /**
+     * The number of fetch attempts made so far for this request.
+     *
+     * Optional as not all fetch requests are part of a retry series.
+     */
+    fetchAttempt?: number;
+}

package/dist/esm/src/client/rest_client.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * Copyright 2019 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 { FetchResponse } from '../public_types';
+import { RemoteConfigFetchClient, FetchRequest } from './remote_config_fetch_client';
+import { _FirebaseInstallationsInternal } from '@firebase/installations';
+/**
+ * Implements the Client abstraction for the Remote Config REST API.
+ */
+export declare class RestClient implements RemoteConfigFetchClient {
+    private readonly firebaseInstallations;
+    private readonly sdkVersion;
+    private readonly namespace;
+    private readonly projectId;
+    private readonly apiKey;
+    private readonly appId;
+    constructor(firebaseInstallations: _FirebaseInstallationsInternal, sdkVersion: string, namespace: string, projectId: string, apiKey: string, appId: string);
+    /**
+     * Fetches from the Remote Config REST API.
+     *
+     * @throws a {@link ErrorCode.FETCH_NETWORK} error if {@link GlobalFetch#fetch} can't
+     * connect to the network.
+     * @throws a {@link ErrorCode.FETCH_PARSE} error if {@link Response#json} can't parse the
+     * fetch response.
+     * @throws a {@link ErrorCode.FETCH_STATUS} error if the service returns an HTTP error status.
+     */
+    fetch(request: FetchRequest): Promise<FetchResponse>;
+}

package/dist/esm/src/client/retrying_client.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @license
+ * Copyright 2019 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 { FetchResponse } from '../public_types';
+import { RemoteConfigAbortSignal, RemoteConfigFetchClient, FetchRequest } from './remote_config_fetch_client';
+import { ThrottleMetadata, Storage } from '../storage/storage';
+/**
+ * Supports waiting on a backoff by:
+ *
+ * <ul>
+ *   <li>Promisifying setTimeout, so we can set a timeout in our Promise chain</li>
+ *   <li>Listening on a signal bus for abort events, just like the Fetch API</li>
+ *   <li>Failing in the same way the Fetch API fails, so timing out a live request and a throttled
+ *       request appear the same.</li>
+ * </ul>
+ *
+ * <p>Visible for testing.
+ */
+export declare function setAbortableTimeout(signal: RemoteConfigAbortSignal, throttleEndTimeMillis: number): Promise<void>;
+/**
+ * Decorates a Client with retry logic.
+ *
+ * <p>Comparable to CachingClient, but uses backoff logic instead of cache max age and doesn't cache
+ * responses (because the SDK has no use for error responses).
+ */
+export declare class RetryingClient implements RemoteConfigFetchClient {
+    private readonly client;
+    private readonly storage;
+    constructor(client: RemoteConfigFetchClient, storage: Storage);
+    fetch(request: FetchRequest): Promise<FetchResponse>;
+    /**
+     * A recursive helper for attempting a fetch request repeatedly.
+     *
+     * @throws any non-retriable errors.
+     */
+    attemptFetch(request: FetchRequest, { throttleEndTimeMillis, backoffCount }: ThrottleMetadata): Promise<FetchResponse>;
+}

package/dist/esm/src/client/visibility_monitor.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2025 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 { EventEmitter } from './eventEmitter';
+export declare class VisibilityMonitor extends EventEmitter {
+    private visible_;
+    static getInstance(): VisibilityMonitor;
+    constructor();
+    getInitialEvent(eventType: string): boolean[];
+}

package/dist/esm/src/constants.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @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.
+ */
+export declare const RC_COMPONENT_NAME = "remote-config";
+export declare const RC_CUSTOM_SIGNAL_MAX_ALLOWED_SIGNALS = 100;
+export declare const RC_CUSTOM_SIGNAL_KEY_MAX_LENGTH = 250;
+export declare const RC_CUSTOM_SIGNAL_VALUE_MAX_LENGTH = 500;

package/dist/esm/src/errors.d.ts

@@ -0,0 +1,87 @@
+/**
+ * @license
+ * Copyright 2019 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 { ErrorFactory } from '@firebase/util';
+export declare const enum ErrorCode {
+    ALREADY_INITIALIZED = "already-initialized",
+    REGISTRATION_WINDOW = "registration-window",
+    REGISTRATION_PROJECT_ID = "registration-project-id",
+    REGISTRATION_API_KEY = "registration-api-key",
+    REGISTRATION_APP_ID = "registration-app-id",
+    STORAGE_OPEN = "storage-open",
+    STORAGE_GET = "storage-get",
+    STORAGE_SET = "storage-set",
+    STORAGE_DELETE = "storage-delete",
+    FETCH_NETWORK = "fetch-client-network",
+    FETCH_TIMEOUT = "fetch-timeout",
+    FETCH_THROTTLE = "fetch-throttle",
+    FETCH_PARSE = "fetch-client-parse",
+    FETCH_STATUS = "fetch-status",
+    INDEXED_DB_UNAVAILABLE = "indexed-db-unavailable",
+    CUSTOM_SIGNAL_MAX_ALLOWED_SIGNALS = "custom-signal-max-allowed-signals",
+    CONFIG_UPDATE_STREAM_ERROR = "stream-error",
+    CONFIG_UPDATE_UNAVAILABLE = "realtime-unavailable",
+    CONFIG_UPDATE_MESSAGE_INVALID = "update-message-invalid",
+    CONFIG_UPDATE_NOT_FETCHED = "update-not-fetched",
+    ANALYTICS_UNAVAILABLE = "analytics-unavailable"
+}
+interface ErrorParams {
+    [ErrorCode.STORAGE_OPEN]: {
+        originalErrorMessage: string | undefined;
+    };
+    [ErrorCode.STORAGE_GET]: {
+        originalErrorMessage: string | undefined;
+    };
+    [ErrorCode.STORAGE_SET]: {
+        originalErrorMessage: string | undefined;
+    };
+    [ErrorCode.STORAGE_DELETE]: {
+        originalErrorMessage: string | undefined;
+    };
+    [ErrorCode.FETCH_NETWORK]: {
+        originalErrorMessage: string;
+    };
+    [ErrorCode.FETCH_THROTTLE]: {
+        throttleEndTimeMillis: number;
+    };
+    [ErrorCode.FETCH_PARSE]: {
+        originalErrorMessage: string;
+    };
+    [ErrorCode.FETCH_STATUS]: {
+        httpStatus: number;
+    };
+    [ErrorCode.CUSTOM_SIGNAL_MAX_ALLOWED_SIGNALS]: {
+        maxSignals: number;
+    };
+    [ErrorCode.CONFIG_UPDATE_STREAM_ERROR]: {
+        originalErrorMessage: string;
+    };
+    [ErrorCode.CONFIG_UPDATE_UNAVAILABLE]: {
+        originalErrorMessage: string;
+    };
+    [ErrorCode.CONFIG_UPDATE_MESSAGE_INVALID]: {
+        originalErrorMessage: string;
+    };
+    [ErrorCode.CONFIG_UPDATE_NOT_FETCHED]: {
+        originalErrorMessage: string;
+    };
+    [ErrorCode.ANALYTICS_UNAVAILABLE]: {
+        originalErrorMessage: string;
+    };
+}
+export declare const ERROR_FACTORY: ErrorFactory<ErrorCode, ErrorParams>;
+export declare function hasErrorCode(e: Error, errorCode: ErrorCode): boolean;
+export {};

package/dist/esm/src/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The Firebase Remote Config Web SDK.
+ * This SDK does not work in a Node.js environment.
+ *
+ * @packageDocumentation
+ */
+declare global {
+    interface Window {
+        FIREBASE_REMOTE_CONFIG_URL_BASE: string;
+    }
+}
+export * from './api';
+export * from './api2';
+export * from './public_types';

package/dist/esm/src/language.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright 2019 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.
+ */
+/**
+ * Attempts to get the most accurate browser language setting.
+ *
+ * <p>Adapted from getUserLanguage in packages/auth/src/utils.js for TypeScript.
+ *
+ * <p>Defers default language specification to server logic for consistency.
+ *
+ * @param navigatorLanguage Enables tests to override read-only {@link NavigatorLanguage}.
+ */
+export declare function getUserLanguage(navigatorLanguage?: NavigatorLanguage): string;