@neurosity/sdk 6.0.0-next.11

package/dist/esm/Notion.js

@@ -0,0 +1,1260 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { combineLatest, Observable, of, throwError } from "rxjs";
+import { ReplaySubject, firstValueFrom, EMPTY } from "rxjs";
+import { distinctUntilChanged, map, switchMap } from "rxjs/operators";
+import isEqual from "fast-deep-equal";
+import { CloudClient, createUser } from "./api/index";
+import { credentialWithLink, SERVER_TIMESTAMP } from "./api/index";
+import { STREAMING_MODE, STREAMING_TYPE } from "./types/streaming";
+import { getLabels } from "./utils/subscription";
+import { STATUS } from "./types/status";
+import * as errors from "./utils/errors";
+import * as platform from "./utils/platform";
+import * as hapticEffects from "./utils/hapticEffects";
+import { validateOAuthScopeForFunctionName } from "./utils/oauth";
+import { validateOAuthScopeForAction } from "./utils/oauth";
+import { createOAuthURL } from "./api/https/createOAuthURL";
+import { getOAuthToken } from "./api/https/getOAuthToken";
+import { isNode } from "./utils/is-node";
+import { getCloudMetric } from "./utils/metrics";
+import { BluetoothClient } from "./api/bluetooth";
+import { BLUETOOTH_CONNECTION } from "./api/bluetooth/types";
+const defaultOptions = {
+    timesync: false,
+    autoSelectDevice: true,
+    streamingMode: STREAMING_MODE.WIFI_ONLY,
+    emulator: false,
+    emulatorHost: "localhost",
+    emulatorAuthPort: 9099,
+    emulatorDatabasePort: 9000,
+    emulatorFunctionsPort: 5001,
+    emulatorFirestorePort: 8080,
+    emulatorOptions: {}
+};
+/**
+ * import StreamingModes from "@site/src/components/StreamingModes";
+ *
+ * Example
+ * ```typescript
+ * import { Neurosity } from "@neurosity/sdk";
+ *
+ * const neurosity = new Neurosity();
+ * ```
+ */
+export class Neurosity {
+    /**
+     * Creates new instance of the Neurosity SDK
+     *
+     * ```typescript
+     * const neurosity = new Neurosity();
+     * ```
+  
+     * @param options
+     */
+    constructor(options = {}) {
+        /**
+         * @hidden
+         */
+        this.streamingMode$ = new ReplaySubject(1);
+        const { streamingMode, bluetoothTransport } = options;
+        this.options = Object.freeze(Object.assign(Object.assign({}, defaultOptions), options));
+        this.cloudClient = new CloudClient(this.options);
+        if (!!bluetoothTransport) {
+            this.bluetoothClient = new BluetoothClient({
+                selectedDevice$: this.onDeviceChange(),
+                createBluetoothToken: this.createBluetoothToken.bind(this),
+                transport: bluetoothTransport
+            });
+        }
+        this._initStreamingMode(streamingMode, !!bluetoothTransport);
+    }
+    /**
+     *
+     * @hidden
+     */
+    _initStreamingMode(streamingMode, hasBluetoothTransport) {
+        const streamingModeFeaturesBluetooth = [
+            STREAMING_MODE.BLUETOOTH_WITH_WIFI_FALLBACK,
+            STREAMING_MODE.WIFI_WITH_BLUETOOTH_FALLBACK
+        ].includes(streamingMode);
+        const isInvalidStreamingMode = !Object.values(STREAMING_MODE).includes(streamingMode);
+        const isMissingBluetoothTransport = streamingModeFeaturesBluetooth && !hasBluetoothTransport;
+        this.isMissingBluetoothTransport = isMissingBluetoothTransport;
+        const shouldDefaultToCloud = !streamingMode || isInvalidStreamingMode || isMissingBluetoothTransport;
+        // Default to backwards compatible cloud streaming mode if:
+        // 1. No streaming mode is provided
+        // 2. An invalid streaming mode is provided
+        // 3. A streaming mode containing bluetooth is provided, but without a bluetooth transport
+        if (shouldDefaultToCloud) {
+            this.streamingMode$.next(STREAMING_MODE.WIFI_ONLY);
+        }
+        else {
+            this.streamingMode$.next(streamingMode);
+        }
+    }
+    /**
+     * Subscribe to the device's streaming state changes and the current strategy
+     *
+     * Streams the current mode of streaming (wifi or bluetooth).
+     *
+     * ```typescript
+     * neurosity.streamingState().subscribe((streamingState) => {
+     *   console.log(streamingState);
+     *   // { streamingMode: "wifi-only", activeMode: "wifi", connected: true }
+     * });
+     * ```
+     */
+    streamingState() {
+        const isWifiOnline = (state) => [STATUS.ONLINE, STATUS.UPDATING].includes(state);
+        return this.streamingMode$.pipe(switchMap((streamingMode) => {
+            if (this.isMissingBluetoothTransport) {
+                return this.cloudClient.status().pipe(map(({ state }) => ({
+                    connected: isWifiOnline(state),
+                    streamingMode,
+                    activeMode: STREAMING_TYPE.WIFI
+                })));
+            }
+            return this.onDeviceChange().pipe(switchMap((selectDevice) => !selectDevice
+                ? EMPTY
+                : combineLatest({
+                    wifiStatus: this.cloudClient.status(),
+                    bluetoothConnection: !!(this === null || this === void 0 ? void 0 : this.bluetoothClient)
+                        ? this.bluetoothClient.connection()
+                        : of(BLUETOOTH_CONNECTION.DISCONNECTED)
+                }).pipe(map(({ wifiStatus, bluetoothConnection }) => {
+                    const isBluetoothConnected = bluetoothConnection === BLUETOOTH_CONNECTION.CONNECTED;
+                    switch (streamingMode) {
+                        default:
+                        case STREAMING_MODE.WIFI_ONLY:
+                            return {
+                                connected: isWifiOnline(wifiStatus.state),
+                                streamingMode,
+                                activeMode: STREAMING_TYPE.WIFI
+                            };
+                        case STREAMING_MODE.WIFI_WITH_BLUETOOTH_FALLBACK:
+                            return {
+                                connected: isWifiOnline(wifiStatus.state) ||
+                                    !isBluetoothConnected
+                                    ? isWifiOnline(wifiStatus.state)
+                                    : isBluetoothConnected,
+                                streamingMode,
+                                activeMode: isWifiOnline(wifiStatus.state) ||
+                                    !isBluetoothConnected
+                                    ? STREAMING_TYPE.WIFI
+                                    : STREAMING_TYPE.BLUETOOTH
+                            };
+                        case STREAMING_MODE.BLUETOOTH_WITH_WIFI_FALLBACK:
+                            return {
+                                connected: isBluetoothConnected
+                                    ? true
+                                    : isWifiOnline(wifiStatus.state),
+                                streamingMode,
+                                activeMode: isBluetoothConnected
+                                    ? STREAMING_TYPE.BLUETOOTH
+                                    : STREAMING_TYPE.WIFI
+                            };
+                    }
+                }), distinctUntilChanged((a, b) => isEqual(a, b)))));
+        }));
+    }
+    /**
+     *
+     * @hidden
+     */
+    _withStreamingModeObservable(streams) {
+        const { wifi, bluetooth } = streams;
+        return this.streamingState().pipe(switchMap(({ activeMode }) => {
+            switch (activeMode) {
+                case STREAMING_TYPE.WIFI:
+                    return wifi();
+                case STREAMING_TYPE.BLUETOOTH:
+                    return bluetooth();
+                default:
+                    return wifi();
+            }
+        }));
+    }
+    /**
+     *
+     * @hidden
+     */
+    _withStreamingModePromise(promises) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { wifi, bluetooth } = promises;
+            const { activeMode } = yield firstValueFrom(this.streamingState());
+            switch (activeMode) {
+                case STREAMING_TYPE.WIFI:
+                    return yield wifi();
+                case STREAMING_TYPE.BLUETOOTH:
+                    return yield bluetooth();
+                default:
+                    return yield wifi();
+            }
+        });
+    }
+    /**
+     *
+     * @hidden
+     */
+    get bluetooth() {
+        return this === null || this === void 0 ? void 0 : this.bluetoothClient;
+    }
+    /**
+     *
+     * @hidden
+     */
+    _getCloudMetricDependencies() {
+        return {
+            options: this.options,
+            cloudClient: this.cloudClient,
+            onDeviceChange: this.onDeviceChange.bind(this),
+            status: this.status.bind(this)
+        };
+    }
+    /**
+     * Starts user session
+     *
+     * ```typescript
+     * await neurosity.login({
+     *   email: "...",
+     *   password: "..."
+     * });
+     * ```
+     *
+     * @param credentials
+     */
+    login(credentials) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.cloudClient.login(credentials);
+        });
+    }
+    /**
+     * Ends user session
+     *
+     * ```typescript
+     * await neurosity.logout();
+     * // session has ended
+     * ```
+     *
+     */
+    logout() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.cloudClient.logout();
+        });
+    }
+    /**
+     * @internal
+     * Not user facing.
+     */
+    __getApp() {
+        return this.cloudClient.__getApp();
+    }
+    /**
+     * Subscribe to auth state changes
+     *
+     * Streams the state of the auth session. If user has logged in, the user object will be set. When logged out, the user object will be null.
+     *
+     * ```typescript
+     * neurosity.onAuthStateChanged().subscribe((user) => {
+     *   console.log(user);
+     * });
+     * ```
+     */
+    onAuthStateChanged() {
+        return this.cloudClient.onAuthStateChanged();
+    }
+    /**
+     * @internal
+     * Not user facing yet
+     */
+    addDevice(deviceId) {
+        const [hasOAuthError, OAuthError] = validateOAuthScopeForFunctionName(this.cloudClient.userClaims, "addDevice");
+        if (hasOAuthError) {
+            return Promise.reject(OAuthError);
+        }
+        return this.cloudClient.addDevice(deviceId);
+    }
+    /**
+     * @internal
+     * Not user facing yet
+     */
+    removeDevice(deviceId) {
+        const [hasOAuthError, OAuthError] = validateOAuthScopeForFunctionName(this.cloudClient.userClaims, "removeDevice");
+        if (hasOAuthError) {
+            return Promise.reject(OAuthError);
+        }
+        return this.cloudClient.removeDevice(deviceId);
+    }
+    /**
+     * @internal
+     * Not user facing yet
+     */
+    transferDevice(options) {
+        const [hasOAuthError, OAuthError] = validateOAuthScopeForFunctionName(this.cloudClient.userClaims, "transferDevice");
+        if (hasOAuthError) {
+            return Promise.reject(OAuthError);
+        }
+        return this.cloudClient.transferDevice(options);
+    }
+    /**
+     * @internal
+     * Not user facing yet
+     */
+    onUserDevicesChange() {
+        const [hasOAuthError, OAuthError] = validateOAuthScopeForFunctionName(this.cloudClient.userClaims, "onUserDevicesChange");
+        if (hasOAuthError) {
+            return throwError(() => OAuthError);
+        }
+        return this.cloudClient.onUserDevicesChange();
+    }
+    /**
+     * @internal
+     * Not user facing yet
+     */
+    onUserClaimsChange() {
+        return this.cloudClient.onUserClaimsChange();
+    }
+    /**
+     * Get user devices
+     *
+     * Returns a list of devices claimed by the user authenticated.
+     *
+     * ```typescript
+     * const devices = await neurosity.getDevices();
+     * console.log(devices);
+     * ```
+     */
+    getDevices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.cloudClient.getDevices();
+        });
+    }
+    /**
+     * Select Device
+     *
+     * Rarely necessary, but useful when the user owns multiple devices.
+     *
+     * A common use case for manually selecting a device is when you wish to build a device dropdown a user can select from, instead of collecting the Device Id from the user ahead of time.
+     *
+     * The 3 steps to manually selecting a device are:
+     *
+     * - Set `autoSelectDevice` to false when instantiating the `Neurosity` class.
+     * - Authenticate with your Neurosity account to access your devices by calling the `neurosity.login(...)` function.
+     * - Call the `neurosity.selectDevice(...)` function with a device selector function.
+     *
+     * ```typescript
+     * const devices = await neurosity.selectDevice((devices) =>
+     *   devices.find((device) => device.deviceNickname === "Crown-A1B")
+     * );
+     *
+     * console.log(devices);
+     * ```
+     *
+     * > If you own multiple devices, and don't pass `autoSelectDevice`, then the first device on the list will be automatically selected.
+     *
+     * For more info, check out the "Device Selection" guide.
+     */
+    selectDevice(deviceSelector) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [hasOAuthError, OAuthError] = validateOAuthScopeForFunctionName(this.cloudClient.userClaims, "selectDevice");
+            if (hasOAuthError) {
+                return Promise.reject(OAuthError);
+            }
+            return yield this.cloudClient.selectDevice(deviceSelector);
+        });
+    }
+    /**
+     * Get selected device
+     *
+     * ```typescript
+     * const selectedDevice = await neurosity.getSelectedDevice();
+     * console.log(selectedDevice);
+     * ```
+     */
+    getSelectedDevice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [hasOAuthError, OAuthError] = validateOAuthScopeForFunctionName(this.cloudClient.userClaims, "getSelectedDevice");
+            if (hasOAuthError) {
+                return Promise.reject(OAuthError);
+            }
+            return yield this.cloudClient.getSelectedDevice();
+        });
+    }
+    /**
+     * ```typescript
+     * const info = await neurosity.getInfo();
+     * ```
+     */
+    getInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(yield this.cloudClient.didSelectDevice())) {
+                return Promise.reject(errors.mustSelectDevice);
+            }
+            const [hasOAuthError, OAuthError] = validateOAuthScopeForFunctionName(this.cloudClient.userClaims, "getInfo");
+            if (hasOAuthError) {
+                return Promise.reject(OAuthError);
+            }
+            return yield this._withStreamingModePromise({
+                wifi: () => this.cloudClient.getInfo(),
+                bluetooth: () => this.bluetoothClient.getInfo()
+            });
+        });
+    }
+    /**
+     * Observes selected device
+     *
+     * ```typescript
+     * neurosity.onDeviceChange().subscribe(device => {
+     *  console.log(device);
+     * });
+     * ```
+     */
+    onDeviceChange() {
+        const [hasOAuthError, OAuthError] = validateOAuthScopeForFunctionName(this.cloudClient.userClaims, "onDeviceChange");
+        if (hasOAuthError) {
+            return throwError(() => OAuthError);
+        }
+        return this.cloudClient.onDeviceChange();
+    }
+    /**
+     * <StreamingModes wifi={true} bluetooth={true} />
+     *
+     * Ends database connection
+     *
+     * ```typescript
+     * await neurosity.disconnect();
+     * ```
+     */
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._withStreamingModePromise({
+                wifi: () => this.cloudClient.disconnect(),
+                bluetooth: () => this.bluetoothClient.disconnect()
+            });
+        });
+    }
+    /**
+     * <StreamingModes wifi={true} bluetooth={true} />
+     *
+     * @internal
+     * Not user facing
+     */
+    dispatchAction(action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(yield this.cloudClient.didSelectDevice())) {
+                return Promise.reject(errors.mustSelectDevice);
+            }
+            const [hasOAuthError, OAuthError] = validateOAuthScopeForAction(this.cloudClient.userClaims, action);
+            if (hasOAuthError) {
+                return Promise.reject(OAuthError);
+            }
+            return yield this._withStreamingModePromise({
+                wifi: () => this.cloudClient.dispatchAction(action),
+                bluetooth: () => this.bluetoothClient.dispatchAction(action)
+            });
+        });
+    }
+    /**
+     * <StreamingModes wifi={true} bluetooth={true} />
+     *
+     * Injects an EEG marker to data stream
+     *
+     * ```typescript
+     * neurosity.addMarker("eyes-closed");
+     *
+     * // later...
+     *
+     * neurosity.addMarker("eyes-open");
+     * ```
+     *
+     * @param label Name the label to inject
+     */
+    addMarker(label) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(yield this.cloudClient.didSelectDevice())) {
+                throw errors.mustSelectDevice;
+            }
+            if (!label) {
+                throw new Error(`${errors.prefix}A label is required for addMarker`);
+            }
+            return yield this._withStreamingModePromise({
+                wifi: () => this.cloudClient.dispatchAction({
+                    command: "marker",
+                    action: "add",
+                    message: {
+                        label,
+                        timestamp: this.cloudClient.timestamp
+                    }
+                }),
+                bluetooth: () => this.bluetoothClient.addMarker(label)
+            });
+        });
+    }
+    /**
+     * <StreamingModes wifi={true} bluetooth={true} />
+     *
+     * Queue haptic motor commands
+     *
+     * To queue haptic P7 only,
+     * ```typescript
+     * await neurosity.haptics({
+     *   P7: ["tripleClick100"]
+     * });
+     * ```
+     *
+     * To queue both motors at the same time
+     * ```typescript
+     * await neurosity.haptics({
+     *   P7: [neurosity.getHapticEffects().strongClick100],
+     *   P8: [neurosity.getHapticEffects().strongClick100]
+     * });
+     * ```
+     *
+     * You can queue different commands to the motors too
+     * ```typescript
+     * const effects = neurosity.getHapticEffects();
+     * await neurosity.haptics({
+     *   P7: [effects.transitionRampUpLongSmooth1_0_to_100,
+     *         effects.transitionRampDownLongSmooth1_100_to_0],
+     *   P8: [effects.strongClick100]
+     * });
+     * ```
+     *
+     * @param effects Effects to queue. The key of the object passed should be the location of the motor
+     *  to queue. Each key can be an array of up to 7 commands. There is no haptic support for model
+     *  version 1, Notion DK1. The Haptic motor's location is positioned in reference to the 10-10 EEG
+     *  system used to label the channels of the Crown's EEG sensors. Notion 2 and Crown have haptics
+     *  at P7 and P8. A list of haptic commands can be found on ./utils/hapticCodes.ts - there
+     *  are about 127 of them!
+     */
+    haptics(effects) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const metric = "haptics";
+            if (!(yield this.cloudClient.didSelectDevice())) {
+                return Promise.reject(errors.mustSelectDevice);
+            }
+            const modelVersion = (_a = (yield this.getSelectedDevice())) === null || _a === void 0 ? void 0 : _a.modelVersion;
+            const supportsHaptics = platform.supportsHaptics(modelVersion);
+            if (!supportsHaptics) {
+                return Promise.reject(errors.metricNotSupportedByModel(metric, modelVersion));
+            }
+            const newPlatformHapticRequest = platform.getPlatformHapticMotors(modelVersion);
+            for (const key in effects) {
+                if (!Object.keys(newPlatformHapticRequest).includes(key)) {
+                    return Promise.reject(errors.locationNotFound(key, modelVersion));
+                }
+                const singleMotorEffects = effects[key];
+                const maxItems = 7;
+                if (singleMotorEffects.length > maxItems) {
+                    return Promise.reject(errors.exceededMaxItems(maxItems));
+                }
+                newPlatformHapticRequest[key] = singleMotorEffects;
+            }
+            const payload = {
+                command: metric,
+                action: "queue",
+                responseRequired: true,
+                responseTimeout: 1000,
+                message: { effects: newPlatformHapticRequest }
+            };
+            return yield this._withStreamingModePromise({
+                wifi: () => this.cloudClient.dispatchAction(payload),
+                bluetooth: () => this.bluetoothClient.dispatchAction(payload)
+            });
+        });
+    }
+    /**
+     * ```typescript
+     * const effects = neurosity.getHapticEffects();
+     * ```
+     */
+    getHapticEffects() {
+        return hapticEffects;
+    }
+    /**
+     * <StreamingModes wifi={true} bluetooth={true} />
+     *
+     * Observes accelerometer data
+     * Supported by the Crown and Notion 2 devices.
+     *
+     * ```typescript
+     * neurosity.accelerometer().subscribe(accelerometer => {
+     *   console.log(accelerometer);
+     * });
+     *
+     * // { acceleration: ..., inclination: ..., orientation: ..., pitch: ..., roll: ..., x: ..., y: ..., z: ... }
+     * ```
+     *
+     * @returns Observable of accelerometer metric events
+     */
+    accelerometer() {
+        const metric = "accelerometer";
+        const [hasOAuthError, OAuthError] = validateOAuthScopeForFunctionName(this.cloudClient.userClaims, metric);
+        if (hasOAuthError) {
+            return throwError(() => OAuthError);
+        }
+        return this.onDeviceChange().pipe(switchMap((selectedDevice) => {
+            const modelVersion = (selectedDevice === null || selectedDevice === void 0 ? void 0 : selectedDevice.modelVersion) || platform.MODEL_VERSION_1;
+            const supportsAccel = platform.supportsAccel(modelVersion);
+            if (!supportsAccel) {
+                return throwError(() => errors.metricNotSupportedByModel(metric, modelVersion));
+            }
+            return this._withStreamingModeObservable({
+                wifi: () => getCloudMetric(this._getCloudMetricDependencies(), {
+                    metric,
+                    labels: getLabels(metric),
+                    atomic: true
+                }),
+                bluetooth: () => this.bluetoothClient.accelerometer()
+            });
+        }));
+    }
+    /**
+     * <StreamingModes wifi={true} bluetooth={true} />
+     *
+     * The `raw` brainwaves parameter emits epochs of 16 samples for Crown and 25 for Notion 1 and 2.
+     *
+     * Example
+     * ```typescript
+     * neurosity.brainwaves("raw").subscribe(brainwaves => {
+     *   console.log(brainwaves);
+     * });
+     * ```
+     *
+     * Raw Unfiltered - The `rawUnfiltered` brainwaves parameter emits epochs of 16 samples for Crown and 25 for Notion 1 and 2.
+  
+     * Example
+     * ```typescript
+     * neurosity.brainwaves("rawUnfiltered").subscribe(brainwaves => {
+     *   console.log(brainwaves);
+     * });
+     * ```
+     *
+     * Power By Band - The `powerByBand` brainwaves parameter emits epochs 4 times a second. Every frequency label (e.g. beta) contains an average power value per channel.
+     *
+     * Example
+     * ```typescript
+     * neurosity.brainwaves("powerByBand").subscribe(brainwaves => {
+     *   console.log(brainwaves);
+     * });
+     * ```
+     *
+     * Power Spectral Density (PSD) - The `psd` brainwaves parameter emits epochs 4 times a second. Every frequency label (e.g. alpha) contains the computed FFT (Fast Fourier transform) value per channel (see the `psd` property), as well as the frequency ranges (see the `freqs` property).
+     *
+     * Example
+     * ```typescript
+     * neurosity.brainwaves("psd").subscribe(brainwaves => {
+     *   console.log(brainwaves);
+     * });
+     * ```
+     *
+     * @param label Name of metric properties to filter by
+     * @returns Observable of brainwaves metric events
+     */
+    brainwaves(label) {
+        const [hasOAuthError, OAuthError] = validateOAuthScopeForFunctionName(this.cloudClient.userClaims, "brainwaves");
+        if (hasOAuthError) {
+            return throwError(() => OAuthError);
+        }
+        return this._withStreamingModeObservable({
+            wifi: () => getCloudMetric(this._getCloudMetricDependencies(), {
+                metric: "brainwaves",
+                labels: label ? [label] : [],
+                atomic: false
+            }),
+            // @TODO: doesn't support multiple labels, we should make the higher
+            // order function only support one label
+            bluetooth: () => this.bluetoothClient.brainwaves(label)
+        });
+    }
+    /**
+     * <StreamingModes wifi={true} bluetooth={true} />
+     *
+     * Example
+     * ```typescript
+     * neurosity.calm().subscribe(calm => {
+     *   console.log(calm.probability);
+     * });
+     *
+     * // 0.45
+     * // 0.47
+     * // 0.53
+     * // 0.51
+     * // ...
+     * ```
+     *
+     * @returns Observable of calm events - awareness/calm alias
+     */
+    calm() {
+        const [hasOAuthError, OAuthError] = validateOAuthScopeForFunctionName(this.cloudClient.userClaims, "calm");
+        if (hasOAuthError) {
+            return throwError(() => OAuthError);
+        }
+        return this._withStreamingModeObservable({
+            wifi: () => getCloudMetric(this._getCloudMetricDependencies(), {
+                metric: "awareness",
+                labels: ["calm"],
+                atomic: false
+            }),
+            bluetooth: () => this.bluetoothClient.calm()
+        });
+    }
+    /**
+     * <StreamingModes wifi={true} bluetooth={true} />
+     *
+     * Observes signal quality data where each property is the name
+     * of the channel and the value includes the standard deviation and
+     * a status set by the device
+     *
+     * ```typescript
+     * neurosity.signalQuality().subscribe(signalQuality => {
+     *   console.log(signalQuality);
+     * });
+     *
+     * // { FC6: { standardDeviation: 3.5, status: "good" }, C3: {...}, ... }
+     * ```
+     *
+     * @returns Observable of signalQuality metric events
+     */
+    signalQuality() {
+        const metric = "signalQuality";
+        const [hasOAuthError, OAuthError] = validateOAuthScopeForFunctionName(this.cloudClient.userClaims, metric);
+        if (hasOAuthError) {
+            return throwError(() => OAuthError);
+        }
+        return this._withStreamingModeObservable({
+            wifi: () => getCloudMetric(this._getCloudMetricDependencies(), {
+                metric,
+                labels: getLabels(metric),
+                atomic: true
+            }),
+            bluetooth: () => this.bluetoothClient.signalQuality()
+        });
+    }
+    /**
+     * <StreamingModes wifi={true} />
+     *
+     * Observes last state of `settings` and all subsequent `settings` changes
+     *
+     * ```typescript
+     * neurosity.settings().subscribe(settings => {
+     *   console.log(settings.lsl);
+     * });
+     *
+     * // true
+     * // ...
+     * ```
+     *
+     * @returns Observable of `settings` metric events
+     */
+    settings() {
+        const [hasOAuthError, OAuthError] = validateOAuthScopeForFunctionName(this.cloudClient.userClaims, "settings");
+        if (hasOAuthError) {
+            return throwError(() => OAuthError);
+        }
+        return this.cloudClient.observeNamespace("settings");
+    }
+    /**
+     * <StreamingModes wifi={true} bluetooth={true} />
+     *
+     * Example
+     * ```typescript
+     * neurosity.focus().subscribe(focus => {
+     *   console.log(focus.probability);
+     * });
+     *
+     * // 0.56
+     * // 0.46
+     * // 0.31
+     * // 0.39
+     * // ...
+     * ```
+     *
+     * @returns Observable of focus events - awareness/focus alias
+     */
+    focus() {
+        const [hasOAuthError, OAuthError] = validateOAuthScopeForFunctionName(this.cloudClient.userClaims, "focus");
+        if (hasOAuthError) {
+            return throwError(() => OAuthError);
+        }
+        return this._withStreamingModeObservable({
+            wifi: () => getCloudMetric(this._getCloudMetricDependencies(), {
+                metric: "awareness",
+                labels: ["focus"],
+                atomic: false
+            }),
+            bluetooth: () => this.bluetoothClient.focus()
+        });
+    }
+    /**
+     * <StreamingModes wifi={true} />
+     *
+     * @param label Name of metric properties to filter by
+     * @returns Observable of kinesis metric events
+     */
+    kinesis(label) {
+        const metric = "kinesis";
+        const [hasOAuthError, OAuthError] = validateOAuthScopeForFunctionName(this.cloudClient.userClaims, metric);
+        if (hasOAuthError) {
+            return throwError(() => OAuthError);
+        }
+        return getCloudMetric(this._getCloudMetricDependencies(), {
+            metric,
+            labels: label ? [label] : [],
+            atomic: false
+        });
+    }
+    /**
+     * <StreamingModes wifi={true} />
+     *
+     * @param label Name of metric properties to filter by
+     * @returns Observable of predictions metric events
+     */
+    predictions(label) {
+        const metric = "predictions";
+        const [hasOAuthError, OAuthError] = validateOAuthScopeForFunctionName(this.cloudClient.userClaims, metric);
+        if (hasOAuthError) {
+            return throwError(() => OAuthError);
+        }
+        return getCloudMetric(this._getCloudMetricDependencies(), {
+            metric,
+            labels: label ? [label] : [],
+            atomic: false
+        });
+    }
+    /**
+     * <StreamingModes wifi={true} bluetooth={true} />
+     *
+     * Observes last state of `status` and all subsequent `status` changes
+     *
+     * ```typescript
+     * neurosity.status().subscribe(status => {
+     *   console.log(status.state);
+     * });
+     *
+     * // "online"
+     * // ...
+     * ```
+     *
+     * @returns Observable of `status` metric events
+     */
+    status() {
+        const [hasOAuthError, OAuthError] = validateOAuthScopeForFunctionName(this.cloudClient.userClaims, "status");
+        if (hasOAuthError) {
+            return throwError(() => OAuthError);
+        }
+        return this._withStreamingModeObservable({
+            wifi: () => this.cloudClient.status(),
+            bluetooth: () => this.bluetoothClient.status()
+        });
+    }
+    /**
+     * @internal
+     * Not user facing yet
+     *
+     * <StreamingModes wifi={true} />
+     *
+     * Changes device settings programmatically. These settings can be
+     * also changed from the developer console under device settings.
+     *
+     * Available settings [[ChangeSettings]]
+     *
+     * Example
+     * ```typescript
+     * neurosity.changeSettings({
+     *   lsl: true
+     * });
+     * ```
+     */
+    changeSettings(settings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(yield this.cloudClient.didSelectDevice())) {
+                return Promise.reject(errors.mustSelectDevice);
+            }
+            const [hasOAuthError, OAuthError] = validateOAuthScopeForFunctionName(this.cloudClient.userClaims, "changeSettings");
+            if (hasOAuthError) {
+                return Promise.reject(OAuthError);
+            }
+            return yield this.cloudClient.changeSettings(settings);
+        });
+    }
+    /**
+     * <StreamingModes wifi={true} />
+     *
+     * ```typescript
+     * neurosity.training.record({
+     *   metric: "kinesis",
+     *   label: "push"
+     * });
+     *
+     * neurosity.training.stop({
+     *   metric: "kinesis",
+     *   label: "push"
+     * });
+     * ```
+     *
+     * @returns Training methods
+     */
+    get training() {
+        return {
+            /**
+             * <StreamingModes wifi={true} />
+             *
+             * Records a training for a metric/label pair
+             * @category Training
+             */
+            record: (training) => __awaiter(this, void 0, void 0, function* () {
+                if (!(yield this.cloudClient.didSelectDevice())) {
+                    throw errors.mustSelectDevice;
+                }
+                const userId = this.cloudClient.user && "uid" in this.cloudClient.user
+                    ? this.cloudClient.user.uid
+                    : null;
+                const message = Object.assign(Object.assign({ fit: false, baseline: false, timestamp: this.cloudClient.timestamp }, training), { userId });
+                yield this.cloudClient.actions.dispatch({
+                    command: "training",
+                    action: "record",
+                    message
+                });
+            }),
+            /**
+             * <StreamingModes wifi={true} />
+             *
+             * Stops the training for a metric/label pair
+             * @category Training
+             */
+            stop: (training) => __awaiter(this, void 0, void 0, function* () {
+                if (!(yield this.cloudClient.didSelectDevice())) {
+                    throw errors.mustSelectDevice;
+                }
+                yield this.cloudClient.actions.dispatch({
+                    command: "training",
+                    action: "stop",
+                    message: Object.assign({}, training)
+                });
+            }),
+            /**
+             * <StreamingModes wifi={true} />
+             *
+             * Stops all trainings
+             * @category Training
+             */
+            stopAll: () => __awaiter(this, void 0, void 0, function* () {
+                if (!(yield this.cloudClient.didSelectDevice())) {
+                    throw errors.mustSelectDevice;
+                }
+                yield this.cloudClient.actions.dispatch({
+                    command: "training",
+                    action: "stopAll",
+                    message: {}
+                });
+            })
+        };
+    }
+    /**
+     * @internal
+     * Proof of Concept for disconnecting db
+     */
+    goOffline() {
+        this.cloudClient.goOffline();
+    }
+    /**
+     * @internal
+     * Proof of Concept for resuming db connection
+     */
+    goOnline() {
+        this.cloudClient.goOnline();
+    }
+    /**
+     * @internal
+     * Not user facing yet
+     *
+     * Creates user account and automatically signs in with same credentials
+     *
+     * @param emailAndPasswordObject
+     * @returns user credential
+     */
+    createAccount(credentials) {
+        return this.cloudClient.createAccount(credentials);
+    }
+    /**
+     * @internal
+     * Not user facing yet
+     *
+     * Removes all devices from an account and then deletes the account
+     */
+    deleteAccount() {
+        return this.cloudClient.deleteAccount();
+    }
+    /**
+     * @internal
+     * Not user facing
+     *
+     * Creates token (JWT) designed to authenticate and authorize Bluetooth clients/centrals.
+     *
+     * @returns token
+     */
+    createBluetoothToken() {
+        return this.cloudClient.createBluetoothToken();
+    }
+    /**
+     * @internal
+     * Not user facing yet
+     *
+     * Creates custom token (JWT) to use to login with `{ customToken }`.
+     *
+     * @returns custom token
+     */
+    createCustomToken() {
+        return this.cloudClient.createCustomToken();
+    }
+    /**
+     * @internal
+     * Not user facing yet
+     *
+     * Gets the offset between the device's clock and the client's clock
+     * Requires option.timesync to be true
+     *
+     * @returns timesyncOffset
+     */
+    getTimesyncOffset() {
+        if (!this.options.timesync) {
+            console.warn(`getTimesyncOffset() requires options.timesync to be true.`);
+        }
+        return this.options.timesync ? this.cloudClient.getTimesyncOffset() : 0;
+    }
+    /**
+     * Create OAuth URL
+     * 💡 OAuth requires developers to register their apps with Neurosity
+     * [Read full OAuth guide](/docs/oauth)
+     *
+     * Creates client-specific OAuth URL. This is the first step of the OAuth workflow. Use this function to create a URL you can use to redirect users to the Neurosity sign-in page.
+     * 💡 This function is designed to only run on the server side for security reasons, as it requires your client secret.
+     *
+     * ```typescript
+     * const { Neurosity } = require("@neurosity/sdk");
+     *
+     * const neurosity = new Neurosity({
+     *   autoSelectDevice: false
+     * });
+     *
+     * exports.handler = async function (event) {
+     *   return neurosity
+     *     .createOAuthURL({
+     *       clientId: process.env.NEUROSITY_OAUTH_CLIENT_ID,
+     *       clientSecret: process.env.NEUROSITY_OAUTH_CLIENT_SECRET,
+     *       redirectUri: process.env.NEUROSITY_OAUTH_CLIENT_REDIRECT_URI,
+     *       responseType: "token",
+     *       state: Math.random().toString().split(".")[1],
+     *       scope: [
+     *         "read:devices-info",
+     *         "read:devices-status",
+     *         "read:signal-quality",
+     *         "read:brainwaves"
+     *       ]
+     *     })
+     *     .then((url) => ({
+     *       statusCode: 200,
+     *       body: JSON.stringify({ url })
+     *     }))
+     *     .catch((error) => ({
+     *       statusCode: 400,
+     *       body: JSON.stringify(error.response.data)
+     *     }));
+     * };
+     * ```
+     * @returns custom token
+     */
+    createOAuthURL(config) {
+        if (!isNode) {
+            return Promise.reject(new Error(`${errors.prefix}the createOAuthURL method must be used on the server side (node.js) for security reasons.`));
+        }
+        return createOAuthURL(config, this.options);
+    }
+    /**
+     * Get OAuth Token
+     * 💡 OAuth requires developers to register their apps with Neurosity
+     * [Read full OAuth guide](/docs/oauth)
+     *
+     * Gets client-specific OAuth token for a given userId.
+     *
+     * 💡 This function is designed to only run on the server side for security reasons, as it requires your client secret.
+     * Here's an example of a cloud function that receives a `userId` via query params and loads the client id and client secret securely via environment variables.
+     *
+     *
+     * ```typescript
+     * const { Neurosity } = require("@neurosity/sdk");
+     *
+     * const neurosity = new Neurosity({
+     *   autoSelectDevice: false
+     * });
+     *
+     * exports.handler = async function (event) {
+     *   const userId = event.queryStringParameters?.userId;
+     *
+     *   return neurosity
+     *     .getOAuthToken({
+     *       clientId: process.env.NEUROSITY_OAUTH_CLIENT_ID,
+     *       clientSecret: process.env.NEUROSITY_OAUTH_CLIENT_SECRET,
+     *       userId
+     *     })
+     *     .then((token) => ({
+     *       statusCode: 200,
+     *       body: JSON.stringify(token)
+     *     }))
+     *     .catch((error) => ({
+     *       statusCode: 200,
+     *       body: JSON.stringify(error.response.data)
+     *     }));
+     * };
+     * ```
+     * @returns custom token
+     */
+    getOAuthToken(query) {
+        if (!isNode) {
+            return Promise.reject(new Error(`${errors.prefix}the getOAuthToken method must be used on the server side (node.js) for security reasons.`));
+        }
+        return getOAuthToken(query, this.options);
+    }
+    /**
+     * Remove OAuth Access
+     * 💡 OAuth requires developers to register their apps with Neurosity
+     * [Read full OAuth guide](/docs/oauth)
+     *
+     * Removes client-specific OAuth token for a given userId. Requires SDK to be signed in with OAuth custom token.
+     *
+     * ```typescript
+     * await neurosity.removeOAuthAccess().catch((error) => {
+     *   // handle error here...
+     * });
+     * ```
+     * @returns custom token
+     */
+    removeOAuthAccess() {
+        return this.cloudClient.removeOAuthAccess();
+    }
+    /**
+     * @internal
+     * Proof of Concept for Skills - Not user facing yet
+     *
+     * Accesses a skill by Bundle ID. Additionally, allows to observe
+     * and push skill metrics
+     *
+     * @param bundleId Bundle ID of skill
+     * @returns Skill instance
+     */
+    skill(bundleId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(yield this.cloudClient.didSelectDevice())) {
+                return Promise.reject(errors.mustSelectDevice);
+            }
+            const skillData = yield this.cloudClient.skills.get(bundleId);
+            if (skillData === null) {
+                return Promise.reject(new Error(`${errors.prefix}Access denied for: ${bundleId}. Make sure the skill is installed.`));
+            }
+            return {
+                metric: (label) => {
+                    const metricName = `skill~${skillData.id}~${label}`;
+                    const subscription = new Observable((observer) => {
+                        const subscription = this.cloudClient.metrics.subscribe({
+                            metric: metricName,
+                            labels: [label],
+                            atomic: true
+                        });
+                        const listener = this.cloudClient.metrics.on(subscription, (...data) => {
+                            observer.next(...data);
+                        });
+                        return () => {
+                            this.cloudClient.metrics.unsubscribe(subscription, listener);
+                        };
+                    }).pipe(map((metric) => metric[label]));
+                    Object.defineProperty(subscription, "next", {
+                        value: (metricValue) => {
+                            this.cloudClient.metrics.next(metricName, {
+                                [label]: metricValue
+                            });
+                        }
+                    });
+                    return subscription;
+                }
+            };
+        });
+    }
+    /**
+     * <StreamingModes wifi={true} />
+     *
+     * Observes and returns a list of all Kinesis `experiments` and all subsequent experiment changes.
+     * Here's an example of how to get a list of all Kinesis labels that have been trained:
+     *
+     * ```typescript
+     *
+     * const getUniqueLabels = (experiments) => {
+     *   const labels = experiments.flatMap((experiment) => experiment.labels);
+     *   // only return unique labels
+     *   return [...new Set(labels)];
+     * }
+     *
+     * neurosity.onUserExperiments().subscribe((experiments) => {
+     *   console.log(experiments);
+     *   console.log("labels", getUniqueLabels(experiments));
+     * });
+     *
+     * // [{ id: '...', deviceId: '...', labels: [ 'drop' ], name: 'Lightgray cheetah', timestamp: 1577908381552, totalTrials: 16, userId: '...' }]
+     * // ["drop", "lift", "push"]
+     * ```
+     *
+     * @returns Observable of `experiments` events
+     */
+    onUserExperiments() {
+        return this.cloudClient.onUserExperiments();
+    }
+    /**
+     * <StreamingModes wifi={true} />
+     *
+     * Deletes a specific experiment provided an experiment ID
+     *
+     * ```typescript
+     * await neurosity.deleteUserExperiment(experiment.id);
+     * ```
+     *
+     * @param experimentId The ID of the Experiment
+     * @returns void
+     */
+    deleteUserExperiment(experimentId) {
+        return this.cloudClient.deleteUserExperiment(experimentId);
+    }
+}
+/**
+ *
+ * @hidden
+ */
+Neurosity.credentialWithLink = credentialWithLink;
+/**
+ *
+ * @hidden
+ */
+Neurosity.createUser = createUser;
+/**
+ *
+ * @hidden
+ */
+Neurosity.SERVER_TIMESTAMP = SERVER_TIMESTAMP;
+/**
+ * @hidden
+ * Deprecated class kept for backwards compatibility purposes.
+ */
+export class Notion extends Neurosity {
+    constructor(options = {}) {
+        super(options);
+        console.log(`The Notion class is deprecated and will be removed in the next version of the SDK. Please use the Neurosity class instead. e.g. new Notion() => new Neurosity()`);
+    }
+}