@ovok/core 0.4.30 → 0.4.32

package/dist/client/slim/types.d.ts

@@ -271,10 +271,19 @@ export type SlimTrendPoint = {
     deviceModel?: string;
     deviceId?: string;
 };
-export type SlimTrends = {
-    heartRate?: Record<string, SlimTrendPoint[]>;
-    respiratoryRate?: Record<string, SlimTrendPoint[]>;
+export type SlimGraphType = "heartRate" | "respiratoryRate" | "oxygenSaturation" | "pulseRate" | "perfusionIndex" | "bodyTemperature" | "systolicBloodPressure" | "diastolicBloodPressure" | "heartRateVariability";
+export type SlimHistoricalGraphType = "heartRate" | "respiratoryRate";
+export type SlimTrendStats = {
+    average: number | null;
+    max: number | null;
+    min: number | null;
+    total: number;
+};
+export type SlimTrendDeviceData = {
+    dataPoints: SlimTrendPoint[];
+    stats: SlimTrendStats;
 };
+export type SlimTrends = Partial<Record<SlimGraphType, Record<string, SlimTrendDeviceData>>>;
 export type SlimSleepMetric = {
     current: number | string | null;
     average: number | string | null;
@@ -360,3 +369,361 @@ export type SlimExportPdfRequest = {
         end: string;
     };
 };
+export type SlimProjectAddress = {
+    use?: "work" | "temp" | "old" | "billing";
+    type?: "postal" | "physical" | "both";
+    text?: string;
+    line?: string[];
+    city?: string;
+    district?: string;
+    state?: string;
+    postalCode?: string;
+    country?: string;
+};
+export type SlimProjectContact = {
+    telecom?: Array<{
+        system?: "email" | "phone" | "fax" | "pager" | "url" | "sms" | "other";
+        use?: "work" | "temp" | "old" | "mobile";
+        value?: string;
+    }>;
+    name?: {
+        use?: "temp" | "old" | "official" | "usual" | "nickname" | "anonymous" | "maiden";
+        prefix?: string[];
+        given?: string[];
+        family?: string;
+        suffix?: string[];
+    };
+    address?: SlimProjectAddress;
+};
+export type SlimProject = {
+    resourceType: "Project";
+    id: string;
+    name: string;
+    address?: SlimProjectAddress[];
+    contact?: SlimProjectContact[];
+    settings?: {
+        timeZone?: string;
+        trendsPeriod?: {
+            start: string;
+            durationSeconds: number;
+        };
+    };
+};
+export type SlimProjectRelationships = {
+    currentProject: SlimProject | null;
+    parentProject: SlimProject | null;
+    childProjects: SlimProject[];
+};
+export type SlimProjectRelationshipsV2 = {
+    currentProject: (SlimProject & {
+        deviceCount: number;
+    }) | null;
+    parentProject: (SlimProject & {
+        deviceCount: number;
+    }) | null;
+    childProjects: Array<SlimProject & {
+        deviceCount: number;
+    }>;
+};
+export type SlimChildProjectInput = {
+    id?: string;
+    name: string;
+    address?: SlimProjectAddress[];
+    contact?: SlimProjectContact[];
+    extension?: unknown;
+    settings?: SlimProject["settings"];
+};
+export type SlimProjectUsersQuery = {
+    profileType?: "Practitioner";
+    sortBy?: "profileName" | "userName" | "accessPolicyName";
+    orderBy?: "ASC" | "DESC";
+    search?: string;
+    accessPolicyId?: string;
+    profileId?: string;
+    userId?: string;
+    page?: number;
+    count?: number;
+};
+export type SlimProjectUser = {
+    user: {
+        resourceType: "User";
+        id: string;
+        firstName?: string;
+        lastName?: string;
+        email?: string;
+        project?: {
+            reference?: string;
+            display?: string;
+        };
+        meta?: {
+            project?: string;
+            lastUpdated?: string;
+        };
+    };
+    profile: {
+        resourceType: "Practitioner";
+        id: string;
+        name?: Array<{
+            use?: string;
+            text?: string;
+            family?: string;
+            given?: string[];
+            prefix?: string[];
+            suffix?: string[];
+        }>;
+        meta?: {
+            project?: string;
+            lastUpdated?: string;
+        };
+    };
+    membership: {
+        resourceType: "ProjectMembership";
+        id: string;
+        project?: {
+            reference?: string;
+            display?: string;
+        };
+        user?: {
+            reference?: string;
+            display?: string;
+        };
+        profile?: {
+            reference?: string;
+            display?: string;
+        };
+        accessPolicy?: {
+            reference?: string;
+            display?: string;
+        };
+        meta?: {
+            project?: string;
+            lastUpdated?: string;
+        };
+    };
+    status: "Active" | "Pending";
+    accessPolicy?: {
+        resourceType: "AccessPolicy";
+        id: string;
+        name?: string;
+    };
+};
+export type SlimProjectUsersPage = SlimPage<SlimProjectUser>;
+export type SlimProjectDeviceCounts = {
+    projectId: string;
+    totalDeviceCount: number;
+    assignedResidentDeviceCount: number;
+    unassignedDeviceCount: number;
+    activeDeviceCount: number;
+    inactiveDeviceCount: number;
+    radarDeviceCount: number;
+    withingsDeviceCount: number;
+};
+export type SlimProjectPatientCounts = {
+    projectId: string;
+    totalPatientCount: number;
+    activePatientCount: number;
+    dischargedRecentPatientCount: number;
+    dischargedPatientCount: number;
+    archivedPatientCount: number;
+};
+export type SlimPolicyResource = {
+    resourceType: string;
+    interaction?: string[];
+    criteria?: string;
+    readonly?: boolean;
+    [key: string]: unknown;
+};
+export type SlimPolicy = {
+    resourceType: "AccessPolicy";
+    id: string;
+    name: string;
+    resource?: SlimPolicyResource[];
+    meta?: {
+        project?: string;
+        author?: {
+            reference: string;
+        };
+        lastUpdated?: string;
+    };
+};
+export type SlimPolicyMember = {
+    reference: string;
+    display?: string;
+};
+export type SlimPolicyResponse = {
+    policy: SlimPolicy;
+    members: SlimPolicyMember[];
+};
+export type SlimPolicyListQuery = {
+    page?: number;
+    count?: number;
+    sortBy?: "_id" | "_lastUpdated" | "name";
+    orderBy?: "ASC" | "DESC";
+    projectId?: string;
+    profile?: string;
+    search?: string;
+};
+export type SlimPolicyList = {
+    total: number;
+    resources: SlimPolicyResponse[];
+};
+export type SlimCreatePolicy = {
+    policy: {
+        resourceType: "AccessPolicy";
+        name: string;
+        resource: Array<{
+            resourceType: string;
+            interaction: string[];
+        }>;
+    };
+    members: SlimPolicyMember[];
+};
+export type SlimUpdatePolicy = Omit<SlimCreatePolicy, "policy"> & {
+    policy: SlimCreatePolicy["policy"] & {
+        id: string;
+    };
+};
+export type SlimOrganization = {
+    id: string;
+    name: string;
+    parentOrganizationId?: string;
+    description?: string;
+};
+export type SlimOrganizationInput = {
+    name: string;
+    parentOrganizationId?: string;
+    description?: string | null;
+};
+export type SlimPractitionerInviteInput = {
+    email: string;
+    name: string;
+    surname: string;
+    accessPolicyId: string;
+    admin?: boolean;
+    projectId?: string;
+};
+export type SlimPractitionerInviteResponse = {
+    membership: {
+        resourceType: "ProjectMembership";
+        id: string;
+        project?: {
+            reference: string;
+            display?: string;
+        };
+        user?: {
+            reference: string;
+        };
+        profile?: {
+            reference: string;
+        };
+        accessPolicy?: {
+            reference: string;
+            display: string;
+        };
+        meta?: {
+            project?: string;
+            author?: {
+                reference: string;
+            };
+            lastUpdated?: string;
+        };
+    };
+    profile: {
+        resourceType: "Practitioner";
+        id: string;
+        name?: unknown[];
+        meta?: {
+            project?: string;
+            lastUpdated?: string;
+        };
+    };
+    status: "Pending";
+};
+export type SlimUserProfileType = "Patient" | "Practitioner";
+export type SlimHealthDependency = {
+    status: "up" | "down";
+    version?: string;
+    postgres?: boolean;
+    redis?: boolean;
+    platform?: string;
+    runtime?: string;
+    responseTimeMs?: number;
+    serverMetrics?: {
+        db: {
+            idleConnections?: number;
+            queriesAwaitingClient?: number;
+            healthcheckRttSeconds?: number;
+        };
+        memory: {
+            usedHeapBytes?: number;
+            oldSpaceBytes?: number;
+            newSpaceBytes?: number;
+        };
+        queues: {
+            batchWaiting?: number;
+            batchDelayed?: number;
+            cronWaiting?: number;
+            cronDelayed?: number;
+            subscriptionWaiting?: number;
+            subscriptionDelayed?: number;
+        };
+        fhirOps?: {
+            readCount?: number;
+            searchCount?: number;
+            createCount?: number;
+            updateCount?: number;
+            deleteCount?: number;
+            patchCount?: number;
+        };
+        server?: {
+            indexingDurationMsMax?: number;
+            validationDurationMsMax?: number;
+        };
+    };
+    uptimeSeconds?: number;
+    connectedClients?: number;
+    usedMemoryBytes?: number;
+    usedMemoryHuman?: string;
+    peakMemoryBytes?: number;
+    peakMemoryHuman?: string;
+    opsPerSecond?: number;
+    hitRate?: number;
+    evictedKeys?: number;
+    blockedClients?: number;
+};
+export type SlimHealth = {
+    status: "healthy" | "degraded" | "unhealthy";
+    environment: string;
+    version: string | null;
+    uptimeSeconds: number;
+    timestamp: string;
+    endpoints: {
+        api: string;
+        fhir: string;
+    };
+    externalSystems: {
+        fhirStore: SlimHealthDependency;
+        redis: SlimHealthDependency;
+    };
+    cache?: {
+        hits: number;
+        misses: number;
+        errors: number;
+        hitRate?: number;
+    };
+    ovok?: {
+        cpuUsage?: number;
+        memoryUsageBytes?: number;
+        eventLoopLagMs?: number;
+    };
+    system?: {
+        cpuUtilization?: number;
+        loadAverage1m?: number;
+        loadAverage5m?: number;
+        loadAverage15m?: number;
+        memoryUsageBytes?: number;
+    };
+    observability: {
+        signoz: string | null;
+    };
+};

package/dist/conformance/api-requirements.js

@@ -180,5 +180,27 @@ exports.OVOK_CORE_API_REQUIREMENTS = {
         { method: "GET", path: "/v1/slim/zones/:zoneId", group: "Slim/Zones" },
         { method: "GET", path: "/v1/slim/zones/device-counts", group: "Slim/Zones" },
         { method: "POST", path: "/v1/slim/export/pdf", group: "Slim/Export" },
+        { method: "GET", path: "/v1/slim/project/users", group: "Slim/Project" },
+        { method: "POST", path: "/v1/slim/project/child", group: "Slim/Project" },
+        { method: "GET", path: "/v1/slim/project/child", group: "Slim/Project" },
+        { method: "GET", path: "/v2/slim/project/child", group: "Slim/Project" },
+        { method: "DELETE", path: "/v1/slim/project/child/:subProjectId", group: "Slim/Project" },
+        { method: "GET", path: "/v1/slim/project/:id/users", group: "Slim/Project" },
+        { method: "GET", path: "/v1/slim/project/:id/device-counts", group: "Slim/Project" },
+        { method: "GET", path: "/v1/slim/project/:id/patient-counts", group: "Slim/Project" },
+        { method: "PUT", path: "/v1/slim/project/:id", group: "Slim/Project" },
+        { method: "GET", path: "/v1/slim/project/:id", group: "Slim/Project" },
+        { method: "GET", path: "/v1/slim/policy", group: "Slim/Policy" },
+        { method: "GET", path: "/v1/slim/policy/:id", group: "Slim/Policy" },
+        { method: "POST", path: "/v1/slim/policy", group: "Slim/Policy" },
+        { method: "PUT", path: "/v1/slim/policy/:id", group: "Slim/Policy" },
+        { method: "DELETE", path: "/v1/slim/policy/:id", group: "Slim/Policy" },
+        { method: "GET", path: "/v1/slim/organization/:id", group: "Slim/Organization" },
+        { method: "POST", path: "/v1/slim/organization", group: "Slim/Organization" },
+        { method: "PUT", path: "/v1/slim/organization/:id", group: "Slim/Organization" },
+        { method: "DELETE", path: "/v1/slim/organization/:id", group: "Slim/Organization" },
+        { method: "POST", path: "/v1/slim/invite/practitioner", group: "Slim/Invite" },
+        { method: "DELETE", path: "/v1/slim/user/:profileType/:profileId", group: "Slim/User" },
+        { method: "GET", path: "/v1/slim/health", group: "Slim/Health" },
     ],
 };

