@tryvital/vital-node 3.1.3 → 3.1.5

package/dist/serialization/types/GroupedHrvResponse.js

@@ -25,19 +25,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupedHrvResponse = void 0;
 const core = __importStar(require("../../core"));
+const GroupedHrv_1 = require("./GroupedHrv");
 exports.GroupedHrvResponse = core.serialization.object({
-    groups: core.serialization.record(core.serialization.string(), core.serialization.list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).GroupedHrv; })))),
+    groups: core.serialization.record(core.serialization.string(), core.serialization.list(GroupedHrv_1.GroupedHrv)),
     next: core.serialization.string().optional(),
 });

package/dist/serialization/types/GroupedHypnogram.d.ts

@@ -4,10 +4,12 @@
 import * as serializers from "..";
 import * as Vital from "../../api";
 import * as core from "../../core";
+import { ClientFacingSource } from "./ClientFacingSource";
+import { ClientFacingHypnogramTimeseries } from "./ClientFacingHypnogramTimeseries";
 export declare const GroupedHypnogram: core.serialization.ObjectSchema<serializers.GroupedHypnogram.Raw, Vital.GroupedHypnogram>;
 export declare namespace GroupedHypnogram {
     interface Raw {
-        source: serializers.ClientFacingSource.Raw;
-        data: serializers.ClientFacingHypnogramTimeseries.Raw[];
+        source: ClientFacingSource.Raw;
+        data: ClientFacingHypnogramTimeseries.Raw[];
     }
 }

package/dist/serialization/types/GroupedHypnogram.js

@@ -25,19 +25,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupedHypnogram = void 0;
 const core = __importStar(require("../../core"));
+const ClientFacingSource_1 = require("./ClientFacingSource");
+const ClientFacingHypnogramTimeseries_1 = require("./ClientFacingHypnogramTimeseries");
 exports.GroupedHypnogram = core.serialization.object({
-    source: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ClientFacingSource; })),
-    data: core.serialization.list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ClientFacingHypnogramTimeseries; }))),
+    source: ClientFacingSource_1.ClientFacingSource,
+    data: core.serialization.list(ClientFacingHypnogramTimeseries_1.ClientFacingHypnogramTimeseries),
 });

package/dist/serialization/types/GroupedHypnogramResponse.d.ts

@@ -4,10 +4,11 @@
 import * as serializers from "..";
 import * as Vital from "../../api";
 import * as core from "../../core";
+import { GroupedHypnogram } from "./GroupedHypnogram";
 export declare const GroupedHypnogramResponse: core.serialization.ObjectSchema<serializers.GroupedHypnogramResponse.Raw, Vital.GroupedHypnogramResponse>;
 export declare namespace GroupedHypnogramResponse {
     interface Raw {
-        groups: Record<string, serializers.GroupedHypnogram.Raw[]>;
+        groups: Record<string, GroupedHypnogram.Raw[]>;
         next?: string | null;
     }
 }

package/dist/serialization/types/GroupedHypnogramResponse.js

@@ -25,19 +25,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupedHypnogramResponse = void 0;
 const core = __importStar(require("../../core"));
+const GroupedHypnogram_1 = require("./GroupedHypnogram");
 exports.GroupedHypnogramResponse = core.serialization.object({
-    groups: core.serialization.record(core.serialization.string(), core.serialization.list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).GroupedHypnogram; })))),
+    groups: core.serialization.record(core.serialization.string(), core.serialization.list(GroupedHypnogram_1.GroupedHypnogram)),
     next: core.serialization.string().optional(),
 });

package/dist/serialization/types/GroupedIge.d.ts

@@ -4,10 +4,12 @@
 import * as serializers from "..";
 import * as Vital from "../../api";
 import * as core from "../../core";
+import { ClientFacingSource } from "./ClientFacingSource";
+import { ClientFacingIgeTimeseries } from "./ClientFacingIgeTimeseries";
 export declare const GroupedIge: core.serialization.ObjectSchema<serializers.GroupedIge.Raw, Vital.GroupedIge>;
 export declare namespace GroupedIge {
     interface Raw {
-        source: serializers.ClientFacingSource.Raw;
-        data: serializers.ClientFacingIgeTimeseries.Raw[];
+        source: ClientFacingSource.Raw;
+        data: ClientFacingIgeTimeseries.Raw[];
     }
 }

package/dist/serialization/types/GroupedIge.js

@@ -25,19 +25,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupedIge = void 0;
 const core = __importStar(require("../../core"));
