@comapeo/core-react 9.0.2 → 10.0.0

package/dist/commonjs/lib/react-query.d.ts

@@ -0,0 +1,103 @@
+import type { QueryClient, UseMutationResult } from '@tanstack/react-query';
+import { DistributedPick } from 'type-fest';
+import type { WriteableDocumentType } from './types.js';
+export declare function baseQueryOptions(): {
+    networkMode: "always";
+    retry: false;
+};
+export declare function baseMutationOptions(): {
+    networkMode: "always";
+    retry: false;
+};
+declare const PICKED_MUTATION_RESULT_KEYS: readonly ["error", "mutate", "mutateAsync", "reset", "status"];
+export type FilteredMutationResult<TResult extends UseMutationResult<any, any, any, any>> = DistributedPick<TResult, (typeof PICKED_MUTATION_RESULT_KEYS)[number]>;
+/**
+ * Filters a `UseMutationResult` to only include a subset of its keys, and uses
+ * `DistributedPick` to preserve the discriminated union types of the mutation
+ * result based on the `status` property.
+ */
+export declare function filterMutationResult<TResult extends UseMutationResult<any, any, any, any>>(mutationResult: TResult): DistributedPick<TResult, "error" | "status" | "mutate" | "reset" | "mutateAsync">;
+export declare function getDeviceInfoQueryKey(): readonly ["@comapeo/core-react", "client", "device_info"];
+export declare function getIsArchiveDeviceQueryKey(): readonly ["@comapeo/core-react", "client", "is_archive_device"];
+export declare function getInvitesQueryKey(): readonly ["@comapeo/core-react", "invites"];
+export declare function getInvitesByIdQueryKey({ inviteId }: {
+    inviteId: string;
+}): readonly ["@comapeo/core-react", "invites", {
+    readonly inviteId: string;
+}];
+export declare function getMapQueryKey({ mapId }: {
+    mapId: string;
+}): readonly ["@comapeo/core-react", "maps", string];
+export declare function getMapInfoQueryKey({ mapId }: {
+    mapId: string;
+}): readonly ["@comapeo/core-react", "maps", string, "info"];
+export declare function getStyleJsonUrlQueryKey({ mapId }: {
+    mapId: string;
+}): readonly ["@comapeo/core-react", "maps", string, "stylejson_url"];
+/**
+ * Invalidate queries for this map and the default map (which internally
+ * redirects to custom) so that they will be refetched with the new map data.
+ */
+export declare function invalidateMapQueries(queryClient: QueryClient, { mapId }: {
+    mapId: string;
+}): Promise<void>;
+export declare function getProjectsQueryKey(): readonly ["@comapeo/core-react", "projects"];
+export declare function getProjectByIdQueryKey({ projectId }: {
+    projectId: string;
+}): readonly ["@comapeo/core-react", "projects", string];
+export declare function getProjectSettingsQueryKey({ projectId, }: {
+    projectId: string;
+}): readonly ["@comapeo/core-react", "projects", string, "project_settings"];
+export declare function getProjectRoleQueryKey({ projectId }: {
+    projectId: string;
+}): readonly ["@comapeo/core-react", "projects", string, "role"];
+export declare function getMembersQueryKey({ projectId, includeLeft, }: {
+    projectId: string;
+    includeLeft?: boolean;
+}): readonly ["@comapeo/core-react", "projects", string, "members", {
+    readonly includeLeft: boolean | undefined;
+}];
+export declare function getMemberByIdQueryKey({ projectId, deviceId, }: {
+    projectId: string;
+    deviceId: string;
+}): readonly ["@comapeo/core-react", "projects", string, "members", string];
+export declare function getDocumentCreatedByQueryKey({ projectId, originalVersionId, }: {
+    projectId: string;
+    originalVersionId: string;
+}): readonly ["@comapeo/core-react", "projects", string, "document_created_by", string];
+/**
+ * We call this within a project hook, because that's the only place the API is
+ * exposed right now, but it is the same for all projects, so no need for
+ * scoping the query key to the project
+ */
+export declare function getMediaServerOriginQueryKey(): readonly ["@comapeo/core-react", "media_server_origin"];
+export declare function getDocumentsQueryKey<D extends WriteableDocumentType>({ projectId, docType, }: {
+    projectId: string;
+    docType: D;
+}): readonly ["@comapeo/core-react", "projects", string, D];
+export declare function getManyDocumentsQueryKey<D extends WriteableDocumentType>({ projectId, docType, includeDeleted, lang, }: {
+    projectId: string;
+    docType: D;
+    includeDeleted?: boolean;
+    lang?: string;
+}): readonly ["@comapeo/core-react", "projects", string, D, {
+    readonly includeDeleted: boolean | undefined;
+    readonly lang: string | undefined;
+}];
+export declare function getDocumentByDocIdQueryKey<D extends WriteableDocumentType>({ projectId, docType, docId, lang, }: {
+    projectId: string;
+    docType: D;
+    docId: string;
+    lang?: string;
+}): readonly ["@comapeo/core-react", "projects", string, D, string, {
+    readonly lang: string | undefined;
+}];
+export declare function getDocumentByVersionIdQueryKey<D extends WriteableDocumentType>({ projectId, docType, versionId, lang, }: {
+    projectId: string;
+    docType: D;
+    versionId: string;
+    lang?: string;
+}): readonly ["@comapeo/core-react", "projects", string, D, string, {
+    readonly lang: string | undefined;
+}];
+export {};