package/dist/conformance/capability-requirements.js

@@ -48,7 +48,7 @@ exports.OVOK_CORE_REQUIREMENTS = {
     description: "The FHIR surface a server must provide for the @ovok/core client library's own methods to function.",
     software: {
         name: "@ovok/core",
-        version: "0.4.30",
+        version: "0.4.32",
     },
     fhirVersion: "4.0.1",
     format: ["json"],

package/dist/hooks/account-hooks.js

@@ -41,13 +41,13 @@ const index_1 = require("./index");
 const useChangeHistory = (params = {}) => {
     const client = (0, index_1.useClient)();
     const serialized = JSON.stringify(params);
-    const load = React.useCallback(() => client.listChangeHistory(params), [client, serialized]);
+    const load = React.useCallback((signal) => client.listChangeHistory(params, { signal }), [client, serialized]);
     return (0, api_hooks_1.useOvokRequest)(load);
 };
 exports.useChangeHistory = useChangeHistory;
 const useLegalConsent = () => {
     const client = (0, index_1.useClient)();
-    const load = React.useCallback(() => client.getLegalConsent(), [client]);
+    const load = React.useCallback((signal) => client.getLegalConsent({ signal }), [client]);
     return (0, api_hooks_1.useOvokRequest)(load);
 };
 exports.useLegalConsent = useLegalConsent;
@@ -55,7 +55,7 @@ const useSetLegalConsent = () => (0, api_hooks_1.useOvokMutation)((client, accep
 exports.useSetLegalConsent = useSetLegalConsent;
 const useMedicalConsent = () => {
     const client = (0, index_1.useClient)();
-    const load = React.useCallback(() => client.getMedicalConsent(), [client]);
+    const load = React.useCallback((signal) => client.getMedicalConsent({ signal }), [client]);
     return (0, api_hooks_1.useOvokRequest)(load);
 };
 exports.useMedicalConsent = useMedicalConsent;
@@ -63,14 +63,14 @@ const useSetMedicalConsent = () => (0, api_hooks_1.useOvokMutation)((client, acc
 exports.useSetMedicalConsent = useSetMedicalConsent;
 const useSlimThresholdV2 = () => {
     const client = (0, index_1.useClient)();
-    const load = React.useCallback(() => client.getSlimThresholdV2(), [client]);
+    const load = React.useCallback((signal) => client.getSlimThresholdV2({ signal }), [client]);
     return (0, api_hooks_1.useOvokRequest)(load);
 };
 exports.useSlimThresholdV2 = useSlimThresholdV2;
 const useSlimPatientThresholdV2 = (patientId) => {
     const client = (0, index_1.useClient)();
-    const load = React.useCallback(() => patientId
-        ? client.getSlimPatientThresholdV2(patientId)
+    const load = React.useCallback((signal) => patientId
+        ? client.getSlimPatientThresholdV2(patientId, { signal })
         : Promise.reject(new Error("patientId is required")), [client, patientId]);
     return (0, api_hooks_1.useOvokRequest)(load, patientId !== undefined);
 };
@@ -84,7 +84,7 @@ const useUpdateSlimPatientThresholdV2 = () => (0, api_hooks_1.useOvokMutation)(a
 exports.useUpdateSlimPatientThresholdV2 = useUpdateSlimPatientThresholdV2;
 const useUnconfirmedLimits = () => {
     const client = (0, index_1.useClient)();
-    const load = React.useCallback(() => client.listUnconfirmedLimits(), [client]);
+    const load = React.useCallback((signal) => client.listUnconfirmedLimits({ signal }), [client]);
     return (0, api_hooks_1.useOvokRequest)(load);
 };
 exports.useUnconfirmedLimits = useUnconfirmedLimits;

package/dist/hooks/api-hooks.d.ts

@@ -5,7 +5,10 @@ import { SlimDeviceListItem, SlimDeviceListQuery, SlimDeviceTelemetry, SlimNotif
 import { OvokPublicApiEndpoint } from "../conformance/capability";
 export type OvokRequestState<T> = {
     data: T | undefined;
+    dataUpdatedAt: number | undefined;
     loading: boolean;
+    isRefreshing: boolean;
+    isStale: boolean;
     error: Error | undefined;
     reload: () => void;
 };
@@ -21,9 +24,9 @@ export type OvokMutationState<TParams, TData> = {
  * add a cache or retry policy: MedplumClient already owns request caching and
  * the host app owns the retry policy appropriate to its screen.
  */
-export declare function useOvokRequest<T>(load: () => Promise<T>, enabled?: boolean): OvokRequestState<T>;
+export declare function useOvokRequest<T>(load: (signal?: AbortSignal) => Promise<T>, enabled?: boolean): OvokRequestState<T>;
 /** Internal variant for list hooks that reconcile server-confirmed changes in mounted data. */
-export declare function useOvokRequestWithUpdater<T>(load: () => Promise<T>, enabled?: boolean): OvokRequestState<T> & {
+export declare function useOvokRequestWithUpdater<T>(load: (signal?: AbortSignal) => Promise<T>, enabled?: boolean): OvokRequestState<T> & {
     updateData(update: (current: T | undefined) => T | undefined): void;
 };
 /** Generic mutation hook for any typed OvokClient method. */

package/dist/hooks/api-hooks.js

@@ -48,17 +48,26 @@ const toError = (error) => error instanceof Error ? error : new Error(String(err
  * the host app owns the retry policy appropriate to its screen.
  */
 function useOvokRequest(load, enabled = true) {
-    const { data, loading, error, reload } = useOvokRequestWithUpdater(load, enabled);
-    return { data, loading, error, reload };
+    const { data, dataUpdatedAt, loading, isRefreshing, isStale, error, reload, } = useOvokRequestWithUpdater(load, enabled);
+    return { data, dataUpdatedAt, loading, isRefreshing, isStale, error, reload };
 }
 /** Internal variant for list hooks that reconcile server-confirmed changes in mounted data. */
 function useOvokRequestWithUpdater(load, enabled = true) {
     const [data, setData] = React.useState();
+    const [dataUpdatedAt, setDataUpdatedAt] = React.useState();
     const [error, setError] = React.useState();
     const [loading, setLoading] = React.useState(enabled);
     const [revision, setRevision] = React.useState(0);
+    const previousLoad = React.useRef(load);
     React.useEffect(() => {
         let disposed = false;
+        const controller = new AbortController();
+        const queryChanged = previousLoad.current !== load;
+        if (queryChanged) {
+            previousLoad.current = load;
+            setData(undefined);
+            setDataUpdatedAt(undefined);
+        }
         if (!enabled) {
             setLoading(false);
             setError(undefined);
@@ -68,10 +77,11 @@ function useOvokRequestWithUpdater(load, enabled = true) {
         }
         setLoading(true);
         setError(undefined);
-        load()
+        load(controller.signal)
             .then((value) => {
             if (!disposed) {
                 setData(value);
+                setDataUpdatedAt(Date.now());
                 setLoading(false);
             }
         })
@@ -83,11 +93,24 @@ function useOvokRequestWithUpdater(load, enabled = true) {
         });
         return () => {
             disposed = true;
+            controller.abort();
         };
     }, [enabled, load, revision]);
     const reload = React.useCallback(() => setRevision((value) => value + 1), []);
-    const updateData = React.useCallback((update) => setData(update), []);
-    return { data, loading, error, reload, updateData };
+    const updateData = React.useCallback((update) => {
+        setData(update);
+        setDataUpdatedAt(Date.now());
+    }, []);
+    return {
+        data,
+        dataUpdatedAt,
+        loading,
+        isRefreshing: data !== undefined && loading,
+        isStale: data !== undefined && (loading || error !== undefined),
+        error,
+        reload,
+        updateData,
+    };
 }
 /** Generic mutation hook for any typed OvokClient method. */
 function useOvokMutation(mutateRequest) {
@@ -121,53 +144,53 @@ function useOvokMutation(mutateRequest) {
 }
 const useCapabilityStatement = (version = "R4") => {
     const client = (0, index_1.useClient)();
-    const load = React.useCallback(() => client.getCapabilityStatement(version), [client, version]);
+    const load = React.useCallback((signal) => client.getCapabilityStatement(version, { signal }), [client, version]);
     return useOvokRequest(load);
 };
 exports.useCapabilityStatement = useCapabilityStatement;
 const usePublicApiEndpoints = (version = "R4") => {
     const client = (0, index_1.useClient)();
-    const load = React.useCallback(() => client.getPublicApiEndpoints(version), [client, version]);
+    const load = React.useCallback((signal) => client.getPublicApiEndpoints(version, { signal }), [client, version]);
     return useOvokRequest(load);
 };
 exports.usePublicApiEndpoints = usePublicApiEndpoints;
 const useAdministeredProjects = (params = {}) => {
     const client = (0, index_1.useClient)();
     const serialized = JSON.stringify(params);
-    const load = React.useCallback(() => client.listAdministeredProjects(params), [client, serialized]);
+    const load = React.useCallback((signal) => client.listAdministeredProjects(params, { signal }), [client, serialized]);
     return useOvokRequest(load);
 };
 exports.useAdministeredProjects = useAdministeredProjects;
 const useProjectSettings = () => {
     const client = (0, index_1.useClient)();
-    const load = React.useCallback(() => client.getProjectSettings(), [client]);
+    const load = React.useCallback((signal) => client.getProjectSettings({ signal }), [client]);
     return useOvokRequest(load);
 };
 exports.useProjectSettings = useProjectSettings;
 const useProjectFeatures = () => {
     const client = (0, index_1.useClient)();
-    const load = React.useCallback(() => client.getProjectFeatures(), [client]);
+    const load = React.useCallback((signal) => client.getProjectFeatures({ signal }), [client]);
     return useOvokRequest(load);
 };
 exports.useProjectFeatures = useProjectFeatures;
 const useSlimPatients = (params = {}) => {
     const client = (0, index_1.useClient)();
     const serialized = JSON.stringify(params);
-    const load = React.useCallback(() => client.listSlimPatients(params), [client, serialized]);
+    const load = React.useCallback((signal) => client.listSlimPatients(params, { signal }), [client, serialized]);
     return useOvokRequest(load);
 };
 exports.useSlimPatients = useSlimPatients;
 const useSlimDevices = (params = {}) => {
     const client = (0, index_1.useClient)();
     const serialized = JSON.stringify(params);
-    const load = React.useCallback(() => client.listSlimDevices(params), [client, serialized]);
+    const load = React.useCallback((signal) => client.listSlimDevices(params, { signal }), [client, serialized]);
     return useOvokRequest(load);
 };
 exports.useSlimDevices = useSlimDevices;
 const useSlimDeviceTelemetry = (deviceId) => {
     const client = (0, index_1.useClient)();
-    const load = React.useCallback(() => deviceId
-        ? client.getSlimDeviceTelemetry(deviceId)
+    const load = React.useCallback((signal) => deviceId
+        ? client.getSlimDeviceTelemetry(deviceId, { signal })
         : Promise.reject(new Error("deviceId is required")), [client, deviceId]);
     return useOvokRequest(load, deviceId !== undefined);
 };
@@ -176,7 +199,7 @@ exports.useSlimDeviceTelemetry = useSlimDeviceTelemetry;
 const useSlimNotifications = (params = {}) => {
     const client = (0, index_1.useClient)();
     const serialized = JSON.stringify(params);
-    const load = React.useCallback(() => client.listSlimNotifications(params), [client, serialized]);
+    const load = React.useCallback((signal) => client.listSlimNotifications(params, { signal }), [client, serialized]);
     const { updateData, ...state } = useOvokRequestWithUpdater(load);
     React.useEffect(() => (0, notification_invalidation_1.subscribeToNotificationChanges)(client, (change) => {
         if (!change) {
@@ -194,7 +217,7 @@ const useSlimNotifications = (params = {}) => {
 exports.useSlimNotifications = useSlimNotifications;
 const useRecentSlimNotifications = (count) => {
     const client = (0, index_1.useClient)();
-    const load = React.useCallback(() => client.getRecentSlimNotifications(count), [client, count]);
+    const load = React.useCallback((signal) => client.getRecentSlimNotifications(count, { signal }), [client, count]);
     const { updateData, ...state } = useOvokRequestWithUpdater(load);
     React.useEffect(() => (0, notification_invalidation_1.subscribeToNotificationChanges)(client, (change) => {
         if (!change) {

package/dist/hooks/cms-hooks.js

@@ -47,7 +47,7 @@ const useCmsDocument = (collection, slug, options = {}) => {
     const client = (0, index_1.useClient)();
     const { tenantCode, environment, allowSignedOut } = options;
     const locale = React.useMemo(() => (0, cms_1.toCmsLocale)(options.locale || (0, cms_1.defaultCmsLocale)()), [options.locale]);
-    const load = React.useCallback(() => client.getCmsDocument(collection, slug, { locale, tenantCode, environment, allowSignedOut }), [client, collection, slug, locale, tenantCode, environment, allowSignedOut]);
+    const load = React.useCallback((signal) => client.getCmsDocument(collection, slug, { locale, tenantCode, environment, allowSignedOut }, { signal }), [client, collection, slug, locale, tenantCode, environment, allowSignedOut]);
     return (0, api_hooks_1.useOvokRequest)(load, Boolean(slug));
 };
 exports.useCmsDocument = useCmsDocument;
@@ -56,7 +56,7 @@ const useCmsDocuments = (collection, options = {}) => {
     const client = (0, index_1.useClient)();
     const { tenantCode, environment, allowSignedOut, page, limit, sort } = options;
     const locale = React.useMemo(() => (0, cms_1.toCmsLocale)(options.locale || (0, cms_1.defaultCmsLocale)()), [options.locale]);
-    const load = React.useCallback(() => client.listCmsDocuments(collection, { locale, tenantCode, environment, allowSignedOut, page, limit, sort }), [client, collection, locale, tenantCode, environment, allowSignedOut, page, limit, sort]);
+    const load = React.useCallback((signal) => client.listCmsDocuments(collection, { locale, tenantCode, environment, allowSignedOut, page, limit, sort }, { signal }), [client, collection, locale, tenantCode, environment, allowSignedOut, page, limit, sort]);
     return (0, api_hooks_1.useOvokRequest)(load);
 };
 exports.useCmsDocuments = useCmsDocuments;
@@ -74,7 +74,7 @@ const useTranslations = (options = {}) => {
     const client = (0, index_1.useClient)();
     const { tenantCode, environment, allowSignedOut } = options;
     const locale = React.useMemo(() => (0, cms_1.toCmsLocale)(options.locale || (0, cms_1.defaultCmsLocale)()), [options.locale]);
-    const load = React.useCallback(() => client.getTranslations({ locale, tenantCode, environment, allowSignedOut }), [client, locale, tenantCode, environment, allowSignedOut]);
+    const load = React.useCallback((signal) => client.getTranslations({ locale, tenantCode, environment, allowSignedOut }, { signal }), [client, locale, tenantCode, environment, allowSignedOut]);
     return (0, api_hooks_1.useOvokRequest)(load);
 };
 exports.useTranslations = useTranslations;

package/dist/hooks/email-hooks.js

@@ -40,7 +40,7 @@ const api_hooks_1 = require("./api-hooks");
 const index_1 = require("./index");
 const useEmailTemplates = () => {
     const client = (0, index_1.useClient)();
-    const load = React.useCallback(() => client.getEmailTemplates(), [client]);
+    const load = React.useCallback((signal) => client.getEmailTemplates({ signal }), [client]);
     return (0, api_hooks_1.useOvokRequest)(load);
 };
 exports.useEmailTemplates = useEmailTemplates;