@ovok/core 0.4.49-dev.495 → 0.4.49-dev.496

package/dist/next/resources/slim/slim-patient-thresholds-resource.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlimPatientThresholdsResource = void 0;
+const url_1 = require("../../http/url");
+const slim_paths_1 = require("./slim-paths");
+const PATIENT_THRESHOLDS_PATH = `${slim_paths_1.THRESHOLD_V2_PATH}/patient`;
+const patientThresholdPath = (patientId) => `${PATIENT_THRESHOLDS_PATH}/${(0, url_1.pathSegment)(patientId)}`;
+class SlimPatientThresholdsResource {
+    constructor(http) {
+        this.http = http;
+    }
+    retrieve(patientId, options) {
+        return this.http.get(patientThresholdPath(patientId), options);
+    }
+    /** Never retried: a 409 means another save for this resident is running and nothing changed. */
+    update(patientId, body, options) {
+        return this.http.send({ method: "PUT", path: patientThresholdPath(patientId), body, idempotent: false }, options);
+    }
+}
+exports.SlimPatientThresholdsResource = SlimPatientThresholdsResource;

package/dist/next/resources/slim/slim-patients-resource.d.ts

@@ -0,0 +1,20 @@
+import type { SlimCreatePatient, SlimPatient, SlimPatientListItem, SlimPatientListQuery, SlimUpdatePatient } from "../../../client/slim/types";
+import type { Bundle, Resource } from "@medplum/fhirtypes";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { PagePromise } from "../../paging/page";
+import { SlimPatientThresholdsResource } from "./slim-patient-thresholds-resource";
+export declare class SlimPatientsResource {
+    private readonly http;
+    readonly thresholds: SlimPatientThresholdsResource;
+    constructor(http: HttpClient);
+    list(params?: SlimPatientListQuery, options?: RequestOptions): PagePromise<SlimPatientListItem>;
+    retrieve(patientId: string, options?: RequestOptions): Promise<SlimPatient>;
+    create(body: SlimCreatePatient, options?: RequestOptions): Promise<SlimPatient>;
+    /** Replaces the editable fields: omitting locationId unassigns the resident's devices. */
+    update(patientId: string, body: SlimUpdatePatient, options?: RequestOptions): Promise<SlimPatient>;
+    /** 409 while the resident has a device: unassign it first with an update that omits locationId. */
+    delete(patientId: string, options?: RequestOptions): Promise<void>;
+    everything(patientId: string, options?: RequestOptions): Promise<Bundle<Resource>>;
+    currentVitals(patientId: string, options?: RequestOptions): Promise<Record<string, unknown>>;
+}

package/dist/next/resources/slim/slim-patients-resource.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlimPatientsResource = void 0;
+const url_1 = require("../../http/url");
+const numbered_pages_1 = require("../../paging/numbered-pages");
+const slim_paths_1 = require("./slim-paths");
+const slim_patient_thresholds_resource_1 = require("./slim-patient-thresholds-resource");
+const PATIENTS_PATH = `${slim_paths_1.SLIM_PATH}/patient`;
+const patientPath = (patientId) => `${PATIENTS_PATH}/${(0, url_1.pathSegment)(patientId)}`;
+class SlimPatientsResource {
+    constructor(http) {
+        this.http = http;
+        this.thresholds = new slim_patient_thresholds_resource_1.SlimPatientThresholdsResource(http);
+    }
+    list(params = {}, options) {
+        return (0, numbered_pages_1.numberedRoutePages)((path) => this.http.get(path, options), PATIENTS_PATH, params);
+    }
+    retrieve(patientId, options) {
+        return this.http.get(patientPath(patientId), options);
+    }
+    create(body, options) {
+        return this.http.post(PATIENTS_PATH, body, options);
+    }
+    /** Replaces the editable fields: omitting locationId unassigns the resident's devices. */
+    update(patientId, body, options) {
+        return this.http.put(patientPath(patientId), body, options);
+    }
+    /** 409 while the resident has a device: unassign it first with an update that omits locationId. */
+    delete(patientId, options) {
+        return this.http.delete(patientPath(patientId), options);
+    }
+    everything(patientId, options) {
+        return this.http.get(`${patientPath(patientId)}/$everything`, options);
+    }
+    currentVitals(patientId, options) {
+        return this.http.get(`${patientPath(patientId)}/current-vitals`, options);
+    }
+}
+exports.SlimPatientsResource = SlimPatientsResource;