package/dist/commonjs/lib/react-query.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseQueryOptions = baseQueryOptions;
+exports.baseMutationOptions = baseMutationOptions;
+exports.filterMutationResult = filterMutationResult;
+exports.getDeviceInfoQueryKey = getDeviceInfoQueryKey;
+exports.getIsArchiveDeviceQueryKey = getIsArchiveDeviceQueryKey;
+exports.getInvitesQueryKey = getInvitesQueryKey;
+exports.getInvitesByIdQueryKey = getInvitesByIdQueryKey;
+exports.getMapQueryKey = getMapQueryKey;
+exports.getMapInfoQueryKey = getMapInfoQueryKey;
+exports.getStyleJsonUrlQueryKey = getStyleJsonUrlQueryKey;
+exports.invalidateMapQueries = invalidateMapQueries;
+exports.getProjectsQueryKey = getProjectsQueryKey;
+exports.getProjectByIdQueryKey = getProjectByIdQueryKey;
+exports.getProjectSettingsQueryKey = getProjectSettingsQueryKey;
+exports.getProjectRoleQueryKey = getProjectRoleQueryKey;
+exports.getMembersQueryKey = getMembersQueryKey;
+exports.getMemberByIdQueryKey = getMemberByIdQueryKey;
+exports.getDocumentCreatedByQueryKey = getDocumentCreatedByQueryKey;
+exports.getMediaServerOriginQueryKey = getMediaServerOriginQueryKey;
+exports.getDocumentsQueryKey = getDocumentsQueryKey;
+exports.getManyDocumentsQueryKey = getManyDocumentsQueryKey;
+exports.getDocumentByDocIdQueryKey = getDocumentByDocIdQueryKey;
+exports.getDocumentByVersionIdQueryKey = getDocumentByVersionIdQueryKey;
+const map_server_1 = require("@comapeo/map-server");
+// #region Shared
+const ROOT_QUERY_KEY = '@comapeo/core-react';
+// Since the API is running locally, queries should run regardless of network
+// status, and should not be retried. In React Native the API consumer would
+// have to manually set the network mode, but we still should keep these options
+// to avoid surprises. Not using the queryClient `defaultOptions` because the API
+// consumer might also use the same queryClient for network queries
+function baseQueryOptions() {
+    return {
+        networkMode: 'always',
+        retry: false,
+    };
+}
+function baseMutationOptions() {
+    return {
+        networkMode: 'always',
+        retry: false,
+    };
+}
+const PICKED_MUTATION_RESULT_KEYS = [
+    'error',
+    'mutate',
+    'mutateAsync',
+    'reset',
+    'status',
+];
+/**
+ * Filters a `UseMutationResult` to only include a subset of its keys, and uses
+ * `DistributedPick` to preserve the discriminated union types of the mutation
+ * result based on the `status` property.
+ */
+function filterMutationResult(mutationResult) {
+    const filteredResult = {};
+    for (const key of PICKED_MUTATION_RESULT_KEYS) {
+        filteredResult[key] = mutationResult[key];
+    }
+    return filteredResult;
+}
+// #endregion
+// #region Client
+function getClientQueryKey() {
+    return [ROOT_QUERY_KEY, 'client'];
+}
+function getDeviceInfoQueryKey() {
+    return [...getClientQueryKey(), 'device_info'];
+}
+function getIsArchiveDeviceQueryKey() {
+    return [...getClientQueryKey(), 'is_archive_device'];
+}
+// #endregion
+// #region Invites
+function getInvitesQueryKey() {
+    return [ROOT_QUERY_KEY, 'invites'];
+}
+function getInvitesByIdQueryKey({ inviteId }) {
+    return [ROOT_QUERY_KEY, 'invites', { inviteId }];
+}
+// #endregion
+// #region Maps
+const MAPS_ROOT_QUERY_KEY = [ROOT_QUERY_KEY, 'maps'];
+function getMapQueryKey({ mapId }) {
+    return [...MAPS_ROOT_QUERY_KEY, mapId];
+}
+function getMapInfoQueryKey({ mapId }) {
+    return [...getMapQueryKey({ mapId }), 'info'];
+}
+function getStyleJsonUrlQueryKey({ mapId }) {
+    return [...getMapQueryKey({ mapId }), 'stylejson_url'];
+}
+/**
+ * Invalidate queries for this map and the default map (which internally
+ * redirects to custom) so that they will be refetched with the new map data.
+ */
+async function invalidateMapQueries(queryClient, { mapId }) {
+    await Promise.all([
+        queryClient.invalidateQueries({
+            queryKey: getMapQueryKey({ mapId }),
+        }),
+        queryClient.invalidateQueries({
+            queryKey: getMapQueryKey({ mapId: map_server_1.DEFAULT_MAP_ID }),
+        }),
+    ]);
+}
+// #endregion
+// #region Projects
+function getProjectsQueryKey() {
+    return [ROOT_QUERY_KEY, 'projects'];
+}
+function getProjectByIdQueryKey({ projectId }) {
+    return [ROOT_QUERY_KEY, 'projects', projectId];
+}
+function getProjectSettingsQueryKey({ projectId, }) {
+    return [ROOT_QUERY_KEY, 'projects', projectId, 'project_settings'];
+}
+function getProjectRoleQueryKey({ projectId }) {
+    return [ROOT_QUERY_KEY, 'projects', projectId, 'role'];
+}
+function getMembersQueryKey({ projectId, includeLeft, }) {
+    return [
+        ROOT_QUERY_KEY,
+        'projects',
+        projectId,
+        'members',
+        { includeLeft },
+    ];
+}
+function getMemberByIdQueryKey({ projectId, deviceId, }) {
+    return [ROOT_QUERY_KEY, 'projects', projectId, 'members', deviceId];
+}
+function getDocumentCreatedByQueryKey({ projectId, originalVersionId, }) {
+    return [
+        ROOT_QUERY_KEY,
+        'projects',
+        projectId,
+        'document_created_by',
+        originalVersionId,
+    ];
+}
+/**
+ * We call this within a project hook, because that's the only place the API is
+ * exposed right now, but it is the same for all projects, so no need for
+ * scoping the query key to the project
+ */
+function getMediaServerOriginQueryKey() {
+    return [ROOT_QUERY_KEY, 'media_server_origin'];
+}
+// #endregion
+// #region Documents
+function getDocumentsQueryKey({ projectId, docType, }) {
+    return [ROOT_QUERY_KEY, 'projects', projectId, docType];
+}
+function getManyDocumentsQueryKey({ projectId, docType, includeDeleted, lang, }) {
+    return [
+        ROOT_QUERY_KEY,
+        'projects',
+        projectId,
+        docType,
+        { includeDeleted, lang },
+    ];
+}
+function getDocumentByDocIdQueryKey({ projectId, docType, docId, lang, }) {
+    return [
+        ROOT_QUERY_KEY,
+        'projects',
+        projectId,
+        docType,
+        docId,
+        { lang },
+    ];
+}
+function getDocumentByVersionIdQueryKey({ projectId, docType, versionId, lang, }) {
+    return [
+        ROOT_QUERY_KEY,
+        'projects',
+        projectId,
+        docType,
+        versionId,
+        { lang },
+    ];
+}
+// #endregion

