@neurosity/sdk 6.2.1-next.1 → 6.2.1-next.2

package/dist/api/bluetooth/BluetoothClient.d.ts

@@ -0,0 +1,72 @@
+import { Observable } from "rxjs";
+import { ReplaySubject } from "rxjs";
+import { WebBluetoothTransport } from "./web/WebBluetoothTransport";
+import { ReactNativeTransport } from "./react-native/ReactNativeTransport";
+import { DeviceInfo } from "../../types/deviceInfo";
+import { Action } from "../../types/actions";
+import { Epoch } from "../../types/epoch";
+import { BLUETOOTH_CONNECTION } from "./types";
+import { DeviceNicknameOrPeripheral } from "./BluetoothTransport";
+import { Peripheral } from "./react-native/types/BleManagerTypes";
+export type BluetoothTransport = WebBluetoothTransport | ReactNativeTransport;
+type IsAuthenticated = boolean;
+type ExpiresIn = number;
+type IsAuthenticatedResponse = [IsAuthenticated, ExpiresIn];
+type CreateBluetoothToken = () => Promise<string>;
+type Options = {
+    transport: BluetoothTransport;
+    selectedDevice$: Observable<DeviceInfo>;
+    createBluetoothToken: CreateBluetoothToken;
+};
+export declare class BluetoothClient {
+    transport: BluetoothTransport;
+    deviceInfo: DeviceInfo;
+    selectedDevice$: ReplaySubject<DeviceInfo>;
+    isAuthenticated$: ReplaySubject<boolean>;
+    _focus$: Observable<any>;
+    _calm$: Observable<any>;
+    _accelerometer$: Observable<any>;
+    _brainwavesRaw$: Observable<any>;
+    _brainwavesRawUnfiltered$: Observable<any>;
+    _brainwavesPSD$: Observable<any>;
+    _brainwavesPowerByBand$: Observable<any>;
+    _signalQuality$: Observable<any>;
+    _status$: Observable<any>;
+    _settings$: Observable<any>;
+    _wifiNearbyNetworks$: Observable<any>;
+    _wifiConnections$: Observable<any>;
+    constructor(options: Options);
+    _autoAuthenticate(createBluetoothToken: CreateBluetoothToken): Observable<IsAuthenticatedResponse>;
+    enableAutoConnect(autoConnect: boolean): void;
+    _hasBluetoothSupport(): Promise<boolean>;
+    authenticate(token: string): Promise<IsAuthenticatedResponse>;
+    isAuthenticated(): Promise<IsAuthenticatedResponse>;
+    scan(options?: any): Observable<Peripheral[]>;
+    connect(deviceNicknameORPeripheral?: DeviceNicknameOrPeripheral): Promise<void>;
+    disconnect(): Promise<void>;
+    connection(): Observable<BLUETOOTH_CONNECTION>;
+    logs(): Observable<string>;
+    getDeviceId(): Promise<string>;
+    _withAuthentication<T>(getter: () => Promise<T>): Promise<T>;
+    _subscribeWhileAuthenticated(characteristicName: string): Observable<any>;
+    focus(): Observable<any>;
+    calm(): Observable<any>;
+    accelerometer(): Observable<any>;
+    brainwaves(label: string): Observable<Epoch | any>;
+    signalQuality(): Observable<any>;
+    addMarker(label: string): Promise<void>;
+    getInfo(): Promise<DeviceInfo>;
+    status(): Observable<any>;
+    dispatchAction(action: Action): Promise<any>;
+    settings(): Observable<any>;
+    haptics(effects: any): Promise<any>;
+    get wifi(): {
+        nearbyNetworks: () => Observable<any>;
+        connections: () => Observable<any>;
+        connect: (ssid: string, password?: string) => Promise<any>;
+        forgetConnection: (ssid: string) => Promise<any>;
+        reset: () => Promise<any>;
+        speedTest: () => Promise<any>;
+    };
+}
+export {};

package/dist/api/bluetooth/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const ANDROID_MAX_MTU: number;
+export declare const REACT_NATIVE_MAX_BYTE_SIZE: number;
+export declare const DEFAULT_ACTION_RESPONSE_TIMEOUT: number;
+export declare const CHARACTERISTIC_UUIDS_TO_NAMES: any;