package/dist/next/resources/slim/slim-policies-resource.d.ts

@@ -0,0 +1,12 @@
+import type { SlimCreatePolicy, SlimPolicyList, SlimPolicyListQuery, SlimPolicyResponse, SlimUpdatePolicy } from "../../../client/slim/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export declare class SlimPoliciesResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(params?: SlimPolicyListQuery, options?: RequestOptions): Promise<SlimPolicyList>;
+    retrieve(policyId: string, options?: RequestOptions): Promise<SlimPolicyResponse>;
+    create(body: SlimCreatePolicy, options?: RequestOptions): Promise<SlimPolicyResponse>;
+    update(policyId: string, body: SlimUpdatePolicy, options?: RequestOptions): Promise<SlimPolicyResponse>;
+    delete(policyId: string, options?: RequestOptions): Promise<void>;
+}

package/dist/next/resources/slim/slim-policies-resource.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlimPoliciesResource = void 0;
+const query_string_1 = require("../../../client/query-string");
+const url_1 = require("../../http/url");
+const slim_paths_1 = require("./slim-paths");
+const POLICIES_PATH = `${slim_paths_1.SLIM_PATH}/policy`;
+const policyPath = (policyId) => `${POLICIES_PATH}/${(0, url_1.pathSegment)(policyId)}`;
+class SlimPoliciesResource {
+    constructor(http) {
+        this.http = http;
+    }
+    list(params = {}, options) {
+        return this.http.get(`${POLICIES_PATH}${(0, query_string_1.toQueryString)(params)}`, options);
+    }
+    retrieve(policyId, options) {
+        return this.http.get(policyPath(policyId), options);
+    }
+    create(body, options) {
+        return this.http.post(POLICIES_PATH, body, options);
+    }
+    update(policyId, body, options) {
+        return this.http.put(policyPath(policyId), body, options);
+    }
+    delete(policyId, options) {
+        return this.http.delete(policyPath(policyId), options);
+    }
+}
+exports.SlimPoliciesResource = SlimPoliciesResource;

package/dist/next/resources/slim/slim-practitioners-resource.d.ts

@@ -0,0 +1,8 @@
+import type { SlimPractitionerInviteInput, SlimPractitionerInviteResponse } from "../../../client/slim/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export declare class SlimPractitionersResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    invite(body: SlimPractitionerInviteInput, options?: RequestOptions): Promise<SlimPractitionerInviteResponse>;
+}

package/dist/next/resources/slim/slim-practitioners-resource.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlimPractitionersResource = void 0;
+const slim_paths_1 = require("./slim-paths");
+const INVITE_PRACTITIONER_PATH = `${slim_paths_1.SLIM_PATH}/invite/practitioner`;
+class SlimPractitionersResource {
+    constructor(http) {
+        this.http = http;
+    }
+    invite(body, options) {
+        return this.http.post(INVITE_PRACTITIONER_PATH, body, options);
+    }
+}
+exports.SlimPractitionersResource = SlimPractitionersResource;

package/dist/next/resources/slim/slim-projects-resource.d.ts

@@ -0,0 +1,16 @@
+import type { SlimChildProjectInput, SlimProject, SlimProjectDeviceCounts, SlimProjectPatientCounts, SlimProjectUser, SlimProjectUsersQuery } from "../../../client/slim/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { PagePromise } from "../../paging/page";
+import { SlimChildProjectsResource } from "./slim-child-projects-resource";
+export declare class SlimProjectsResource {
+    private readonly http;
+    readonly children: SlimChildProjectsResource;
+    constructor(http: HttpClient);
+    retrieve(projectId: string, options?: RequestOptions): Promise<SlimProject>;
+    update(projectId: string, body: SlimChildProjectInput, options?: RequestOptions): Promise<SlimProject>;
+    users(projectId: string, params?: SlimProjectUsersQuery, options?: RequestOptions): PagePromise<SlimProjectUser>;
+    currentUsers(params?: SlimProjectUsersQuery, options?: RequestOptions): PagePromise<SlimProjectUser>;
+    deviceCounts(projectId: string, options?: RequestOptions): Promise<SlimProjectDeviceCounts>;
+    patientCounts(projectId: string, options?: RequestOptions): Promise<SlimProjectPatientCounts>;
+}