package/dist/commonjs/lib/sync.d.ts

@@ -1,12 +1,9 @@
-import type { MapeoProjectApi } from '@comapeo/ipc' with {
-    'resolution-mode': 'import'
-};
+import type { MapeoProjectApi } from '@comapeo/ipc';
 export type SyncState = Awaited<ReturnType<MapeoProjectApi['$sync']['getState']>>;
-export declare function getDataSyncCountForDevice(syncStateForDevice: SyncState['remoteDeviceSyncState'][string]): number;
 export declare class SyncStore {
     #private;
     constructor(project: MapeoProjectApi);
     subscribe: (listener: () => void) => () => void;
-    getStateSnapshot: () => import("@comapeo/core/dist/sync/sync-api.js", { with: { "resolution-mode": "import" } }).State | null;
+    getStateSnapshot: () => SyncState | null;
     getDataProgressSnapshot: () => number | null;
 }

package/dist/commonjs/lib/sync.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SyncStore = void 0;
-exports.getDataSyncCountForDevice = getDataSyncCountForDevice;
 function getDataSyncCountForDevice(syncStateForDevice) {
     const { data } = syncStateForDevice;
     return data.want + data.wanted;

package/dist/commonjs/lib/types.d.ts

@@ -1,11 +1,9 @@
-import type { MapeoDoc, MapeoValue } from '@comapeo/schema' with {
-    'resolution-mode': 'import'
-};
-export type WriteableDocumentType = Extract<MapeoDoc['schemaName'], 'field' | 'observation' | 'preset' | 'track' | 'remoteDetectionAlert'>;
-export type WriteableValue<D extends WriteableDocumentType> = Extract<MapeoValue, {
+import type { ComapeoDoc, ComapeoValue } from '@comapeo/core/schema.js';
+export type WriteableDocumentType = Extract<ComapeoDoc['schemaName'], 'field' | 'observation' | 'preset' | 'track' | 'remoteDetectionAlert'>;
+export type WriteableValue<D extends WriteableDocumentType> = Extract<ComapeoValue, {
     schemaName: D;
 }>;
-export type WriteableDocument<D extends WriteableDocumentType> = Extract<MapeoDoc, {
+export type WriteableDocument<D extends WriteableDocumentType> = Extract<ComapeoDoc, {
     schemaName: D;
 }>;
 export {};

package/dist/esm/contexts/ClientApi.d.ts

@@ -1,6 +1,4 @@
-import type { MapeoClientApi } from '@comapeo/ipc' with {
-    'resolution-mode': 'import'
-};
+import type { MapeoClientApi } from '@comapeo/ipc';
 import { type Context, type JSX, type PropsWithChildren } from 'react';
 export declare const ClientApiContext: Context<MapeoClientApi | null>;
 export type ClientApiProviderProps = PropsWithChildren<{

package/dist/esm/contexts/ClientApi.js

@@ -1,6 +1,6 @@
 import { useQueryClient } from '@tanstack/react-query';
 import { createContext, createElement, useEffect, } from 'react';
-import { getInvitesQueryKey } from '../lib/react-query/invites.js';
+import { getInvitesQueryKey } from '../lib/react-query.js';
 export const ClientApiContext = createContext(null);
 /**
  * Create a context provider that holds a CoMapeo API client instance.

package/dist/esm/hooks/client.d.ts

@@ -1,6 +1,6 @@
-import type { MapeoClientApi } from '@comapeo/ipc' with {
-    'resolution-mode': 'import'
-};
+import type { DeviceInfo } from '@comapeo/core/schema.js';
+import type { MapeoClientApi } from '@comapeo/ipc';
+import { type UseSuspenseQueryResult } from '@tanstack/react-query';
 /**
  * Access a client API instance. If a ClientApiContext provider is not
  * set up, it will throw an error.
@@ -37,14 +37,7 @@ export declare function useClientApi(): MapeoClientApi;
  * }
  * ```
  */
-export declare function useOwnDeviceInfo(): {
-    data: {
-        deviceId: string;
-        deviceType: import("@comapeo/core/dist/schema/client.js").DeviceInfoParam["deviceType"];
-    } & Partial<import("@comapeo/core/dist/schema/client.js").DeviceInfoParam>;
-    error: Error | null;
-    isRefetching: boolean;
-};
+export declare function useOwnDeviceInfo(): Pick<UseSuspenseQueryResult<Awaited<ReturnType<MapeoClientApi['getDeviceInfo']>>>, 'data' | 'error' | 'isRefetching'>;
 /**
  * Retrieve whether the current device is an archive device or not.
  *
@@ -63,52 +56,100 @@ export declare function useIsArchiveDevice(): {
 /**
  * Update the device info for the current device.
  */
-export declare function useSetOwnDeviceInfo(): {
-    error: Error;
+export declare function useSetOwnDeviceInfo(): Pick<import("@tanstack/react-query").Override<import("@tanstack/react-query").MutationObserverIdleResult<void, Error, {
+    name: string;
+    deviceType: DeviceInfo["deviceType"];
+}, unknown>, {
     mutate: import("@tanstack/react-query").UseMutateFunction<void, Error, {
         name: string;
-        deviceType: import("@comapeo/schema").DeviceInfo["deviceType"];
+        deviceType: DeviceInfo["deviceType"];
     }, unknown>;
+}> & {
     mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<void, Error, {
         name: string;
-        deviceType: import("@comapeo/schema").DeviceInfo["deviceType"];
+        deviceType: DeviceInfo["deviceType"];
     }, unknown>;
-    reset: () => void;
-    status: "error";
-} | {
-    error: null;
+}, "error" | "status" | "mutate" | "reset" | "mutateAsync"> | Pick<import("@tanstack/react-query").Override<import("@tanstack/react-query").MutationObserverLoadingResult<void, Error, {
+    name: string;
+    deviceType: DeviceInfo["deviceType"];
+}, unknown>, {
     mutate: import("@tanstack/react-query").UseMutateFunction<void, Error, {
         name: string;
-        deviceType: import("@comapeo/schema").DeviceInfo["deviceType"];
+        deviceType: DeviceInfo["deviceType"];
     }, unknown>;
+}> & {
     mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<void, Error, {
         name: string;
-        deviceType: import("@comapeo/schema").DeviceInfo["deviceType"];
+        deviceType: DeviceInfo["deviceType"];
     }, unknown>;
-    reset: () => void;
-    status: "pending" | "success" | "idle";
-};
+}, "error" | "status" | "mutate" | "reset" | "mutateAsync"> | Pick<import("@tanstack/react-query").Override<import("@tanstack/react-query").MutationObserverErrorResult<void, Error, {
+    name: string;
+    deviceType: DeviceInfo["deviceType"];
+}, unknown>, {
+    mutate: import("@tanstack/react-query").UseMutateFunction<void, Error, {
+        name: string;
+        deviceType: DeviceInfo["deviceType"];
+    }, unknown>;
+}> & {
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<void, Error, {
+        name: string;
+        deviceType: DeviceInfo["deviceType"];
+    }, unknown>;
+}, "error" | "status" | "mutate" | "reset" | "mutateAsync"> | Pick<import("@tanstack/react-query").Override<import("@tanstack/react-query").MutationObserverSuccessResult<void, Error, {
+    name: string;
+    deviceType: DeviceInfo["deviceType"];
+}, unknown>, {
+    mutate: import("@tanstack/react-query").UseMutateFunction<void, Error, {
+        name: string;
+        deviceType: DeviceInfo["deviceType"];
+    }, unknown>;
+}> & {
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<void, Error, {
+        name: string;
+        deviceType: DeviceInfo["deviceType"];
+    }, unknown>;
+}, "error" | "status" | "mutate" | "reset" | "mutateAsync">;
 /**
  * Set or unset the current device as an archive device.
  */
-export declare function useSetIsArchiveDevice(): {
-    error: Error;
+export declare function useSetIsArchiveDevice(): Pick<import("@tanstack/react-query").Override<import("@tanstack/react-query").MutationObserverIdleResult<void, Error, {
+    isArchiveDevice: boolean;
+}, unknown>, {
     mutate: import("@tanstack/react-query").UseMutateFunction<void, Error, {
         isArchiveDevice: boolean;
     }, unknown>;
+}> & {
     mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<void, Error, {
         isArchiveDevice: boolean;
     }, unknown>;
-    reset: () => void;
-    status: "error";
-} | {
-    error: null;
+}, "error" | "status" | "mutate" | "reset" | "mutateAsync"> | Pick<import("@tanstack/react-query").Override<import("@tanstack/react-query").MutationObserverLoadingResult<void, Error, {
+    isArchiveDevice: boolean;
+}, unknown>, {
     mutate: import("@tanstack/react-query").UseMutateFunction<void, Error, {
         isArchiveDevice: boolean;
     }, unknown>;
+}> & {
     mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<void, Error, {
         isArchiveDevice: boolean;
     }, unknown>;
-    reset: () => void;
-    status: "pending" | "success" | "idle";
-};
+}, "error" | "status" | "mutate" | "reset" | "mutateAsync"> | Pick<import("@tanstack/react-query").Override<import("@tanstack/react-query").MutationObserverErrorResult<void, Error, {
+    isArchiveDevice: boolean;
+}, unknown>, {
+    mutate: import("@tanstack/react-query").UseMutateFunction<void, Error, {
+        isArchiveDevice: boolean;
+    }, unknown>;
+}> & {
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<void, Error, {
+        isArchiveDevice: boolean;
+    }, unknown>;
+}, "error" | "status" | "mutate" | "reset" | "mutateAsync"> | Pick<import("@tanstack/react-query").Override<import("@tanstack/react-query").MutationObserverSuccessResult<void, Error, {
+    isArchiveDevice: boolean;
+}, unknown>, {
+    mutate: import("@tanstack/react-query").UseMutateFunction<void, Error, {
+        isArchiveDevice: boolean;
+    }, unknown>;
+}> & {
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<void, Error, {
+        isArchiveDevice: boolean;
+    }, unknown>;
+}, "error" | "status" | "mutate" | "reset" | "mutateAsync">;

package/dist/esm/hooks/client.js

@@ -1,7 +1,7 @@
 import { useMutation, useQueryClient, useSuspenseQuery, } from '@tanstack/react-query';
 import { useContext } from 'react';
 import { ClientApiContext } from '../contexts/ClientApi.js';
-import { deviceInfoQueryOptions, isArchiveDeviceQueryOptions, setIsArchiveDeviceMutationOptions, setOwnDeviceInfoMutationOptions, } from '../lib/react-query/client.js';
+import { baseMutationOptions, baseQueryOptions, filterMutationResult, getDeviceInfoQueryKey, getIsArchiveDeviceQueryKey, getProjectsQueryKey, } from '../lib/react-query.js';
 /**
  * Access a client API instance. If a ClientApiContext provider is not
  * set up, it will throw an error.
@@ -46,7 +46,13 @@ export function useClientApi() {
  */
 export function useOwnDeviceInfo() {
     const clientApi = useClientApi();
-    const { data, error, isRefetching } = useSuspenseQuery(deviceInfoQueryOptions({ clientApi }));
+    const { data, error, isRefetching } = useSuspenseQuery({
+        ...baseQueryOptions(),
+        queryKey: getDeviceInfoQueryKey(),
+        queryFn: async () => {
+            return clientApi.getDeviceInfo();
+        },
+    });
     return { data, error, isRefetching };
 }
 /**
@@ -61,7 +67,13 @@ export function useOwnDeviceInfo() {
  */
 export function useIsArchiveDevice() {
     const clientApi = useClientApi();
-    const { data, error, isRefetching } = useSuspenseQuery(isArchiveDeviceQueryOptions({ clientApi }));
+    const { data, error, isRefetching } = useSuspenseQuery({
+        ...baseQueryOptions(),
+        queryKey: getIsArchiveDeviceQueryKey(),
+        queryFn: async () => {
+            return clientApi.getIsArchiveDevice();
+        },
+    });
     return { data, error, isRefetching };
 }
 /**
@@ -70,10 +82,20 @@ export function useIsArchiveDevice() {
 export function useSetOwnDeviceInfo() {
     const queryClient = useQueryClient();
     const clientApi = useClientApi();
-    const { error, mutate, mutateAsync, reset, status } = useMutation(setOwnDeviceInfoMutationOptions({ clientApi, queryClient }));
-    return status === 'error'
-        ? { error, mutate, mutateAsync, reset, status }
-        : { error: null, mutate, mutateAsync, reset, status };
+    return filterMutationResult(useMutation({
+        ...baseMutationOptions(),
+        mutationFn: async ({ name, deviceType, }) => {
+            return clientApi.setDeviceInfo({ name, deviceType });
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({
+                queryKey: getDeviceInfoQueryKey(),
+            });
+            queryClient.invalidateQueries({
+                queryKey: getProjectsQueryKey(),
+            });
+        },
+    }));
 }
 /**
  * Set or unset the current device as an archive device.
@@ -81,8 +103,15 @@ export function useSetOwnDeviceInfo() {
 export function useSetIsArchiveDevice() {
     const queryClient = useQueryClient();
     const clientApi = useClientApi();
-    const { error, mutate, mutateAsync, status, reset } = useMutation(setIsArchiveDeviceMutationOptions({ clientApi, queryClient }));
-    return status === 'error'
-        ? { error, mutate, mutateAsync, reset, status }
-        : { error: null, mutate, mutateAsync, reset, status };
+    return filterMutationResult(useMutation({
+        ...baseMutationOptions(),
+        mutationFn: async ({ isArchiveDevice }) => {
+            return clientApi.setIsArchiveDevice(isArchiveDevice);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({
+                queryKey: getIsArchiveDeviceQueryKey(),
+            });
+        },
+    }));
 }