+const ClientFacingSource_1 = require("./ClientFacingSource");
+const ClientFacingIgeTimeseries_1 = require("./ClientFacingIgeTimeseries");
 exports.GroupedIge = core.serialization.object({
-    source: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ClientFacingSource; })),
-    data: core.serialization.list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ClientFacingIgeTimeseries; }))),
+    source: ClientFacingSource_1.ClientFacingSource,
+    data: core.serialization.list(ClientFacingIgeTimeseries_1.ClientFacingIgeTimeseries),
 });

package/dist/serialization/types/GroupedIgeResponse.d.ts

@@ -4,10 +4,11 @@
 import * as serializers from "..";
 import * as Vital from "../../api";
 import * as core from "../../core";
+import { GroupedIge } from "./GroupedIge";
 export declare const GroupedIgeResponse: core.serialization.ObjectSchema<serializers.GroupedIgeResponse.Raw, Vital.GroupedIgeResponse>;
 export declare namespace GroupedIgeResponse {
     interface Raw {
-        groups: Record<string, serializers.GroupedIge.Raw[]>;
+        groups: Record<string, GroupedIge.Raw[]>;
         next?: string | null;
     }
 }

package/dist/serialization/types/GroupedIgeResponse.js

@@ -25,19 +25,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupedIgeResponse = void 0;
 const core = __importStar(require("../../core"));
+const GroupedIge_1 = require("./GroupedIge");
 exports.GroupedIgeResponse = core.serialization.object({
-    groups: core.serialization.record(core.serialization.string(), core.serialization.list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).GroupedIge; })))),
+    groups: core.serialization.record(core.serialization.string(), core.serialization.list(GroupedIge_1.GroupedIge)),
     next: core.serialization.string().optional(),
 });

package/dist/serialization/types/GroupedIgg.d.ts

@@ -4,10 +4,12 @@
 import * as serializers from "..";
 import * as Vital from "../../api";
 import * as core from "../../core";
+import { ClientFacingSource } from "./ClientFacingSource";
+import { ClientFacingIggTimeseries } from "./ClientFacingIggTimeseries";
 export declare const GroupedIgg: core.serialization.ObjectSchema<serializers.GroupedIgg.Raw, Vital.GroupedIgg>;
 export declare namespace GroupedIgg {
     interface Raw {
-        source: serializers.ClientFacingSource.Raw;
-        data: serializers.ClientFacingIggTimeseries.Raw[];
+        source: ClientFacingSource.Raw;
+        data: ClientFacingIggTimeseries.Raw[];
     }
 }

package/dist/serialization/types/GroupedIgg.js

@@ -25,19 +25,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupedIgg = void 0;
 const core = __importStar(require("../../core"));
+const ClientFacingSource_1 = require("./ClientFacingSource");
+const ClientFacingIggTimeseries_1 = require("./ClientFacingIggTimeseries");
 exports.GroupedIgg = core.serialization.object({
-    source: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ClientFacingSource; })),
-    data: core.serialization.list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ClientFacingIggTimeseries; }))),
+    source: ClientFacingSource_1.ClientFacingSource,
+    data: core.serialization.list(ClientFacingIggTimeseries_1.ClientFacingIggTimeseries),
 });

package/dist/serialization/types/GroupedIggResponse.d.ts

@@ -4,10 +4,11 @@
 import * as serializers from "..";
 import * as Vital from "../../api";
 import * as core from "../../core";
+import { GroupedIgg } from "./GroupedIgg";
 export declare const GroupedIggResponse: core.serialization.ObjectSchema<serializers.GroupedIggResponse.Raw, Vital.GroupedIggResponse>;
 export declare namespace GroupedIggResponse {
     interface Raw {
-        groups: Record<string, serializers.GroupedIgg.Raw[]>;
+        groups: Record<string, GroupedIgg.Raw[]>;
         next?: string | null;
     }
 }

package/dist/serialization/types/GroupedIggResponse.js

@@ -25,19 +25,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupedIggResponse = void 0;
 const core = __importStar(require("../../core"));
+const GroupedIgg_1 = require("./GroupedIgg");
 exports.GroupedIggResponse = core.serialization.object({
-    groups: core.serialization.record(core.serialization.string(), core.serialization.list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).GroupedIgg; })))),
+    groups: core.serialization.record(core.serialization.string(), core.serialization.list(GroupedIgg_1.GroupedIgg)),
     next: core.serialization.string().optional(),
 });

package/dist/serialization/types/GroupedMindfulnessMinutes.d.ts

