react-native-spike-sdk 4.3.73-beta.3 → 4.3.73

package/lib/commonjs/DataModels/SpikeActivitiesStreamDataEntry.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=SpikeActivitiesStreamDataEntry.js.map

package/lib/commonjs/DataModels/SpikeActivitiesSummaryDataEntry.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=SpikeActivitiesSummaryDataEntry.js.map

package/lib/commonjs/DataModels/SpikeBodyDataEntry.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=SpikeBodyDataEntry.js.map

package/lib/commonjs/DataModels/SpikeBreathingDataEntry.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=SpikeBreathingDataEntry.js.map

package/lib/commonjs/DataModels/SpikeCaloriesDataEntry.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=SpikeCaloriesDataEntry.js.map

package/lib/commonjs/DataModels/SpikeData.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=SpikeData.js.map

package/lib/commonjs/DataModels/SpikeDataTypes.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SpikeDataTypes = void 0;
+var _SpikeDataType = require("../DataTypes/SpikeDataType");
+const SpikeDataTypes = exports.SpikeDataTypes = {
+  activitiesSummary: new _SpikeDataType.SpikeActivitiesSummaryDataType(),
+  activitiesStream: new _SpikeDataType.SpikeActivitiesStreamDataType(),
+  breathing: new _SpikeDataType.SpikeBreathingDataType(),
+  calories: new _SpikeDataType.SpikeCaloriesDataType(),
+  distance: new _SpikeDataType.SpikeDistanceDataType(),
+  glucose: new _SpikeDataType.SpikeGlucoseDataType(),
+  heart: new _SpikeDataType.SpikeHeartDataType(),
+  oxygenSaturation: new _SpikeDataType.SpikeOxygenSaturationDataType(),
+  sleep: new _SpikeDataType.SpikeSleepDataType(),
+  steps: new _SpikeDataType.SpikeStepsDataType(),
+  stepsIntraday: new _SpikeDataType.SpikeStepsIntradayDataType(),
+  body: new _SpikeDataType.SpikeBodyDataType(),
+  ecg: new _SpikeDataType.SpikeEcgDataType()
+};
+//# sourceMappingURL=SpikeDataTypes.js.map

package/lib/commonjs/DataModels/SpikeDistanceDataEntry.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=SpikeDistanceDataEntry.js.map

package/lib/commonjs/DataModels/SpikeEcgDataEntry.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=SpikeEcgDataEntry.js.map

package/lib/commonjs/DataModels/SpikeGlucoseDataEntry.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=SpikeGlucoseDataEntry.js.map

package/lib/commonjs/DataModels/SpikeHeartDataEntry.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=SpikeHeartDataEntry.js.map

package/lib/commonjs/DataModels/SpikeOxygenSaturationDataEntry.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=SpikeOxygenSaturationDataEntry.js.map

package/lib/commonjs/DataModels/SpikeSleepDataEntry.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=SpikeSleepDataEntry.js.map

package/lib/commonjs/DataModels/SpikeStepsDataEntry.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=SpikeStepsDataEntry.js.map

package/lib/commonjs/DataModels/SpikeStepsIntradayDataEntry.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=SpikeStepsIntradayDataEntry.js.map

package/lib/commonjs/DataModels/SpikeWebhookJob.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=SpikeWebhookJob.js.map