package/dist/api/bluetooth/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./BluetoothClient";
+export * from "./web/WebBluetoothTransport";
+export * from "./react-native/ReactNativeTransport";
+export * from "./utils/osHasBluetoothSupport";
+export * from "./types/index";

package/dist/api/bluetooth/react-native/ReactNativeTransport.d.ts

@@ -0,0 +1,70 @@
+import { BehaviorSubject, ReplaySubject } from "rxjs";
+import { Observable } from "rxjs";
+import { BluetoothTransport } from "../BluetoothTransport";
+import { ActionOptions, SubscribeOptions } from "../types";
+import { TRANSPORT_TYPE, BLUETOOTH_CONNECTION } from "../types";
+import { BleManager } from "./types/BleManagerTypes";
+import { Peripheral } from "./types/BleManagerTypes";
+import { NativeEventEmitter } from "./types/ReactNativeTypes";
+import { PlatformOSType } from "./types/ReactNativeTypes";
+import { DeviceInfo } from "../../../types/deviceInfo";
+type Characteristic = {
+    characteristicUUID: string;
+    serviceUUID: string;
+    peripheralId: string;
+};
+type CharacteristicsByName = {
+    [name: string]: Characteristic;
+};
+type Options = {
+    BleManager: BleManager;
+    bleManagerEmitter: NativeEventEmitter;
+    platform: PlatformOSType;
+    autoConnect?: boolean;
+};
+type BleManagerEvents = {
+    stopScan$: Observable<void>;
+    discoverPeripheral$: Observable<Peripheral>;
+    connectPeripheral$: Observable<void>;
+    disconnectPeripheral$: Observable<void>;
+    didUpdateValueForCharacteristic$: Observable<any>;
+    didUpdateState$: Observable<any>;
+};
+export declare class ReactNativeTransport implements BluetoothTransport {
+    type: TRANSPORT_TYPE;
+    options: Options;
+    BleManager: BleManager;
+    bleManagerEmitter: NativeEventEmitter;
+    platform: PlatformOSType;
+    bleEvents: BleManagerEvents;
+    device: Peripheral;
+    characteristicsByName: CharacteristicsByName;
+    connection$: BehaviorSubject<BLUETOOTH_CONNECTION>;
+    pendingActions$: BehaviorSubject<any[]>;
+    logs$: ReplaySubject<string>;
+    onDisconnected$: Observable<void>;
+    connectionStream$: Observable<BLUETOOTH_CONNECTION>;
+    _isAutoConnectEnabled$: ReplaySubject<boolean>;
+    constructor(options: Options);
+    addLog(log: string): void;
+    isConnected(): boolean;
+    _autoConnect(selectedDevice$: Observable<DeviceInfo>): Observable<void>;
+    enableAutoConnect(autoConnect: boolean): void;
+    connection(): Observable<BLUETOOTH_CONNECTION>;
+    _fromEvent(eventName: string): Observable<any>;
+    scan(options?: {
+        seconds?: number;
+        once?: boolean;
+    }): Observable<Peripheral[]>;
+    connect(peripheral: Peripheral): Promise<void>;
+    disconnect(): Promise<void>;
+    getCharacteristicByName(characteristicName: string): Characteristic;
+    subscribeToCharacteristic({ characteristicName, manageNotifications }: SubscribeOptions): Observable<any>;
+    readCharacteristic(characteristicName: string, parse?: boolean): Promise<any>;
+    writeCharacteristic(characteristicName: string, data: string): Promise<void>;
+    _addPendingAction(actionId: number): void;
+    _removePendingAction(actionId: number): void;
+    _autoToggleActionNotifications(selectedDevice$: Observable<DeviceInfo>): Promise<void>;
+    dispatchAction({ characteristicName, action }: ActionOptions): Promise<any>;
+}
+export {};