@@ -4,10 +4,12 @@
 import * as serializers from "..";
 import * as Vital from "../../api";
 import * as core from "../../core";
+import { ClientFacingSource } from "./ClientFacingSource";
+import { ClientFacingMindfulnessMinutesTimeseries } from "./ClientFacingMindfulnessMinutesTimeseries";
 export declare const GroupedMindfulnessMinutes: core.serialization.ObjectSchema<serializers.GroupedMindfulnessMinutes.Raw, Vital.GroupedMindfulnessMinutes>;
 export declare namespace GroupedMindfulnessMinutes {
     interface Raw {
-        source: serializers.ClientFacingSource.Raw;
-        data: serializers.ClientFacingMindfulnessMinutesTimeseries.Raw[];
+        source: ClientFacingSource.Raw;
+        data: ClientFacingMindfulnessMinutesTimeseries.Raw[];
     }
 }

package/dist/serialization/types/GroupedMindfulnessMinutes.js

@@ -25,19 +25,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupedMindfulnessMinutes = void 0;
 const core = __importStar(require("../../core"));
+const ClientFacingSource_1 = require("./ClientFacingSource");
+const ClientFacingMindfulnessMinutesTimeseries_1 = require("./ClientFacingMindfulnessMinutesTimeseries");
 exports.GroupedMindfulnessMinutes = core.serialization.object({
-    source: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ClientFacingSource; })),
-    data: core.serialization.list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ClientFacingMindfulnessMinutesTimeseries; }))),
+    source: ClientFacingSource_1.ClientFacingSource,
+    data: core.serialization.list(ClientFacingMindfulnessMinutesTimeseries_1.ClientFacingMindfulnessMinutesTimeseries),
 });

package/dist/serialization/types/GroupedMindfulnessMinutesResponse.d.ts

@@ -4,10 +4,11 @@
 import * as serializers from "..";
 import * as Vital from "../../api";
 import * as core from "../../core";
+import { GroupedMindfulnessMinutes } from "./GroupedMindfulnessMinutes";
 export declare const GroupedMindfulnessMinutesResponse: core.serialization.ObjectSchema<serializers.GroupedMindfulnessMinutesResponse.Raw, Vital.GroupedMindfulnessMinutesResponse>;
 export declare namespace GroupedMindfulnessMinutesResponse {
     interface Raw {
-        groups: Record<string, serializers.GroupedMindfulnessMinutes.Raw[]>;
+        groups: Record<string, GroupedMindfulnessMinutes.Raw[]>;
         next?: string | null;
     }
 }

package/dist/serialization/types/GroupedMindfulnessMinutesResponse.js

@@ -25,19 +25,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupedMindfulnessMinutesResponse = void 0;
 const core = __importStar(require("../../core"));
+const GroupedMindfulnessMinutes_1 = require("./GroupedMindfulnessMinutes");
 exports.GroupedMindfulnessMinutesResponse = core.serialization.object({
-    groups: core.serialization.record(core.serialization.string(), core.serialization.list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).GroupedMindfulnessMinutes; })))),
+    groups: core.serialization.record(core.serialization.string(), core.serialization.list(GroupedMindfulnessMinutes_1.GroupedMindfulnessMinutes)),
     next: core.serialization.string().optional(),
 });

package/dist/serialization/types/GroupedRespiratoryRate.d.ts

@@ -4,10 +4,12 @@
 import * as serializers from "..";
 import * as Vital from "../../api";
 import * as core from "../../core";
+import { ClientFacingSource } from "./ClientFacingSource";
+import { ClientFacingRespiratoryRateTimeseries } from "./ClientFacingRespiratoryRateTimeseries";
 export declare const GroupedRespiratoryRate: core.serialization.ObjectSchema<serializers.GroupedRespiratoryRate.Raw, Vital.GroupedRespiratoryRate>;
 export declare namespace GroupedRespiratoryRate {
     interface Raw {
-        source: serializers.ClientFacingSource.Raw;
-        data: serializers.ClientFacingRespiratoryRateTimeseries.Raw[];
+        source: ClientFacingSource.Raw;
+        data: ClientFacingRespiratoryRateTimeseries.Raw[];
     }
 }

package/dist/serialization/types/GroupedRespiratoryRate.js

@@ -25,19 +25,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupedRespiratoryRate = void 0;
 const core = __importStar(require("../../core"));