package/dist/next/resources/slim/slim-projects-resource.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlimProjectsResource = void 0;
+const url_1 = require("../../http/url");
+const numbered_pages_1 = require("../../paging/numbered-pages");
+const slim_child_projects_resource_1 = require("./slim-child-projects-resource");
+const slim_paths_1 = require("./slim-paths");
+const USERS = "users";
+const CURRENT_USERS_PATH = `${slim_paths_1.PROJECT_PATH}/${USERS}`;
+const projectPath = (projectId) => `${slim_paths_1.PROJECT_PATH}/${(0, url_1.pathSegment)(projectId)}`;
+class SlimProjectsResource {
+    constructor(http) {
+        this.http = http;
+        this.children = new slim_child_projects_resource_1.SlimChildProjectsResource(http);
+    }
+    retrieve(projectId, options) {
+        return this.http.get(projectPath(projectId), options);
+    }
+    update(projectId, body, options) {
+        return this.http.put(projectPath(projectId), body, options);
+    }
+    users(projectId, params = {}, options) {
+        return (0, numbered_pages_1.numberedRoutePages)((path) => this.http.get(path, options), `${projectPath(projectId)}/${USERS}`, params);
+    }
+    currentUsers(params = {}, options) {
+        return (0, numbered_pages_1.numberedRoutePages)((path) => this.http.get(path, options), CURRENT_USERS_PATH, params);
+    }
+    deviceCounts(projectId, options) {
+        return this.http.get(`${projectPath(projectId)}/device-counts`, options);
+    }
+    patientCounts(projectId, options) {
+        return this.http.get(`${projectPath(projectId)}/patient-counts`, options);
+    }
+}
+exports.SlimProjectsResource = SlimProjectsResource;

package/dist/next/resources/slim/slim-queries.d.ts

@@ -0,0 +1,34 @@
+import type { SlimGraphType, SlimHistoricalGraphType } from "../../../client/slim/types";
+export type SlimRecentQuery = {
+    count?: number;
+};
+export type SlimTrendsQuery = {
+    patientId: string;
+    startDate: string;
+    endDate: string;
+    graphType: SlimHistoricalGraphType | readonly SlimHistoricalGraphType[];
+};
+export type SlimRealtimeTrendsQuery = {
+    patientId: string;
+    startTime: string;
+    endTime: string;
+    graphType: SlimGraphType | readonly SlimGraphType[];
+};
+export type SlimSleepStatisticsQuery = {
+    endDate: string;
+    lastDayCount?: number;
+    patientId: string;
+};
+export type SlimZoneListQuery = {
+    page?: number;
+    count?: number;
+    sortBy?: string;
+    orderBy?: "ASC" | "DESC";
+    search?: string;
+};
+export type SlimZoneDeviceCountsQuery = {
+    all?: boolean;
+    effectiveSleepStatus?: string;
+    includeUnassigned?: boolean;
+    includeEmpty?: boolean;
+};

package/dist/next/resources/slim/slim-queries.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/next/resources/slim/slim-resource.d.ts

@@ -0,0 +1,38 @@
+import type { SlimHealth } from "../../../client/slim/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { SlimChangeHistoryResource } from "./slim-change-history-resource";
+import { SlimDevicesResource } from "./slim-devices-resource";
+import { SlimExportsResource } from "./slim-exports-resource";
+import { SlimLocationsResource } from "./slim-locations-resource";
+import { SlimNotificationsResource } from "./slim-notifications-resource";
+import { SlimOrganizationsResource } from "./slim-organizations-resource";
+import { SlimPatientsResource } from "./slim-patients-resource";
+import { SlimPoliciesResource } from "./slim-policies-resource";
+import { SlimPractitionersResource } from "./slim-practitioners-resource";
+import { SlimProjectsResource } from "./slim-projects-resource";
+import { SlimSleepResource } from "./slim-sleep-resource";
+import { SlimThresholdsResource } from "./slim-thresholds-resource";
+import { SlimTrendsResource } from "./slim-trends-resource";
+import { SlimUsersResource } from "./slim-users-resource";
+import { SlimZonesResource } from "./slim-zones-resource";
+export declare class SlimResource {
+    private readonly http;
+    readonly patients: SlimPatientsResource;
+    readonly devices: SlimDevicesResource;
+    readonly notifications: SlimNotificationsResource;
+    readonly thresholds: SlimThresholdsResource;
+    readonly trends: SlimTrendsResource;
+    readonly sleep: SlimSleepResource;
+    readonly locations: SlimLocationsResource;
+    readonly zones: SlimZonesResource;
+    readonly exports: SlimExportsResource;
+    readonly changeHistory: SlimChangeHistoryResource;
+    readonly projects: SlimProjectsResource;
+    readonly policies: SlimPoliciesResource;
+    readonly organizations: SlimOrganizationsResource;
+    readonly practitioners: SlimPractitionersResource;
+    readonly users: SlimUsersResource;
+    constructor(http: HttpClient);
+    health(options?: RequestOptions): Promise<SlimHealth>;
+}