package/dist/api/bluetooth/types/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @hidden
+ */
+export type ActionOptions = {
+    characteristicName: string;
+    action: any;
+};
+/**
+ * @hidden
+ */
+export type SubscribeOptions = {
+    characteristicName: string;
+    manageNotifications?: boolean;
+};
+/**
+ * @hidden
+ */
+export declare enum BLUETOOTH_CONNECTION {
+    SCANNING = "scanning",
+    CONNECTED = "connected",
+    CONNECTING = "connecting",
+    DISCONNECTING = "disconnecting",
+    DISCONNECTED = "disconnected"
+}
+/**
+ * @hidden
+ */
+export declare enum TRANSPORT_TYPE {
+    WEB = "web",
+    REACT_NATIVE = "reactNative"
+}

package/dist/api/bluetooth/utils/create6DigitPin.d.ts

@@ -0,0 +1 @@
+export declare function create6DigitPin(): number;

package/dist/api/bluetooth/utils/csvBufferToEpoch.d.ts

@@ -0,0 +1,11 @@
+import { Observable, UnaryFunction } from "rxjs";
+import { Epoch } from "../../../types/epoch";
+import { DeviceInfo } from "../../../types/deviceInfo";
+/**
+ * @hidden
+ */
+export declare function csvBufferToEpoch(deviceInfo: DeviceInfo): UnaryFunction<Observable<Epoch>, any>;
+/**
+ * @hidden
+ */
+export declare function csvBufferToSamples(): UnaryFunction<any, any>;

package/dist/api/bluetooth/utils/encoding.d.ts

@@ -0,0 +1,3 @@
+import { TRANSPORT_TYPE } from "../types";
+export declare function encode(transportType: TRANSPORT_TYPE, data: string): Uint8Array | number[];
+export declare function decode(transportType: TRANSPORT_TYPE, data: Uint8Array | number[]): string;

package/dist/api/bluetooth/utils/osHasBluetoothSupport.d.ts

@@ -0,0 +1,2 @@
+import { DeviceInfo } from "../../../types/deviceInfo";
+export declare function osHasBluetoothSupport(selectedDevice: DeviceInfo): any;

package/dist/api/bluetooth/utils/stitch.d.ts

@@ -0,0 +1,5 @@
+type StitchChunkOptions = {
+    delimiter: string;
+};
+export declare function stitchChunks({ delimiter }: StitchChunkOptions): import("rxjs").UnaryFunction<import("rxjs").Observable<string>, import("rxjs").Observable<string>>;
+export {};

package/dist/api/bluetooth/web/WebBluetoothTransport.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="web-bluetooth" />
+import { BehaviorSubject, ReplaySubject } from "rxjs";
+import { Observable } from "rxjs";
+import { BluetoothTransport } from "../BluetoothTransport";
+import { ActionOptions, SubscribeOptions } from "../types";
+import { TRANSPORT_TYPE, BLUETOOTH_CONNECTION } from "../types";
+import { DeviceInfo } from "../../../types/deviceInfo";
+type Options = {
+    autoConnect?: boolean;
+};
+export declare class WebBluetoothTransport implements BluetoothTransport {
+    type: TRANSPORT_TYPE;
+    options: Options;
+    device: BluetoothDevice;
+    server: BluetoothRemoteGATTServer;
+    service: BluetoothRemoteGATTService;
+    characteristicsByName: {
+        [name: string]: BluetoothRemoteGATTCharacteristic;
+    };
+    connection$: BehaviorSubject<BLUETOOTH_CONNECTION>;
+    pendingActions$: BehaviorSubject<any[]>;
+    logs$: ReplaySubject<string>;
+    onDisconnected$: Observable<void>;
+    connectionStream$: Observable<BLUETOOTH_CONNECTION>;
+    _isAutoConnectEnabled$: ReplaySubject<boolean>;
+    constructor(options?: Options);
+    _getPairedDevices(): Promise<BluetoothDevice[]>;
+    _autoConnect(selectedDevice$: Observable<DeviceInfo>): Observable<void>;
+    enableAutoConnect(autoConnect: boolean): void;
+    addLog(log: string): void;
+    isConnected(): boolean;
+    connection(): Observable<BLUETOOTH_CONNECTION>;
+    connect(deviceNickname?: string): Promise<void>;
+    requestDevice(deviceNickname?: string): Promise<BluetoothDevice>;
+    getServerServiceAndCharacteristics(device: BluetoothDevice): Promise<never>;
+    _onDisconnected(): Observable<any>;
+    disconnect(): Promise<void>;
+    /**
+     *
+     * Bluetooth GATT attributes, services, characteristics, etc. are invalidated
+     * when a device disconnects. This means your code should always retrieve
+     * (through getPrimaryService(s), getCharacteristic(s), etc.) these attributes
+     * after reconnecting.
+     */
+    getCharacteristicByName(characteristicName: string): Promise<BluetoothRemoteGATTCharacteristic>;
+    subscribeToCharacteristic({ characteristicName, manageNotifications }: SubscribeOptions): Observable<any>;
+    readCharacteristic(characteristicName: string, parse?: boolean): Promise<any>;
+    writeCharacteristic(characteristicName: string, data: string): Promise<void>;
+    _addPendingAction(actionId: number): void;
+    _removePendingAction(actionId: number): void;
+    _autoToggleActionNotifications(selectedDevice$: Observable<DeviceInfo>): Promise<void>;
+    dispatchAction({ characteristicName, action }: ActionOptions): Promise<any>;
+}
+export {};