package/lib/commonjs/DataTypes/SpikeDataType.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SpikeStepsIntradayDataType = exports.SpikeStepsDataType = exports.SpikeSleepDataType = exports.SpikeOxygenSaturationDataType = exports.SpikeHeartDataType = exports.SpikeGlucoseDataType = exports.SpikeEcgDataType = exports.SpikeDistanceDataType = exports.SpikeCaloriesDataType = exports.SpikeBreathingDataType = exports.SpikeBodyDataType = exports.SpikeActivitiesSummaryDataType = exports.SpikeActivitiesStreamDataType = void 0;
+class SpikeActivitiesStreamDataType {
+  rawValue = 'activities_stream';
+}
+exports.SpikeActivitiesStreamDataType = SpikeActivitiesStreamDataType;
+class SpikeActivitiesSummaryDataType {
+  rawValue = 'activities_summary';
+}
+exports.SpikeActivitiesSummaryDataType = SpikeActivitiesSummaryDataType;
+class SpikeBreathingDataType {
+  rawValue = 'breathing';
+}
+exports.SpikeBreathingDataType = SpikeBreathingDataType;
+class SpikeCaloriesDataType {
+  rawValue = 'calories';
+}
+exports.SpikeCaloriesDataType = SpikeCaloriesDataType;
+class SpikeDistanceDataType {
+  rawValue = 'distance';
+}
+exports.SpikeDistanceDataType = SpikeDistanceDataType;
+class SpikeGlucoseDataType {
+  rawValue = 'glucose';
+}
+exports.SpikeGlucoseDataType = SpikeGlucoseDataType;
+class SpikeHeartDataType {
+  rawValue = 'heart';
+}
+exports.SpikeHeartDataType = SpikeHeartDataType;
+class SpikeOxygenSaturationDataType {
+  rawValue = 'oxygen_saturation';
+}
+exports.SpikeOxygenSaturationDataType = SpikeOxygenSaturationDataType;
+class SpikeSleepDataType {
+  rawValue = 'sleep';
+}
+exports.SpikeSleepDataType = SpikeSleepDataType;
+class SpikeStepsDataType {
+  rawValue = 'steps';
+}
+exports.SpikeStepsDataType = SpikeStepsDataType;
+class SpikeStepsIntradayDataType {
+  rawValue = 'steps_intraday';
+}
+exports.SpikeStepsIntradayDataType = SpikeStepsIntradayDataType;
+class SpikeBodyDataType {
+  rawValue = 'body';
+}
+exports.SpikeBodyDataType = SpikeBodyDataType;
+class SpikeEcgDataType {
+  rawValue = 'ecg';
+}
+exports.SpikeEcgDataType = SpikeEcgDataType;
+//# sourceMappingURL=SpikeDataType.js.map

package/lib/commonjs/Spike.js