package/dist/next/resources/slim/slim-resource.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlimResource = void 0;
+const slim_change_history_resource_1 = require("./slim-change-history-resource");
+const slim_devices_resource_1 = require("./slim-devices-resource");
+const slim_exports_resource_1 = require("./slim-exports-resource");
+const slim_locations_resource_1 = require("./slim-locations-resource");
+const slim_notifications_resource_1 = require("./slim-notifications-resource");
+const slim_organizations_resource_1 = require("./slim-organizations-resource");
+const slim_paths_1 = require("./slim-paths");
+const slim_patients_resource_1 = require("./slim-patients-resource");
+const slim_policies_resource_1 = require("./slim-policies-resource");
+const slim_practitioners_resource_1 = require("./slim-practitioners-resource");
+const slim_projects_resource_1 = require("./slim-projects-resource");
+const slim_sleep_resource_1 = require("./slim-sleep-resource");
+const slim_thresholds_resource_1 = require("./slim-thresholds-resource");
+const slim_trends_resource_1 = require("./slim-trends-resource");
+const slim_users_resource_1 = require("./slim-users-resource");
+const slim_zones_resource_1 = require("./slim-zones-resource");
+const HEALTH_PATH = `${slim_paths_1.SLIM_PATH}/health`;
+class SlimResource {
+    constructor(http) {
+        this.http = http;
+        this.patients = new slim_patients_resource_1.SlimPatientsResource(http);
+        this.devices = new slim_devices_resource_1.SlimDevicesResource(http);
+        this.notifications = new slim_notifications_resource_1.SlimNotificationsResource(http);
+        this.thresholds = new slim_thresholds_resource_1.SlimThresholdsResource(http);
+        this.trends = new slim_trends_resource_1.SlimTrendsResource(http);
+        this.sleep = new slim_sleep_resource_1.SlimSleepResource(http);
+        this.locations = new slim_locations_resource_1.SlimLocationsResource(http);
+        this.zones = new slim_zones_resource_1.SlimZonesResource(http);
+        this.exports = new slim_exports_resource_1.SlimExportsResource(http);
+        this.changeHistory = new slim_change_history_resource_1.SlimChangeHistoryResource(http);
+        this.projects = new slim_projects_resource_1.SlimProjectsResource(http);
+        this.policies = new slim_policies_resource_1.SlimPoliciesResource(http);
+        this.organizations = new slim_organizations_resource_1.SlimOrganizationsResource(http);
+        this.practitioners = new slim_practitioners_resource_1.SlimPractitionersResource(http);
+        this.users = new slim_users_resource_1.SlimUsersResource(http);
+    }
+    health(options) {
+        return this.http.get(HEALTH_PATH, options);
+    }
+}
+exports.SlimResource = SlimResource;

package/dist/next/resources/slim/slim-sleep-resource.d.ts

@@ -0,0 +1,9 @@
+import type { SlimSleepStatistics } from "../../../client/slim/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { SlimSleepStatisticsQuery } from "./slim-queries";
+export declare class SlimSleepResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    statistics(params: SlimSleepStatisticsQuery, options?: RequestOptions): Promise<SlimSleepStatistics>;
+}