package/dist/api/bluetooth/web/isMaybeWebWorkerContext.d.ts

@@ -0,0 +1 @@
+export declare const isMaybeWebWorkerContext: () => boolean;

package/dist/api/bluetooth/web/isWebBluetoothSupported.d.ts

@@ -0,0 +1 @@
+export declare function isWebBluetoothSupported(): boolean;

package/dist/api/firebase/FirebaseApp.d.ts

@@ -0,0 +1,20 @@
+import firebase from "firebase/app";
+import "firebase/database";
+import "firebase/auth";
+import "firebase/functions";
+import "firebase/firestore";
+import { SDKOptions } from "../../types/options";
+export declare const SERVER_TIMESTAMP: Object;
+/**
+ * @hidden
+ */
+export declare class FirebaseApp {
+    protected standalone: boolean;
+    app: firebase.app.App;
+    constructor(options: SDKOptions);
+    private getApp;
+    connectEmulators(options: SDKOptions): void;
+    goOnline(): void;
+    goOffline(): void;
+    disconnect(): Promise<any>;
+}

package/dist/api/firebase/FirebaseDevice.d.ts

@@ -0,0 +1,68 @@
+import firebase from "firebase/app";
+import { FirebaseApp } from "./FirebaseApp";
+import { SDKDependencies } from "../../types/options";
+type FirebaseDeviceOptions = {
+    deviceId: string;
+    firebaseApp: FirebaseApp;
+    dependencies: SDKDependencies;
+};
+/**
+ * @hidden
+ */
+export declare class FirebaseDevice {
+    static serverType: string;
+    protected app: firebase.app.App;
+    protected deviceStore: any;
+    deviceId: string;
+    constructor({ deviceId, firebaseApp, dependencies }: FirebaseDeviceOptions);
+    get timestamp(): any;
+    dispatchAction(action: any): Promise<any>;
+    getInfo(): Promise<any>;
+    onNamespace(namespace: string, callback: Function): Function;
+    onceNamespace(namespace: string): Promise<any>;
+    offNamespace(namespace: string, listener: Function): void;
+    getTimesync(): Promise<number>;
+    /**
+     * Pushes metric for each subscriptions in path:
+     * /devices/:deviceId/metrics/:metricName
+     */
+    nextMetric(metricName: string, metricValue: {
+        [label: string]: any;
+    }): void;
+    /**
+     * Listens for metrics in path:
+     * /devices/:deviceId/metrics/:metricName
+     */
+    onMetric(subscription: any, callback: any): Function;
+    /**
+     * Creates a new and unique subscription in path:
+     * /devices/:deviceId/subscriptions/:subscriptionId
+     * E.g. /devices/device1/subscriptions/subscription3
+     *
+     * @param subscription
+     * @returns subscriptionId
+     */
+    subscribeToMetric(subscription: any): any;
+    /**
+     * Removes subscription in path:
+     * /devices/:deviceId/subscriptions/:subscriptionId
+     *
+     * @param subscription
+     */
+    unsubscribeFromMetric(subscription: any): void;
+    /**
+     * Removes metric listener
+     * /devices/:deviceId/metric
+     * or
+     * /devices/:deviceId/metric/label
+     *
+     * @param subscription
+     * @param listener
+     */
+    removeMetricListener(subscription: any, listener: Function): void;
+    changeSettings(settings: any): Promise<void>;
+    getSkill(bundleId: any): Promise<any>;
+    createBluetoothToken(): Promise<string>;
+    disconnect(): void;
+}
+export {};