@@ -0,0 +1,116 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isPackageInstalled = exports.isHealthDataAvailable = exports.getBackgroundConnections = exports.ensurePermissionsAreGranted = exports.createConnectionAPIv3Legacy = exports.createConnectionAPIv3 = exports.createConnection = void 0;
+var _reactNative = require("react-native");
+var _SpikeConnection = require("./SpikeConnection");
+var _SpikeException = require("./SpikeException");
+var _SpikeSdk = require("./SpikeSdk");
+var _SpikeRNConnectionAPIv = require("./v3/SpikeRNConnectionAPIv3");
+var _version = require("./version");
+const createConnection = async (config, logger) => {
+  if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
+  try {
+    const connectionUUID = generateUUID();
+    const spikeConnection = new _SpikeConnection.SpikeConnection(connectionUUID, logger);
+    await _SpikeSdk.SpikeSdk.createConnection(connectionUUID, config.appId, config.authToken, config.customerEndUserId, config.callbackUrl ?? null, !!logger);
+    return spikeConnection;
+  } catch (error) {
+    throw (0, _SpikeException.unwrapSpikeException)(error);
+  }
+};
+exports.createConnection = createConnection;
+const getBackgroundConnections = async () => {
+  if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
+  try {
+    const connectionUUIDs = await _SpikeSdk.SpikeSdk.getBackgroundConnections();
+    const connections = connectionUUIDs.map(uuid => new _SpikeConnection.SpikeConnection(uuid));
+    return connections;
+  } catch (error) {
+    throw (0, _SpikeException.unwrapSpikeException)(error);
+  }
+};
+exports.getBackgroundConnections = getBackgroundConnections;
+const ensurePermissionsAreGranted = async permissions => {
+  if (_reactNative.Platform.OS !== 'ios') return;
+  if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
+  try {
+    await _SpikeSdk.SpikeSdk.ensurePermissionsAreGranted(permissions.map(permissionType => permissionType.rawValue));
+  } catch (error) {
+    throw (0, _SpikeException.unwrapSpikeException)(error);
+  }
+};
+exports.ensurePermissionsAreGranted = ensurePermissionsAreGranted;
+const isPackageInstalled = async () => {
+  if (_reactNative.Platform.OS !== 'android') return true;
+  if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
+  try {
+    return await _SpikeSdk.SpikeSdk.isPackageInstalled();
+  } catch (error) {
+    throw (0, _SpikeException.unwrapSpikeException)(error);
+  }
+};
+exports.isPackageInstalled = isPackageInstalled;
+const isHealthDataAvailable = async () => {
+  if (_reactNative.Platform.OS !== 'ios') return true;
+  if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
+  try {
+    return await _SpikeSdk.SpikeSdk.isHealthDataAvailable();
+  } catch (error) {
+    throw (0, _SpikeException.unwrapSpikeException)(error);
+  }
+};
+exports.isHealthDataAvailable = isHealthDataAvailable;
+function generateUUID() {
+  const S4 = function () {
+    let str = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVXZ';
+    let uuid = [];
+    for (let i = 0; i < 4; i++) {
+      uuid.push(str[Math.floor(Math.random() * str.length)]);
+    }
+    return uuid.join('');
+  };
+  return S4() + S4() + '-' + S4() + '-' + S4() + '-' + S4() + '-' + S4() + S4() + S4();
+}
+
+// -------------------------- SpikeConnectionAPIv3 --------------------------
+
+const createConnectionAPIv3 = async ({
+  applicationId,
+  signature,
+  endUserId
+}) => {
+  if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException("No SpikeSDK found");
+  try {
+    await _SpikeSdk.SpikeSdk.setWrapper("RN", _version.SPIKE_SDK_VERSION);
+    const connectionUUID = generateUUID();
+    await _SpikeSdk.SpikeSdk.createConnectionAPIv3(connectionUUID, applicationId, signature, endUserId);
+    const spikeConnection = new _SpikeRNConnectionAPIv.SpikeRNConnectionAPIv3(connectionUUID);
+    return spikeConnection;
+  } catch (error) {
+    throw (0, _SpikeException.unwrapSpikeException)(error);
+  }
+};
+exports.createConnectionAPIv3 = createConnectionAPIv3;
+const createConnectionAPIv3Legacy = async ({
+  appId,
+  authToken,
+  customerEndUserId
+}) => {
+  if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException("No SpikeSDK found");
+  try {
+    await _SpikeSdk.SpikeSdk.setWrapper("RN", _version.SPIKE_SDK_VERSION);
+    const connectionUUID = generateUUID();
+    await _SpikeSdk.SpikeSdk.createConnectionAPIv3Legacy(connectionUUID, appId, authToken, customerEndUserId);
+    const spikeConnection = new _SpikeRNConnectionAPIv.SpikeRNConnectionAPIv3(connectionUUID);
+    return spikeConnection;
+  } catch (error) {
+    throw (0, _SpikeException.unwrapSpikeException)(error);
+  }
+};
+
+// -------------------------- end of SpikeConnectionAPIv3 --------------------------
+exports.createConnectionAPIv3Legacy = createConnectionAPIv3Legacy;
+//# sourceMappingURL=Spike.js.map

package/lib/commonjs/SpikeBackgroundDeliveriesLogger.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=SpikeBackgroundDeliveriesLogger.js.map

package/lib/commonjs/SpikeConnection.js