package/dist/next/resources/slim/slim-sleep-resource.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlimSleepResource = void 0;
+const query_string_1 = require("../../../client/query-string");
+const slim_paths_1 = require("./slim-paths");
+const SLEEP_STATISTICS_PATH = `${slim_paths_1.SLIM_PATH}/sleep/statistics`;
+class SlimSleepResource {
+    constructor(http) {
+        this.http = http;
+    }
+    statistics(params, options) {
+        return this.http.get(`${SLEEP_STATISTICS_PATH}${(0, query_string_1.toQueryString)(params)}`, options);
+    }
+}
+exports.SlimSleepResource = SlimSleepResource;

package/dist/next/resources/slim/slim-thresholds-resource.d.ts

@@ -0,0 +1,11 @@
+import type { SlimThresholdV2, SlimThresholdV2Update } from "../../../client/slim/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export declare class SlimThresholdsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /** A home with no stored limits reads as the default template, not as unset. */
+    retrieve(options?: RequestOptions): Promise<SlimThresholdV2>;
+    /** Never retried: a 502 means Signals did not take every resident's limits and nothing was written. */
+    update(body: SlimThresholdV2Update, options?: RequestOptions): Promise<SlimThresholdV2>;
+}

package/dist/next/resources/slim/slim-thresholds-resource.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlimThresholdsResource = void 0;
+const slim_paths_1 = require("./slim-paths");
+class SlimThresholdsResource {
+    constructor(http) {
+        this.http = http;
+    }
+    /** A home with no stored limits reads as the default template, not as unset. */
+    retrieve(options) {
+        return this.http.get(slim_paths_1.THRESHOLD_V2_PATH, options);
+    }
+    /** Never retried: a 502 means Signals did not take every resident's limits and nothing was written. */
+    update(body, options) {
+        return this.http.send({ method: "PUT", path: slim_paths_1.THRESHOLD_V2_PATH, body, idempotent: false }, options);
+    }
+}
+exports.SlimThresholdsResource = SlimThresholdsResource;

package/dist/next/resources/slim/slim-trends-resource.d.ts

@@ -0,0 +1,11 @@
+import type { SlimTrends } from "../../../client/slim/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { SlimRealtimeTrendsQuery, SlimTrendsQuery } from "./slim-queries";
+export declare class SlimTrendsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    graphs(params: SlimTrendsQuery, options?: RequestOptions): Promise<SlimTrends>;
+    /** At most 20 calls per minute per caller: load once per view and wait retryAfterMs after a 503. */
+    realtime(params: SlimRealtimeTrendsQuery, options?: RequestOptions): Promise<SlimTrends>;
+}

package/dist/next/resources/slim/slim-trends-resource.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlimTrendsResource = void 0;
+const query_string_1 = require("../../../client/query-string");
+const slim_paths_1 = require("./slim-paths");
+const TRENDS_PATH = `${slim_paths_1.SLIM_PATH}/trends`;
+class SlimTrendsResource {
+    constructor(http) {
+        this.http = http;
+    }
+    graphs(params, options) {
+        return this.http.get(`${TRENDS_PATH}/graphs${(0, query_string_1.toQueryString)(params)}`, options);
+    }
+    /** At most 20 calls per minute per caller: load once per view and wait retryAfterMs after a 503. */
+    realtime(params, options) {
+        return this.http.get(`${TRENDS_PATH}/realtime${(0, query_string_1.toQueryString)(params)}`, options);
+    }
+}
+exports.SlimTrendsResource = SlimTrendsResource;

package/dist/next/resources/slim/slim-users-resource.d.ts

@@ -0,0 +1,11 @@
+import type { SlimUserProfileType } from "../../../client/slim/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export type SlimUserDeleted = {
+    success: boolean;
+};
+export declare class SlimUsersResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    delete(profileType: SlimUserProfileType, profileId: string, options?: RequestOptions): Promise<SlimUserDeleted>;
+}

package/dist/next/resources/slim/slim-users-resource.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlimUsersResource = void 0;
+const url_1 = require("../../http/url");
+const slim_paths_1 = require("./slim-paths");
+const USERS_PATH = `${slim_paths_1.SLIM_PATH}/user`;
+class SlimUsersResource {
+    constructor(http) {
+        this.http = http;
+    }
+    delete(profileType, profileId, options) {
+        return this.http.delete(`${USERS_PATH}/${(0, url_1.pathSegment)(profileType)}/${(0, url_1.pathSegment)(profileId)}`, options);
+    }
+}
+exports.SlimUsersResource = SlimUsersResource;