package/dist/api/firebase/FirebaseUser.d.ts

@@ -0,0 +1,53 @@
+import { Observable } from "rxjs";
+import firebase from "firebase/app";
+import { User } from "@firebase/auth-types";
+import { FirebaseApp } from "./FirebaseApp";
+import { Credentials, EmailAndPassword, CustomToken } from "../../types/credentials";
+import { UserClaims } from "../../types/user";
+import { DeviceInfo } from "../../types/deviceInfo";
+import { OAuthRemoveResponse } from "../../types/oauth";
+import { Experiment } from "../../types/experiment";
+import { TransferDeviceOptions } from "../../utils/transferDevice";
+/**
+ * @hidden
+ */
+export declare const credentialWithLink: Function;
+/**
+ * @hidden
+ */
+export declare function createUser(...args: any[]): any;
+/**
+ * @hidden
+ */
+export declare class FirebaseUser {
+    app: firebase.app.App;
+    user: User | null;
+    constructor(firebaseApp: FirebaseApp);
+    auth(): firebase.auth.Auth;
+    createAccount(credentials: EmailAndPassword): Promise<any>;
+    deleteAccount(): Promise<void>;
+    onAuthStateChanged(): Observable<User | null>;
+    onLogin(): Observable<User>;
+    login(credentials: Credentials): Promise<firebase.auth.UserCredential>;
+    logout(): Promise<void>;
+    createCustomToken(): Promise<CustomToken>;
+    removeOAuthAccess(): Promise<OAuthRemoveResponse>;
+    getDevices(): Promise<DeviceInfo[]>;
+    addDevice(deviceId: string): Promise<void>;
+    removeDevice(deviceId: string): Promise<void>;
+    transferDevice(options: TransferDeviceOptions): Promise<void>;
+    isDeviceIdValid(deviceId: string): Promise<boolean>;
+    onUserDevicesChange(): Observable<DeviceInfo[]>;
+    onUserClaimsChange(): Observable<UserClaims>;
+    getIdToken(forceRefresh?: boolean): Promise<void>;
+    getClaims(): Promise<UserClaims>;
+    private userDevicesToDeviceInfoList;
+    hasDevicePermission(deviceId: string): Promise<boolean>;
+    private getDeviceClaimedByPath;
+    private getUserClaimedDevicePath;
+    private getUserDevicesPath;
+    private getUserClaimsUpdatedOnPath;
+    private getDeviceInfoPath;
+    onUserExperiments(): Observable<Experiment[]>;
+    deleteUserExperiment(experimentId: string): Promise<void>;
+}

package/dist/api/firebase/config.d.ts

@@ -0,0 +1,8 @@
+export declare const config: {
+    apiKey: string;
+    authDomain: string;
+    databaseURL: string;
+    projectId: string;
+    storageBucket: string;
+    messagingSenderId: string;
+};

package/dist/api/firebase/deviceStore.d.ts

@@ -0,0 +1,26 @@
+export interface IDevice {
+    info: any;
+    status: any;
+    subscriptions: any;
+    metrics: any;
+}
+/**
+ * @hidden
+ */
+export declare const createDeviceStore: (app: any, deviceId: any, subscriptionManager: any) => {
+    set: (namespace: any, payload: any) => any;
+    once: (namespace: any, eventType?: string) => Promise<any>;
+    update: (namespace: any, payload: any) => any;
+    lastOfChildValue: (namespace: any, key: any, value: any) => Promise<unknown>;
+    onNamespace: (namespace: string, callback: Function) => Function;
+    offNamespace: (namespace: string, listener: Function) => void;
+    dispatchAction: (action: any) => Promise<any>;
+    nextMetric: (metricName: string, metricValue: {
+        [label: string]: any;
+    }) => Promise<void>;
+    onMetric: (subscription: any, callback: Function) => any;
+    subscribeToMetric: (subscription: any) => any;
+    unsubscribeFromMetric: (subscription: any) => void;
+    removeMetricListener(subscription: any, listener: Function): void;
+    disconnect(): void;
+};