+const ClientFacingSource_1 = require("./ClientFacingSource");
+const ClientFacingRespiratoryRateTimeseries_1 = require("./ClientFacingRespiratoryRateTimeseries");
 exports.GroupedRespiratoryRate = core.serialization.object({
-    source: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ClientFacingSource; })),
-    data: core.serialization.list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ClientFacingRespiratoryRateTimeseries; }))),
+    source: ClientFacingSource_1.ClientFacingSource,
+    data: core.serialization.list(ClientFacingRespiratoryRateTimeseries_1.ClientFacingRespiratoryRateTimeseries),
 });

package/dist/serialization/types/GroupedRespiratoryRateResponse.d.ts

@@ -4,10 +4,11 @@
 import * as serializers from "..";
 import * as Vital from "../../api";
 import * as core from "../../core";
+import { GroupedRespiratoryRate } from "./GroupedRespiratoryRate";
 export declare const GroupedRespiratoryRateResponse: core.serialization.ObjectSchema<serializers.GroupedRespiratoryRateResponse.Raw, Vital.GroupedRespiratoryRateResponse>;
 export declare namespace GroupedRespiratoryRateResponse {
     interface Raw {
-        groups: Record<string, serializers.GroupedRespiratoryRate.Raw[]>;
+        groups: Record<string, GroupedRespiratoryRate.Raw[]>;
         next?: string | null;
     }
 }

package/dist/serialization/types/GroupedRespiratoryRateResponse.js

@@ -25,19 +25,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupedRespiratoryRateResponse = void 0;
 const core = __importStar(require("../../core"));
+const GroupedRespiratoryRate_1 = require("./GroupedRespiratoryRate");
 exports.GroupedRespiratoryRateResponse = core.serialization.object({
-    groups: core.serialization.record(core.serialization.string(), core.serialization.list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).GroupedRespiratoryRate; })))),
+    groups: core.serialization.record(core.serialization.string(), core.serialization.list(GroupedRespiratoryRate_1.GroupedRespiratoryRate)),
     next: core.serialization.string().optional(),
 });

package/dist/serialization/types/GroupedSteps.d.ts

@@ -4,10 +4,12 @@
 import * as serializers from "..";
 import * as Vital from "../../api";
 import * as core from "../../core";
+import { ClientFacingSource } from "./ClientFacingSource";
+import { ClientFacingStepsTimeseries } from "./ClientFacingStepsTimeseries";
 export declare const GroupedSteps: core.serialization.ObjectSchema<serializers.GroupedSteps.Raw, Vital.GroupedSteps>;
 export declare namespace GroupedSteps {
     interface Raw {
-        source: serializers.ClientFacingSource.Raw;
-        data: serializers.ClientFacingStepsTimeseries.Raw[];
+        source: ClientFacingSource.Raw;
+        data: ClientFacingStepsTimeseries.Raw[];
     }
 }

package/dist/serialization/types/GroupedSteps.js

@@ -25,19 +25,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupedSteps = void 0;
 const core = __importStar(require("../../core"));
+const ClientFacingSource_1 = require("./ClientFacingSource");
+const ClientFacingStepsTimeseries_1 = require("./ClientFacingStepsTimeseries");
 exports.GroupedSteps = core.serialization.object({
-    source: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ClientFacingSource; })),
-    data: core.serialization.list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ClientFacingStepsTimeseries; }))),
+    source: ClientFacingSource_1.ClientFacingSource,
+    data: core.serialization.list(ClientFacingStepsTimeseries_1.ClientFacingStepsTimeseries),
 });

package/dist/serialization/types/GroupedStepsResponse.d.ts

@@ -4,10 +4,11 @@
 import * as serializers from "..";
 import * as Vital from "../../api";
 import * as core from "../../core";
+import { GroupedSteps } from "./GroupedSteps";
 export declare const GroupedStepsResponse: core.serialization.ObjectSchema<serializers.GroupedStepsResponse.Raw, Vital.GroupedStepsResponse>;
 export declare namespace GroupedStepsResponse {
     interface Raw {
-        groups: Record<string, serializers.GroupedSteps.Raw[]>;
+        groups: Record<string, GroupedSteps.Raw[]>;
         next?: string | null;
     }
 }

package/dist/serialization/types/GroupedStepsResponse.js

@@ -25,19 +25,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupedStepsResponse = void 0;
 const core = __importStar(require("../../core"));
+const GroupedSteps_1 = require("./GroupedSteps");
 exports.GroupedStepsResponse = core.serialization.object({
-    groups: core.serialization.record(core.serialization.string(), core.serialization.list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).GroupedSteps; })))),
+    groups: core.serialization.record(core.serialization.string(), core.serialization.list(GroupedSteps_1.GroupedSteps)),
     next: core.serialization.string().optional(),
 });