package/dist/next/resources/slim/slim-zones-resource.d.ts

@@ -0,0 +1,12 @@
+import type { SlimZone, SlimZoneDetail } from "../../../client/slim/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { PagePromise } from "../../paging/page";
+import { SlimZoneDeviceCountsQuery, SlimZoneListQuery } from "./slim-queries";
+export declare class SlimZonesResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(params?: SlimZoneListQuery, options?: RequestOptions): PagePromise<SlimZone>;
+    retrieve(zoneId: string, options?: RequestOptions): Promise<SlimZoneDetail>;
+    deviceCounts(params?: SlimZoneDeviceCountsQuery, options?: RequestOptions): Promise<Record<string, unknown>>;
+}

package/dist/next/resources/slim/slim-zones-resource.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlimZonesResource = void 0;
+const query_string_1 = require("../../../client/query-string");
+const url_1 = require("../../http/url");
+const numbered_pages_1 = require("../../paging/numbered-pages");
+const slim_paths_1 = require("./slim-paths");
+const ZONES_PATH = `${slim_paths_1.SLIM_PATH}/zones`;
+const DEVICE_COUNTS_PATH = `${ZONES_PATH}/device-counts`;
+class SlimZonesResource {
+    constructor(http) {
+        this.http = http;
+    }
+    list(params = {}, options) {
+        return (0, numbered_pages_1.numberedRoutePages)((path) => this.http.get(path, options), ZONES_PATH, params);
+    }
+    retrieve(zoneId, options) {
+        return this.http.get(`${ZONES_PATH}/${(0, url_1.pathSegment)(zoneId)}`, options);
+    }
+    deviceCounts(params = {}, options) {
+        return this.http.get(`${DEVICE_COUNTS_PATH}${(0, query_string_1.toQueryString)(params)}`, options);
+    }
+}
+exports.SlimZonesResource = SlimZonesResource;

package/dist/next/resources/video-calls/video-call-access-resource.d.ts

@@ -0,0 +1,11 @@
+import type { OvokVideoCallAccess, OvokVideoCallGuestAccess } from "../../../client/experience/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export type VideoCallAccessPermission = Record<string, unknown>;
+export declare class VideoCallAccessResource {
+    private readonly livekit;
+    constructor(livekit: HttpClient);
+    permission(appointmentId: string, options?: RequestOptions): Promise<VideoCallAccessPermission>;
+    createGuest(appointmentId: string, body: OvokVideoCallGuestAccess, options?: RequestOptions): Promise<OvokVideoCallAccess>;
+    createUser(appointmentId: string, options?: RequestOptions): Promise<OvokVideoCallAccess>;
+}

package/dist/next/resources/video-calls/video-call-access-resource.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VideoCallAccessResource = void 0;
+const url_1 = require("../../http/url");
+class VideoCallAccessResource {
+    constructor(livekit) {
+        this.livekit = livekit;
+    }
+    permission(appointmentId, options) {
+        return this.livekit.get(`access-permission/${(0, url_1.pathSegment)(appointmentId)}`, options);
+    }
+    createGuest(appointmentId, body, options) {
+        return this.livekit.post(`guest-access/${(0, url_1.pathSegment)(appointmentId)}`, body, options);
+    }
+    createUser(appointmentId, options) {
+        return this.livekit.post(`user-access/${(0, url_1.pathSegment)(appointmentId)}`, undefined, options);
+    }
+}
+exports.VideoCallAccessResource = VideoCallAccessResource;

package/dist/next/resources/video-calls/video-call-appointments-resource.d.ts

@@ -0,0 +1,10 @@
+import type { OvokVideoCallAppointment, OvokVideoCallAppointmentInput, OvokVideoCallAppointmentQuery } from "../../../client/experience/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export declare class VideoCallAppointmentsResource {
+    private readonly livekit;
+    constructor(livekit: HttpClient);
+    list(params?: OvokVideoCallAppointmentQuery, options?: RequestOptions): Promise<OvokVideoCallAppointment[]>;
+    create(body: OvokVideoCallAppointmentInput, options?: RequestOptions): Promise<OvokVideoCallAppointment>;
+    update(appointmentId: string, body: OvokVideoCallAppointmentInput, options?: RequestOptions): Promise<OvokVideoCallAppointment>;
+}