package/dist/api/firebase/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./FirebaseApp";
+export * from "./FirebaseUser";
+export * from "./FirebaseDevice";

package/dist/api/https/config.d.ts

@@ -0,0 +1 @@
+export declare const prodFunctionsBaseUrl = "https://us-central1-neurosity-device.cloudfunctions.net";

package/dist/api/https/createOAuthURL.d.ts

@@ -0,0 +1,3 @@
+import { SDKOptions } from "../../types/options";
+import { OAuthConfig } from "../../types/oauth";
+export declare function createOAuthURL(config: OAuthConfig, sdkOptions: SDKOptions): Promise<string>;

package/dist/api/https/getOAuthToken.d.ts

@@ -0,0 +1,3 @@
+import { SDKOptions } from "../../types/options";
+import { OAuthQuery, OAuthQueryResult } from "../../types/oauth";
+export declare function getOAuthToken(query: OAuthQuery, sdkOptions: SDKOptions): Promise<OAuthQueryResult>;

package/dist/api/https/utils.d.ts

@@ -0,0 +1,2 @@
+import { SDKOptions } from "../../types/options";
+export declare function getFunctionsBaseURL(sdkOptions: SDKOptions): string;

package/dist/api/index.d.ts

@@ -0,0 +1,117 @@
+import { Observable } from "rxjs";
+import { FirebaseApp, FirebaseUser, FirebaseDevice } from "./firebase";
+import { Timesync } from "../timesync";
+import { SubscriptionManager } from "../subscriptions/SubscriptionManager";
+import { Client } from "../types/client";
+import { Action, Actions } from "../types/actions";
+import { Metrics } from "../types/metrics";
+import { SDKOptions } from "../types/options";
+import { SkillsClient } from "../types/skill";
+import { Credentials, CustomToken } from "../types/credentials";
+import { EmailAndPassword } from "../types/credentials";
+import { ChangeSettings } from "../types/settings";
+import { DeviceStatus } from "../types/status";
+import { DeviceInfo, DeviceSelector } from "../types/deviceInfo";
+import { UserClaims } from "../types/user";
+import { OAuthRemoveResponse } from "../types/oauth";
+import { Experiment } from "../types/experiment";
+import { TransferDeviceOptions } from "../utils/transferDevice";
+export { credentialWithLink, createUser, SERVER_TIMESTAMP } from "./firebase";
+/**
+ * @hidden
+ */
+export declare class CloudClient implements Client {
+    user: any;
+    userClaims: any;
+    protected options: SDKOptions;
+    protected firebaseApp: FirebaseApp;
+    protected firebaseUser: FirebaseUser;
+    protected firebaseDevice: FirebaseDevice;
+    protected timesync: Timesync;
+    protected subscriptionManager: SubscriptionManager;
+    protected status$: Observable<DeviceStatus>;
+    /**
+     * @internal
+     */
+    private _selectedDevice;
+    constructor(options: SDKOptions);
+    onDeviceChange(): Observable<DeviceInfo>;
+    private setAutoSelectedDevice;
+    get actions(): Actions;
+    dispatchAction(action: Action): Promise<any>;
+    disconnect(): Promise<any>;
+    getInfo(): Promise<any>;
+    login(credentials: Credentials): Promise<any>;
+    logout(): Promise<any>;
+    onAuthStateChanged(): Observable<{
+        selectedDevice: DeviceInfo;
+        delete(): Promise<void>;
+        emailVerified: boolean;
+        getIdTokenResult(forceRefresh?: boolean): Promise<import("@firebase/auth-types").IdTokenResult>;
+        getIdToken(forceRefresh?: boolean): Promise<string>;
+        isAnonymous: boolean;
+        linkAndRetrieveDataWithCredential(credential: import("@firebase/auth-types").AuthCredential): Promise<import("@firebase/auth-types").UserCredential>;
+        linkWithCredential(credential: import("@firebase/auth-types").AuthCredential): Promise<import("@firebase/auth-types").UserCredential>;
+        linkWithPhoneNumber(phoneNumber: string, applicationVerifier: import("@firebase/auth-types").ApplicationVerifier): Promise<import("@firebase/auth-types").ConfirmationResult>;
+        linkWithPopup(provider: import("@firebase/auth-types").AuthProvider): Promise<import("@firebase/auth-types").UserCredential>;
+        linkWithRedirect(provider: import("@firebase/auth-types").AuthProvider): Promise<void>;
+        metadata: import("@firebase/auth-types").UserMetadata;
+        multiFactor: import("@firebase/auth-types").MultiFactorUser;
+        phoneNumber: string;
+        providerData: import("@firebase/auth-types").UserInfo[];
+        reauthenticateAndRetrieveDataWithCredential(credential: import("@firebase/auth-types").AuthCredential): Promise<import("@firebase/auth-types").UserCredential>;
+        reauthenticateWithCredential(credential: import("@firebase/auth-types").AuthCredential): Promise<import("@firebase/auth-types").UserCredential>;
+        reauthenticateWithPhoneNumber(phoneNumber: string, applicationVerifier: import("@firebase/auth-types").ApplicationVerifier): Promise<import("@firebase/auth-types").ConfirmationResult>;
+        reauthenticateWithPopup(provider: import("@firebase/auth-types").AuthProvider): Promise<import("@firebase/auth-types").UserCredential>;
+        reauthenticateWithRedirect(provider: import("@firebase/auth-types").AuthProvider): Promise<void>;
+        refreshToken: string;
+        reload(): Promise<void>;
+        sendEmailVerification(actionCodeSettings?: import("@firebase/auth-types").ActionCodeSettings): Promise<void>;
+        tenantId: string;
+        toJSON(): Object;
+        unlink(providerId: string): Promise<import("@firebase/auth-types").User>;
+        updateEmail(newEmail: string): Promise<void>;
+        updatePassword(newPassword: string): Promise<void>;
+        updatePhoneNumber(phoneCredential: import("@firebase/auth-types").AuthCredential): Promise<void>;
+        updateProfile(profile: {
+            displayName?: string;
+            photoURL?: string;
+        }): Promise<void>;
+        verifyBeforeUpdateEmail(newEmail: string, actionCodeSettings?: import("@firebase/auth-types").ActionCodeSettings): Promise<void>;
+        displayName: string;
+        email: string;
+        photoURL: string;
+        providerId: string;
+        uid: string;
+    }>;
+    getDevices(): Promise<DeviceInfo[]>;
+    addDevice(deviceId: string): Promise<void>;
+    removeDevice(deviceId: string): Promise<void>;
+    transferDevice(options: TransferDeviceOptions): Promise<void>;
+    onUserDevicesChange(): Observable<DeviceInfo[]>;
+    onUserClaimsChange(): Observable<UserClaims>;
+    didSelectDevice(): Promise<boolean>;
+    selectDevice(deviceSelector: DeviceSelector): Promise<DeviceInfo>;
+    getSelectedDevice(): Promise<DeviceInfo | null>;
+    status(): Observable<DeviceStatus>;
+    observeNamespace(namespace: string): Observable<any>;
+    onceNamespace(namespace: string): Promise<any>;
+    get metrics(): Metrics;
+    createAccount(credentials: EmailAndPassword): Promise<any>;
+    deleteAccount(): Promise<void>;
+    createBluetoothToken(): Promise<string>;
+    createCustomToken(): Promise<CustomToken>;
+    removeOAuthAccess(): Promise<OAuthRemoveResponse>;
+    onUserExperiments(): Observable<Experiment[]>;
+    deleteUserExperiment(experimentId: string): Promise<void>;
+    get skills(): SkillsClient;
+    get timestamp(): number;
+    getTimesyncOffset(): number;
+    changeSettings(settings: ChangeSettings): Promise<void>;
+    goOffline(): void;
+    goOnline(): void;
+    /**
+     * @internal
+     */
+    __getApp(): import("firebase").default.app.App;
+}