@@ -0,0 +1,298 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SpikeConnection = void 0;
+var _reactNative = require("react-native");
+var _SpikeException = require("./SpikeException");
+var _SpikeSdk = require("./SpikeSdk");
+var _SpikeDataType = require("./DataTypes/SpikeDataType");
+class SpikeConnection {
+  backgroundLogger = null;
+  logger = null;
+  toString() {
+    return 'This is wrapper class. To get connection data use `getAppId()`, `getSpikeEndUserId()`, `getCustomerEndUserId()` methods.';
+  }
+  toJSON() {
+    return JSON.stringify({
+      warning: 'This is wrapper class. To get connection data use `getAppId()`, `getSpikeEndUserId()`, `getCustomerEndUserId()` methods.'
+    });
+  }
+  constructor(connectionUUID, logger = null) {
+    this.connectionUUID = connectionUUID;
+    this.setupLogger(logger);
+  }
+  async manageHealthConnect() {
+    if (_reactNative.Platform.OS !== 'android') return;
+    if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
+    try {
+      return await _SpikeSdk.SpikeSdk.manageHealthConnect(this.connectionUUID);
+    } catch (error) {
+      throw (0, _SpikeException.unwrapSpikeException)(error);
+    }
+  }
+  async checkPermissionsGranted(dataTypes) {
+    if (_reactNative.Platform.OS !== 'android') return false;
+    if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
+    try {
+      return await _SpikeSdk.SpikeSdk.checkPermissionsGranted(this.connectionUUID, dataTypes.rawValue);
+    } catch (error) {
+      throw (0, _SpikeException.unwrapSpikeException)(error);
+    }
+  }
+  async requestHealthPermissions(dataTypes) {
+    if (_reactNative.Platform.OS !== 'android') return;
+    if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
+    if (Array.isArray(dataTypes)) {
+      try {
+        return await _SpikeSdk.SpikeSdk.requestMultipleHealthPermissions(this.connectionUUID, dataTypes.map(type => type.rawValue));
+      } catch (error) {
+        throw (0, _SpikeException.unwrapSpikeException)(error);
+      }
+    }
+    try {
+      return await _SpikeSdk.SpikeSdk.requestHealthPermissions(this.connectionUUID, dataTypes.rawValue);
+    } catch (error) {
+      throw (0, _SpikeException.unwrapSpikeException)(error);
+    }
+  }
+  async revokeAllPermissions() {
+    if (_reactNative.Platform.OS !== 'android') return;
+    if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
+    try {
+      return await _SpikeSdk.SpikeSdk.revokeAllPermissions(this.connectionUUID);
+    } catch (error) {
+      throw (0, _SpikeException.unwrapSpikeException)(error);
+    }
+  }
+  async getHealthConnectAvailability() {
+    if (_reactNative.Platform.OS !== 'android') return 'notInstalled';
+    if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
+    try {
+      return await _SpikeSdk.SpikeSdk.getHealthConnectAvailability(this.connectionUUID);
+    } catch (error) {
+      throw (0, _SpikeException.unwrapSpikeException)(error);
+    }
+  }
+  async getAppId() {
+    if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
+    try {
+      return await _SpikeSdk.SpikeSdk.getAppId(this.connectionUUID);
+    } catch (error) {
+      throw (0, _SpikeException.unwrapSpikeException)(error);
+    }
+  }
+  async getSpikeEndUserId() {
+    if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
+    try {
+      return await _SpikeSdk.SpikeSdk.getSpikeEndUserId(this.connectionUUID);
+    } catch (error) {
+      throw (0, _SpikeException.unwrapSpikeException)(error);
+    }
+  }
+  async getCustomerEndUserId() {
+    if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
+    try {
+      return await _SpikeSdk.SpikeSdk.getCustomerEndUserId(this.connectionUUID);
+    } catch (error) {
+      throw (0, _SpikeException.unwrapSpikeException)(error);
+    }
+  }
+  async getCallbackUrl() {
+    if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
+    try {
+      return await _SpikeSdk.SpikeSdk.getCallbackUrl(this.connectionUUID);
+    } catch (error) {
+      throw (0, _SpikeException.unwrapSpikeException)(error);
+    }
+  }
+  async close() {
+    if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
+    try {
+      await _SpikeSdk.SpikeSdk.close(this.connectionUUID);
+      this.removeListeners();
+    } catch (error) {
+      throw (0, _SpikeException.unwrapSpikeException)(error);
+    }
+  }
+  async extractData(config) {
+    if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
+    if (_reactNative.Platform.OS === 'android' && config.dataType.rawValue === 'ecg') {
+      let dateFrom;
+      let dateTo;
+      let collectedAt = new Date();
+      if ('from' in config) {
+        dateFrom = config.from;
+        dateTo = config.to;
+      } else {
+        dateFrom = new Date();
+        dateTo = new Date();
+      }
+      const result = {
+        dateFrom: dateFrom.toISOString(),
+        dateTo: dateTo.toISOString(),
+        collectedAt: collectedAt.toISOString(),
+        endUserId: await this.getSpikeEndUserId(),
+        sources: [{
+          name: 'android',
+          isSuccess: false,
+          message: 'No ECG data on android health connect'
+        }],
+        entries: []
+      };
+      return result;
+    }
+    try {
+      let json = '';
+      if ('from' in config) {
+        json = await _SpikeSdk.SpikeSdk.extractDataInRange(this.connectionUUID, config.dataType.rawValue, config.from.getTime(), config.to.getTime());
+      } else {
+        json = await _SpikeSdk.SpikeSdk.extractData(this.connectionUUID, config.dataType.rawValue);
+      }
+      const data = JSON.parse(json);
+      return data;
+    } catch (error) {
+      throw (0, _SpikeException.unwrapSpikeException)(error);
+    }
+  }
+  async extractAndPostData(config) {
+    if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
+    if (_reactNative.Platform.OS === 'android' && config.dataType.rawValue === 'ecg') {
+      let dateFrom;
+      let dateTo;
+      let collectedAt = new Date();
+      if ('from' in config) {
+        dateFrom = config.from;
+        dateTo = config.to;
+      } else {
+        dateFrom = new Date();
+        dateTo = new Date();
+      }
+      const result = {
+        dataType: config.dataType.rawValue,
+        payloadSize: 0,
+        callbackUrl: new URL(await this.getCallbackUrl()),
+        dateFrom: dateFrom,
+        dateTo: dateTo,
+        collectedAt: collectedAt
+      };
+      return result;
+    }
+    try {
+      let json = '';
+      if ('from' in config) {
+        json = await _SpikeSdk.SpikeSdk.extractAndPostDataInRange(this.connectionUUID, config.dataType.rawValue, config.from.getTime(), config.to.getTime());
+      } else {
+        json = await _SpikeSdk.SpikeSdk.extractAndPostData(this.connectionUUID, config.dataType.rawValue);
+      }
+      const data = JSON.parse(json);
+      return data;
+    } catch (error) {
+      throw (0, _SpikeException.unwrapSpikeException)(error);
+    }
+  }
+  async enableBackgroundDelivery(dataTypes) {
+    if (_reactNative.Platform.OS !== 'ios') return;
+    if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
+    try {
+      await _SpikeSdk.SpikeSdk.enableBackgroundDelivery(this.connectionUUID, dataTypes.map(type => type.rawValue));
+    } catch (error) {
+      throw (0, _SpikeException.unwrapSpikeException)(error);
+    }
+  }
+  async getBackgroundDeliveryDataTypes() {
+    if (_reactNative.Platform.OS !== 'ios') return [];
+    if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
+    const dataTypes = await _SpikeSdk.SpikeSdk.getBackgroundDeliveryDataTypes(this.connectionUUID);
+    return dataTypes.map(type => this.convertDataType(type));
+  }
+  async setListener(listener) {
+    if (_reactNative.Platform.OS !== 'ios') return;
+    if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
+    try {
+      this.setupListener(listener);
+      await _SpikeSdk.SpikeSdk.setListener(this.connectionUUID);
+    } catch (error) {
+      throw (0, _SpikeException.unwrapSpikeException)(error);
+    }
+  }
+  setupLogger(logger) {
+    if (!_SpikeSdk.SpikeSdk) return;
+    this.removeLogger();
+    if (!logger) return;
+    this.logEventListener = new _reactNative.NativeEventEmitter(_SpikeSdk.SpikeSdk);
+    this.logger = logger;
+    this.logEventListener?.addListener('onDebug', data => {
+      if (this.connectionUUID !== data.connectionUUID) return;
+      if (logger?.isDebugEnabled() === true) {
+        logger?.debug(this, data.message);
+      }
+    });
+    this.logEventListener?.addListener('onInfo', data => {
+      if (!!logger && this.connectionUUID !== data.connectionUUID) return;
+      if (logger?.isInfoEnabled() === true) {
+        logger?.info(this, data.message);
+      }
+    });
+    this.logEventListener?.addListener('onError', data => {
+      if (this.connectionUUID !== data.connectionUUID) return;
+      if (logger?.isErrorEnabled() === true) {
+        logger?.error(this, data.message);
+      }
+    });
+  }
+  removeLogger() {
+    if (!this.logEventListener) return;
+    this.logEventListener.removeAllListeners('onDebug');
+    this.logEventListener.removeAllListeners('onInfo');
+    this.logEventListener.removeAllListeners('onError');
+    this.logEventListener = undefined;
+    this.logger = null;
+  }
+  setupListener(listener) {
+    if (!_SpikeSdk.SpikeSdk) return;
+    this.removeListeners();
+    this.eventListener = new _reactNative.NativeEventEmitter(_SpikeSdk.SpikeSdk);
+    this.backgroundLogger = listener;
+    this.eventListener?.addListener('onBackgroundLog', data => {
+      if (this.connectionUUID !== data.connectionUUID) return;
+      this.backgroundLogger?.onBackgroundLog(data.log);
+    });
+  }
+  removeListeners() {
+    if (!this.eventListener) return;
+    this.eventListener.removeAllListeners('onBackgroundLog');
+    this.eventListener = undefined;
+  }
+  convertDataType(dataType) {
+    if (dataType === 'activities_summary') {
+      return new _SpikeDataType.SpikeActivitiesSummaryDataType();
+    } else if (dataType === 'activities_stream') {
+      return new _SpikeDataType.SpikeActivitiesStreamDataType();
+    } else if (dataType === 'breathing') {
+      return new _SpikeDataType.SpikeBreathingDataType();
+    } else if (dataType === 'calories') {
+      return new _SpikeDataType.SpikeCaloriesDataType();
+    } else if (dataType === 'distance') {
+      return new _SpikeDataType.SpikeDistanceDataType();
+    } else if (dataType === 'glucose') {
+      return new _SpikeDataType.SpikeGlucoseDataType();
+    } else if (dataType === 'heart') {
+      return new _SpikeDataType.SpikeHeartDataType();
+    } else if (dataType === 'oxygen_saturation') {
+      return new _SpikeDataType.SpikeOxygenSaturationDataType();
+    } else if (dataType === 'sleep') {
+      return new _SpikeDataType.SpikeSleepDataType();
+    } else if (dataType === 'steps') {
+      return new _SpikeDataType.SpikeStepsDataType();
+    } else if (dataType === 'body') {
+      return new _SpikeDataType.SpikeBodyDataType();
+    } else if (dataType === 'ecg') {
+      return new _SpikeDataType.SpikeEcgDataType();
+    }
+    return new _SpikeDataType.SpikeStepsDataType();
+  }
+}
+exports.SpikeConnection = SpikeConnection;
+//# sourceMappingURL=SpikeConnection.js.map

package/lib/commonjs/SpikeConnectionTypes.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=SpikeConnectionTypes.js.map