package/dist/serialization/types/GroupedStressLevel.d.ts

@@ -4,10 +4,12 @@
 import * as serializers from "..";
 import * as Vital from "../../api";
 import * as core from "../../core";
+import { ClientFacingSource } from "./ClientFacingSource";
+import { ClientFacingStressLevelTimeseries } from "./ClientFacingStressLevelTimeseries";
 export declare const GroupedStressLevel: core.serialization.ObjectSchema<serializers.GroupedStressLevel.Raw, Vital.GroupedStressLevel>;
 export declare namespace GroupedStressLevel {
     interface Raw {
-        source: serializers.ClientFacingSource.Raw;
-        data: serializers.ClientFacingStressLevelTimeseries.Raw[];
+        source: ClientFacingSource.Raw;
+        data: ClientFacingStressLevelTimeseries.Raw[];
     }
 }

package/dist/serialization/types/GroupedStressLevel.js

@@ -25,19 +25,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupedStressLevel = void 0;
 const core = __importStar(require("../../core"));
+const ClientFacingSource_1 = require("./ClientFacingSource");
+const ClientFacingStressLevelTimeseries_1 = require("./ClientFacingStressLevelTimeseries");
 exports.GroupedStressLevel = core.serialization.object({
-    source: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ClientFacingSource; })),
-    data: core.serialization.list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ClientFacingStressLevelTimeseries; }))),
+    source: ClientFacingSource_1.ClientFacingSource,
+    data: core.serialization.list(ClientFacingStressLevelTimeseries_1.ClientFacingStressLevelTimeseries),
 });

package/dist/serialization/types/GroupedStressLevelResponse.d.ts

@@ -4,10 +4,11 @@
 import * as serializers from "..";
 import * as Vital from "../../api";
 import * as core from "../../core";
+import { GroupedStressLevel } from "./GroupedStressLevel";
 export declare const GroupedStressLevelResponse: core.serialization.ObjectSchema<serializers.GroupedStressLevelResponse.Raw, Vital.GroupedStressLevelResponse>;
 export declare namespace GroupedStressLevelResponse {
     interface Raw {
-        groups: Record<string, serializers.GroupedStressLevel.Raw[]>;
+        groups: Record<string, GroupedStressLevel.Raw[]>;
         next?: string | null;
     }
 }

package/dist/serialization/types/GroupedStressLevelResponse.js

@@ -25,19 +25,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupedStressLevelResponse = void 0;
 const core = __importStar(require("../../core"));
+const GroupedStressLevel_1 = require("./GroupedStressLevel");
 exports.GroupedStressLevelResponse = core.serialization.object({
-    groups: core.serialization.record(core.serialization.string(), core.serialization.list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).GroupedStressLevel; })))),
+    groups: core.serialization.record(core.serialization.string(), core.serialization.list(GroupedStressLevel_1.GroupedStressLevel)),
     next: core.serialization.string().optional(),
 });

package/dist/serialization/types/GroupedVo2Max.d.ts

@@ -4,10 +4,12 @@
 import * as serializers from "..";
 import * as Vital from "../../api";
 import * as core from "../../core";
+import { ClientFacingSource } from "./ClientFacingSource";
+import { ClientFacingVo2MaxTimeseries } from "./ClientFacingVo2MaxTimeseries";
 export declare const GroupedVo2Max: core.serialization.ObjectSchema<serializers.GroupedVo2Max.Raw, Vital.GroupedVo2Max>;
 export declare namespace GroupedVo2Max {
     interface Raw {
-        source: serializers.ClientFacingSource.Raw;
-        data: serializers.ClientFacingVo2MaxTimeseries.Raw[];
+        source: ClientFacingSource.Raw;
+        data: ClientFacingVo2MaxTimeseries.Raw[];
     }
 }

package/dist/serialization/types/GroupedVo2Max.js

@@ -25,19 +25,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupedVo2Max = void 0;
 const core = __importStar(require("../../core"));
+const ClientFacingSource_1 = require("./ClientFacingSource");
+const ClientFacingVo2MaxTimeseries_1 = require("./ClientFacingVo2MaxTimeseries");
 exports.GroupedVo2Max = core.serialization.object({
-    source: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ClientFacingSource; })),
-    data: core.serialization.list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ClientFacingVo2MaxTimeseries; }))),
+    source: ClientFacingSource_1.ClientFacingSource,
+    data: core.serialization.list(ClientFacingVo2MaxTimeseries_1.ClientFacingVo2MaxTimeseries),
 });