package/dist/next/resources/video-calls/video-call-appointments-resource.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VideoCallAppointmentsResource = void 0;
+const query_string_1 = require("../../../client/query-string");
+const url_1 = require("../../http/url");
+const APPOINTMENT_PATH = "appointment";
+class VideoCallAppointmentsResource {
+    constructor(livekit) {
+        this.livekit = livekit;
+    }
+    list(params = {}, options) {
+        return this.livekit.get(`${APPOINTMENT_PATH}${(0, query_string_1.toQueryString)(params)}`, options);
+    }
+    create(body, options) {
+        return this.livekit.post(APPOINTMENT_PATH, body, options);
+    }
+    update(appointmentId, body, options) {
+        return this.livekit.put(`${APPOINTMENT_PATH}/${(0, url_1.pathSegment)(appointmentId)}`, body, options);
+    }
+}
+exports.VideoCallAppointmentsResource = VideoCallAppointmentsResource;

package/dist/next/resources/video-calls/video-call-emails-resource.d.ts

@@ -0,0 +1,10 @@
+import type { OvokVideoCallMailRequest, OvokVideoCallMailResponse } from "../../../client/experience/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export declare class VideoCallEmailsResource {
+    private readonly livekit;
+    constructor(livekit: HttpClient);
+    invite(body: OvokVideoCallMailRequest, options?: RequestOptions): Promise<OvokVideoCallMailResponse>;
+    update(body: OvokVideoCallMailRequest, options?: RequestOptions): Promise<OvokVideoCallMailResponse>;
+    cancel(body: OvokVideoCallMailRequest, options?: RequestOptions): Promise<OvokVideoCallMailResponse>;
+}

package/dist/next/resources/video-calls/video-call-emails-resource.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VideoCallEmailsResource = void 0;
+const MAIL_PATH = "mail";
+class VideoCallEmailsResource {
+    constructor(livekit) {
+        this.livekit = livekit;
+    }
+    invite(body, options) {
+        return this.livekit.post(`${MAIL_PATH}/invite`, body, options);
+    }
+    update(body, options) {
+        return this.livekit.post(`${MAIL_PATH}/update`, body, options);
+    }
+    cancel(body, options) {
+        return this.livekit.post(`${MAIL_PATH}/cancel`, body, options);
+    }
+}
+exports.VideoCallEmailsResource = VideoCallEmailsResource;

package/dist/next/resources/video-calls/video-calls-resource.d.ts

@@ -0,0 +1,14 @@
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { VideoCallAccessResource } from "./video-call-access-resource";
+import { VideoCallAppointmentsResource } from "./video-call-appointments-resource";
+import { VideoCallEmailsResource } from "./video-call-emails-resource";
+export type ActiveCallNotification = Record<string, unknown>;
+export declare class VideoCallsResource {
+    readonly appointments: VideoCallAppointmentsResource;
+    readonly access: VideoCallAccessResource;
+    readonly emails: VideoCallEmailsResource;
+    private readonly livekit;
+    constructor(http: HttpClient);
+    notifyActive(appointmentId: string, options?: RequestOptions): Promise<ActiveCallNotification>;
+}

package/dist/next/resources/video-calls/video-calls-resource.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VideoCallsResource = void 0;
+const url_1 = require("../../http/url");
+const video_call_access_resource_1 = require("./video-call-access-resource");
+const video_call_appointments_resource_1 = require("./video-call-appointments-resource");
+const video_call_emails_resource_1 = require("./video-call-emails-resource");
+const LIVEKIT_PATH = "video-call/livekit";
+class VideoCallsResource {
+    constructor(http) {
+        this.livekit = http.under(LIVEKIT_PATH);
+        this.appointments = new video_call_appointments_resource_1.VideoCallAppointmentsResource(this.livekit);
+        this.access = new video_call_access_resource_1.VideoCallAccessResource(this.livekit);
+        this.emails = new video_call_emails_resource_1.VideoCallEmailsResource(this.livekit);
+    }
+    notifyActive(appointmentId, options) {
+        return this.livekit.post(`notification/active-call/${(0, url_1.pathSegment)(appointmentId)}`, undefined, options);
+    }
+}
+exports.VideoCallsResource = VideoCallsResource;