@gen-epix/ui 1.14.4 → 1.15.0

package/src/context/caseAbac/useCaseAbacContext.tsx

@@ -0,0 +1,6 @@
+import { useContext } from 'react';
+
+import type { CaseAbacContext } from './CaseAbacContext';
+import { EpiCaseAbacContext } from './CaseAbacContext';
+
+export const useCaseAbacContext = (): CaseAbacContext => useContext(EpiCaseAbacContext);

package/src/context/caseTypeAbac/CaseTypeAbacContext.tsx

@@ -0,0 +1,16 @@
+import { createContext } from 'react';
+
+import type {
+  DataCollection,
+  CaseTypeAccessAbac,
+} from '../../api';
+
+export type CaseTypeAbacContext = {
+  userDataCollections: DataCollection[];
+  userDataCollectionsMap: Map<string, DataCollection>;
+  caseTypeAccessAbacDict: { [key: string]: CaseTypeAccessAbac };
+  caseTypeAccessAbacs?: CaseTypeAccessAbac[];
+  effectiveColumnAccessRights?: Map<string, { read: boolean; write: boolean }>;
+};
+
+export const EpiCaseTypeAbacContext = createContext<CaseTypeAbacContext>(null);

package/src/context/caseTypeAbac/CaseTypeAbacContextProvider.tsx

@@ -0,0 +1,40 @@
+import {
+  useMemo,
+  type PropsWithChildren,
+} from 'react';
+
+
+import { AbacUtil } from '../../utils/AbacUtil';
+
+import type { CaseTypeAbacContext } from './CaseTypeAbacContext';
+import { EpiCaseTypeAbacContext } from './CaseTypeAbacContext';
+
+export type CaseTypeAbacContextProviderProps = PropsWithChildren<{
+  readonly caseTypeAbac: CaseTypeAbacContext;
+}>;
+
+export const CaseTypeAbacContextProvider = (
+  props: CaseTypeAbacContextProviderProps,
+) => {
+  const { children, caseTypeAbac } = props;
+
+  const sanitizedCaseAbac = useMemo<CaseTypeAbacContext>(() => {
+    const caseTypeAccessAbacs = Object.values(caseTypeAbac.caseTypeAccessAbacDict).filter(x => !!caseTypeAbac.userDataCollectionsMap.get(x.data_collection_id)).sort((a, b) => {
+      const aDataCollection = caseTypeAbac.userDataCollectionsMap.get(a.data_collection_id);
+      const bDataCollection = caseTypeAbac.userDataCollectionsMap.get(b.data_collection_id);
+      return aDataCollection?.name.localeCompare(bDataCollection?.name) ?? 0;
+    });
+
+    return {
+      ...caseTypeAbac,
+      caseTypeAccessAbacs,
+      effectiveColumnAccessRights: AbacUtil.createEffectieveColumnAccessRights(caseTypeAccessAbacs),
+    } satisfies CaseTypeAbacContext;
+  }, [caseTypeAbac]);
+
+  return (
+    <EpiCaseTypeAbacContext.Provider value={sanitizedCaseAbac}>
+      {children}
+    </EpiCaseTypeAbacContext.Provider>
+  );
+};

package/src/context/caseTypeAbac/index.ts

@@ -0,0 +1,3 @@
+export * from './CaseTypeAbacContextProvider';
+export * from './useCaseTypeAbacContext';
+export * from './CaseTypeAbacContext';

package/src/context/caseTypeAbac/useCaseTypeAbacContext.tsx

@@ -0,0 +1,6 @@
+import { useContext } from 'react';
+
+import type { CaseTypeAbacContext } from './CaseTypeAbacContext';
+import { EpiCaseTypeAbacContext } from './CaseTypeAbacContext';
+
+export const useCaseTypeAbacContext = (): CaseTypeAbacContext => useContext(EpiCaseTypeAbacContext);

package/src/data/date.ts

@@ -0,0 +1,8 @@
+export const DATE_FORMAT = {
+  DATE: 'yyyy-MM-dd',
+  DATE_TIME: 'yyyy-MM-dd HH:mm:ss',
+  YEAR: 'yyyy',
+  YEAR_MONTH: 'yyyy-MM',
+  YEAR_QUARTER: 'yyyy-QQQ',
+  YEAR_WEEK: 'YYYY-\'W\'ww',
+} as const;

package/src/data/queryDependencies.ts

@@ -0,0 +1,166 @@
+import { QUERY_KEY } from '../models/query';
+
+export const QUERY_DEPENDENCIES: Record<QUERY_KEY, QUERY_KEY[]> = {
+  [QUERY_KEY.ASSEMBLY_PROTOCOLS]: [],
+  [QUERY_KEY.VALIDATE_CASES]: [],
+  [QUERY_KEY.CASE_SET_CATEGORIES]: [],
+  [QUERY_KEY.CASE_SET_MEMBERS]: [
+    QUERY_KEY.CASE_SET_STATS,
+    QUERY_KEY.CASE_IDS_BY_QUERY,
+    QUERY_KEY.XXX_CASE_ID_HAS_CASE_SET,
+  ],
+  [QUERY_KEY.XXX_CASE_ID_HAS_CASE_SET]: [],
+  [QUERY_KEY.CASE_SET_STATS]: [],
+  [QUERY_KEY.CASE_SET_STATUSES]: [],
+  [QUERY_KEY.CASE_SETS]: [
+    QUERY_KEY.CASE_SET_STATS,
+    QUERY_KEY.XXX_CASE_ID_HAS_CASE_SET,
+    QUERY_KEY.USER_ACCESS_CASE_POLICIES,
+    QUERY_KEY.ORGANIZATION_ACCESS_CASE_POLICIES,
+  ],
+  [QUERY_KEY.COL_SET_MEMBERS]: [],
+  [QUERY_KEY.COL_SETS]: [
+    QUERY_KEY.ORGANIZATION_ACCESS_CASE_POLICIES,
+    QUERY_KEY.USER_ACCESS_CASE_POLICIES,
+  ],
+  [QUERY_KEY.COLS]: [
+    QUERY_KEY.COMPLETE_CASE_TYPES,
+  ],
+  [QUERY_KEY.DIMS]: [
+    QUERY_KEY.COLS,
+    QUERY_KEY.COMPLETE_CASE_TYPES,
+  ],
+  [QUERY_KEY.CASE_TYPE_SET_CATEGORIES]: [],
+  [QUERY_KEY.CASE_TYPE_SET_MEMBERS]: [],
+  [QUERY_KEY.CASE_TYPE_SETS]: [],
+  [QUERY_KEY.CASE_TYPE_STATS]: [],
+  [QUERY_KEY.CASE_TYPES]: [
+    QUERY_KEY.CASE_IDS_BY_QUERY,
+    QUERY_KEY.COMPLETE_CASE_TYPES,
+    QUERY_KEY.CASE_TYPE_STATS,
+  ],
+  [QUERY_KEY.CASES]: [
+    QUERY_KEY.CASE_TYPE_STATS,
+    QUERY_KEY.CASE_SET_STATS,
+    QUERY_KEY.CASES_LAZY,
+    QUERY_KEY.PHYLOGENETIC_TREE,
+    QUERY_KEY.CASE_IDS_BY_QUERY,
+    QUERY_KEY.CASE_SET_MEMBERS,
+    QUERY_KEY.CASE_DATA_COLLECTION_LINKS,
+  ],
+  [QUERY_KEY.CASES_LAZY]: [],
+  [QUERY_KEY.REF_COLS]: [
+    QUERY_KEY.COLS,
+    QUERY_KEY.COMPLETE_CASE_TYPES,
+  ],
+  [QUERY_KEY.COMPLETE_CASE_TYPES]: [],
+  [QUERY_KEY.CONCEPT_SETS]: [],
+  [QUERY_KEY.CONCEPTS]: [],
+  [QUERY_KEY.CONCEPT_RELATIONS]: [], // FIXME
+  [QUERY_KEY.DATA_COLLECTIONS]: [
+    QUERY_KEY.DATA_COLLECTION_SET_MEMBERS,
+  ],
+  [QUERY_KEY.DATA_COLLECTION_SETS]: [
+    QUERY_KEY.DATA_COLLECTION_SET_MEMBERS,
+  ],
+  [QUERY_KEY.DATA_COLLECTION_SET_MEMBERS]: [],
+  [QUERY_KEY.REF_DIMS]: [
+    QUERY_KEY.REF_COLS,
+    QUERY_KEY.DIMS,
+    QUERY_KEY.COLS,
+    QUERY_KEY.COMPLETE_CASE_TYPES,
+  ],
+  [QUERY_KEY.DISEASES]: [
+    QUERY_KEY.COMPLETE_CASE_TYPES,
+  ],
+  [QUERY_KEY.ETIOLOGICAL_AGENTS]: [
+    QUERY_KEY.COMPLETE_CASE_TYPES,
+  ],
+  [QUERY_KEY.ETIOLOGIES]: [
+    QUERY_KEY.COMPLETE_CASE_TYPES,
+  ],
+  [QUERY_KEY.GENETIC_DISTANCE_PROTOCOLS]: [
+    QUERY_KEY.COMPLETE_CASE_TYPES,
+  ],
+  [QUERY_KEY.IDENTITY_PROVIDERS]: [],
+  [QUERY_KEY.ORGANIZATION_ADMIN_NAME_EMAILS]: [],
+  [QUERY_KEY.ORGANIZATION_ADMIN_POLICIES]: [
+    QUERY_KEY.ORGANIZATION_ADMIN_NAME_EMAILS,
+  ],
+  [QUERY_KEY.ORGANIZATION_ACCESS_CASE_POLICIES]: [
+    QUERY_KEY.COMPLETE_CASE_TYPES,
+  ],
+  [QUERY_KEY.ORGANIZATION_SHARE_CASE_POLICIES]: [], // FIXME
+  [QUERY_KEY.USER_ACCESS_CASE_POLICIES]: [
+    QUERY_KEY.COMPLETE_CASE_TYPES,
+  ],
+  [QUERY_KEY.USER_SHARE_CASE_POLICIES]: [], // FIXME
+  [QUERY_KEY.ORGANIZATIONS]: [
+    QUERY_KEY.ORGANIZATION_ADMIN_NAME_EMAILS,
+    QUERY_KEY.INVITE_USER_CONSTRAINTS,
+  ],
+  [QUERY_KEY.OUTAGES]: [],
+  [QUERY_KEY.PHYLOGENETIC_TREE]: [],
+  [QUERY_KEY.REGION_SET_SHAPES]: [],
+  [QUERY_KEY.REGION_SETS]: [
+    QUERY_KEY.REGION_SETS_LAZY,
+    QUERY_KEY.REGIONS,
+  ],
+  [QUERY_KEY.REGION_SETS_LAZY]: [],
+  [QUERY_KEY.REGIONS_LAZY]: [],
+  [QUERY_KEY.REGIONS]: [
+    QUERY_KEY.REGIONS_LAZY,
+  ],
+  [QUERY_KEY.REGION_RELATIONS]: [], // FIXME
+  [QUERY_KEY.CASE_IDS_BY_QUERY]: [],
+  [QUERY_KEY.USER_ME]: [],
+  [QUERY_KEY.USER_PERMISSIONS]: [],
+  [QUERY_KEY.USER_INVITATIONS]: [
+    QUERY_KEY.USERS,
+  ],
+  [QUERY_KEY.USERS]: [
+    QUERY_KEY.USER_ACCESS_CASE_POLICIES,
+    QUERY_KEY.USER_PERMISSIONS,
+  ],
+  [QUERY_KEY.SEQUENCING_PROTOCOLS]: [],
+  [QUERY_KEY.GENETIC_SEQUENCES]: [
+    QUERY_KEY.COMPLETE_CASE_TYPES,
+    QUERY_KEY.PHYLOGENETIC_TREE,
+  ],
+  [QUERY_KEY.ALLELE_PROFILES]: [
+    QUERY_KEY.COMPLETE_CASE_TYPES,
+    QUERY_KEY.PHYLOGENETIC_TREE,
+  ],
+  [QUERY_KEY.SUBJECTS]: [],
+  [QUERY_KEY.TREE_ALGORITHM_CLASSES]: [
+    QUERY_KEY.COMPLETE_CASE_TYPES,
+  ],
+  [QUERY_KEY.TREE_ALGORITHMS]: [
+    QUERY_KEY.COMPLETE_CASE_TYPES,
+  ],
+  [QUERY_KEY.CONTACTS]: [],
+  [QUERY_KEY.CASE_DATA_COLLECTION_LINKS]: [
+    QUERY_KEY.CASE_RIGHTS,
+  ],
+  [QUERY_KEY.CASE_SET_DATA_COLLECTION_LINKS]: [
+    QUERY_KEY.CASE_SET_RIGHTS,
+  ],
+  [QUERY_KEY.CASE_RIGHTS]: [],
+  [QUERY_KEY.CASE_SET_RIGHTS]: [],
+  [QUERY_KEY.SITES]: [
+    QUERY_KEY.CONTACTS,
+  ],
+  [QUERY_KEY.LICENSES]: [],
+  [QUERY_KEY.INVITE_USER_CONSTRAINTS]: [],
+  [QUERY_KEY.IDENTIFIER_ISSUERS_OWN_ORGANIZATION]: [],
+  [QUERY_KEY.IDENTIFIER_ISSUERS]: [
+    QUERY_KEY.IDENTIFIER_ISSUER_LINKS,
+    QUERY_KEY.IDENTIFIER_ISSUERS_OWN_ORGANIZATION,
+  ],
+  [QUERY_KEY.IDENTIFIER_ISSUER_LINKS]: [
+    QUERY_KEY.IDENTIFIER_ISSUERS_OWN_ORGANIZATION,
+  ],
+  [QUERY_KEY.REF_COLS_VALIDATION_RULES]: [],
+  [QUERY_KEY.SIMILAR_CASES]: [],
+  [QUERY_KEY.FEATURE_FLAGS]: [],
+};

package/src/dataHooks/useAssemblyProtocolsQuery/index.ts

@@ -0,0 +1 @@
+export * from './useAssemblyProtocolsQuery';

package/src/dataHooks/useAssemblyProtocolsQuery/useAssemblyProtocolsQuery.ts

@@ -0,0 +1,39 @@
+import { useMemo } from 'react';
+import { type UseQueryResult } from '@tanstack/react-query';
+
+import type { AssemblyProtocol } from '../../api';
+import { CaseApi } from '../../api';
+import type {
+  UseMap,
+  UseOptions,
+} from '../../models/dataHooks';
+import { QUERY_KEY } from '../../models/query';
+import { DataHookUtil } from '../../utils/DataHookUtil';
+import { QueryUtil } from '../../utils/QueryUtil';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+
+export const useAssemblyProtocolsQuery = (): UseQueryResult<AssemblyProtocol[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.ASSEMBLY_PROTOCOLS),
+    queryFn: async ({ signal }) => {
+      const response = await CaseApi.instance.retrieveAssemblyProtocols({ signal });
+      return response.data;
+    },
+  });
+};
+
+export const useAssemblyProtocolMapQuery = (): UseMap<AssemblyProtocol> => {
+  const response = useAssemblyProtocolsQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseMapDataHook<AssemblyProtocol>(response, item => item.id);
+  }, [response]);
+};
+
+export const useAssemblyProtocolOptionsQuery = (): UseOptions<string> => {
+  const response = useAssemblyProtocolsQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseOptionsDataHook<AssemblyProtocol>(response, item => item.id, (item: AssemblyProtocol) => item.name);
+  }, [response]);
+};

package/src/dataHooks/useCaseRightsQuery/index.ts

@@ -0,0 +1 @@
+export * from './useCaseRightsQuery';

package/src/dataHooks/useCaseRightsQuery/useCaseRightsQuery.ts

@@ -0,0 +1,21 @@
+import { type UseQueryResult } from '@tanstack/react-query';
+
+import type { CaseRights } from '../../api';
+import { CaseApi } from '../../api';
+import { QUERY_KEY } from '../../models/query';
+import { QueryUtil } from '../../utils/QueryUtil';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+
+export const useCaseRightsQuery = (caseIds: string[], caseTypeId: string): UseQueryResult<CaseRights[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.CASE_RIGHTS, caseIds),
+    queryFn: async ({ signal }) => {
+      const response = await CaseApi.instance.retrieveCaseRights({
+        case_ids: caseIds,
+        case_type_id: caseTypeId,
+      }, { signal });
+      return response.data;
+    },
+  });
+
+};

package/src/dataHooks/useCaseSetCategoriesQuery/index.ts

@@ -0,0 +1 @@
+export * from './useCaseSetCategoriesQuery';

package/src/dataHooks/useCaseSetCategoriesQuery/useCaseSetCategoriesQuery.ts

@@ -0,0 +1,39 @@
+import { useMemo } from 'react';
+import { type UseQueryResult } from '@tanstack/react-query';
+
+import type { CaseSetCategory } from '../../api';
+import { CaseApi } from '../../api';
+import type {
+  UseMap,
+  UseOptions,
+} from '../../models/dataHooks';
+import { QUERY_KEY } from '../../models/query';
+import { DataHookUtil } from '../../utils/DataHookUtil';
+import { QueryUtil } from '../../utils/QueryUtil';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+
+export const useCaseSetCategoriesQuery = (): UseQueryResult<CaseSetCategory[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.CASE_SET_CATEGORIES),
+    queryFn: async ({ signal }) => {
+      const response = await CaseApi.instance.caseSetCategoriesGetAll({ signal });
+      return response.data;
+    },
+  });
+};
+
+export const useCaseSetCategoryMapQuery = (): UseMap<CaseSetCategory> => {
+  const response = useCaseSetCategoriesQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseMapDataHook<CaseSetCategory>(response, item => item.id);
+  }, [response]);
+};
+
+export const useCaseSetCategoryOptionsQuery = (): UseOptions<string> => {
+  const response = useCaseSetCategoriesQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseOptionsDataHook<CaseSetCategory>(response, item => item.id, (item: CaseSetCategory) => item.name);
+  }, [response]);
+};

package/src/dataHooks/useCaseSetRightsQuery/index.ts

@@ -0,0 +1 @@
+export * from './useCaseSetRightsQuery';

package/src/dataHooks/useCaseSetRightsQuery/useCaseSetRightsQuery.ts

@@ -0,0 +1,17 @@
+import { type UseQueryResult } from '@tanstack/react-query';
+
+import type { CaseSetRights } from '../../api';
+import { CaseApi } from '../../api';
+import { QUERY_KEY } from '../../models/query';
+import { QueryUtil } from '../../utils/QueryUtil';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+
+export const useCaseSetRightsQuery = (caseSetIds: string[]): UseQueryResult<CaseSetRights[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.CASE_SET_RIGHTS, caseSetIds),
+    queryFn: async ({ signal }) => {
+      const response = await CaseApi.instance.retrieveCaseSetRights(caseSetIds, { signal });
+      return response.data;
+    },
+  });
+};

package/src/dataHooks/useCaseSetStatsQuery/index.ts

@@ -0,0 +1 @@
+export * from './useCaseSetStatsQuery';

package/src/dataHooks/useCaseSetStatsQuery/useCaseSetStatsQuery.ts

@@ -0,0 +1,31 @@
+import { useMemo } from 'react';
+import { type UseQueryResult } from '@tanstack/react-query';
+
+import type { CaseStats } from '../../api';
+import { CaseApi } from '../../api';
+import type { UseMap } from '../../models/dataHooks';
+import { QUERY_KEY } from '../../models/query';
+import { DataHookUtil } from '../../utils/DataHookUtil';
+import { QueryUtil } from '../../utils/QueryUtil';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+
+export const useCaseSetStatsQuery = (caseSetIds: string[]): UseQueryResult<CaseStats[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.CASE_SET_STATS, caseSetIds),
+    queryFn: async ({ signal }) => {
+      const response = await CaseApi.instance.retrieveCaseSetStats({
+        case_set_ids: caseSetIds,
+      }, { signal });
+      return response.data;
+    },
+    enabled: !!caseSetIds?.length,
+  });
+};
+
+export const useCaseSetStatsMapQuery = (caseSetIds: string[]): UseMap<CaseStats> => {
+  const response = useCaseSetStatsQuery(caseSetIds);
+
+  return useMemo(() => {
+    return DataHookUtil.createUseMapDataHook<CaseStats>(response, item => item.case_set_id);
+  }, [response]);
+};

package/src/dataHooks/useCaseSetStatusesQuery/index.ts

@@ -0,0 +1 @@
+export * from './useCaseSetStatusesQuery';

package/src/dataHooks/useCaseSetStatusesQuery/useCaseSetStatusesQuery.ts

@@ -0,0 +1,39 @@
+import { useMemo } from 'react';
+import { type UseQueryResult } from '@tanstack/react-query';
+
+import type { CaseSetStatus } from '../../api';
+import { CaseApi } from '../../api';
+import type {
+  UseMap,
+  UseOptions,
+} from '../../models/dataHooks';
+import { QUERY_KEY } from '../../models/query';
+import { DataHookUtil } from '../../utils/DataHookUtil';
+import { QueryUtil } from '../../utils/QueryUtil';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+
+export const useCaseSetStatusesQuery = (): UseQueryResult<CaseSetStatus[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.CASE_SET_STATUSES),
+    queryFn: async ({ signal }) => {
+      const response = await CaseApi.instance.caseSetStatusesGetAll({ signal });
+      return response.data;
+    },
+  });
+};
+
+export const useCaseSetStatusMapQuery = (): UseMap<CaseSetStatus> => {
+  const response = useCaseSetStatusesQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseMapDataHook<CaseSetStatus>(response, item => item.id);
+  }, [response]);
+};
+
+export const useCaseSetStatusOptionsQuery = (): UseOptions<string> => {
+  const response = useCaseSetStatusesQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseOptionsDataHook<CaseSetStatus>(response, item => item.id, (item: CaseSetStatus) => item.name);
+  }, [response]);
+};

package/src/dataHooks/useCaseSetsQuery/index.ts

@@ -0,0 +1 @@
+export * from './useCaseSetsQuery';

package/src/dataHooks/useCaseSetsQuery/useCaseSetsQuery.ts

@@ -0,0 +1,41 @@
+import { useMemo } from 'react';
+import { type UseQueryResult } from '@tanstack/react-query';
+
+import type { CaseSet } from '../../api';
+import { CaseApi } from '../../api';
+import type {
+  UseMap,
+  UseOptions,
+} from '../../models/dataHooks';
+import { QUERY_KEY } from '../../models/query';
+import { DataHookUtil } from '../../utils/DataHookUtil';
+import { QueryUtil } from '../../utils/QueryUtil';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+import { DataUtil } from '../../utils/DataUtil';
+
+
+export const useCaseSetsQuery = (): UseQueryResult<CaseSet[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.CASE_SETS),
+    queryFn: async ({ signal }) => {
+      const response = await CaseApi.instance.caseSetsGetAll({ signal });
+      return response.data;
+    },
+  });
+};
+
+export const useCaseSetsMapQuery = (): UseMap<CaseSet> => {
+  const response = useCaseSetsQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseMapDataHook<CaseSet>(response, item => item.id);
+  }, [response]);
+};
+
+export const useCaseSetOptionsQuery = (): UseOptions<string> => {
+  const response = useCaseSetsQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseOptionsDataHook<CaseSet>(response, item => item.id, (item: CaseSet) => DataUtil.getCaseSetName(item));
+  }, [response]);
+};

package/src/dataHooks/useCaseTypeSetCategoriesQuery/index.ts

@@ -0,0 +1 @@
+export * from './useCaseTypeSetCategoriesQuery';

package/src/dataHooks/useCaseTypeSetCategoriesQuery/useCaseTypeSetCategoriesQuery.ts

@@ -0,0 +1,41 @@
+import { useMemo } from 'react';
+import { type UseQueryResult } from '@tanstack/react-query';
+
+import type { CaseTypeSetCategory } from '../../api';
+import { CaseApi } from '../../api';
+import type {
+  UseMap,
+  UseOptions,
+} from '../../models/dataHooks';
+import { QUERY_KEY } from '../../models/query';
+import { DataHookUtil } from '../../utils/DataHookUtil';
+import { QueryUtil } from '../../utils/QueryUtil';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+
+export const useCaseTypeSetCategoriesQuery = (): UseQueryResult<CaseTypeSetCategory[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.CASE_TYPE_SET_CATEGORIES),
+    queryFn: async ({ signal }) => {
+      const response = await CaseApi.instance.caseTypeSetCategoriesGetAll({ signal });
+      const items = response.data;
+      items.sort((a, b) => a.rank - b.rank);
+      return items;
+    },
+  });
+};
+
+export const useCaseTypeSetCategoryMapQuery = (): UseMap<CaseTypeSetCategory> => {
+  const response = useCaseTypeSetCategoriesQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseMapDataHook<CaseTypeSetCategory>(response, item => item.id);
+  }, [response]);
+};
+
+export const useCaseTypeSetCategoryOptionsQuery = (): UseOptions<string> => {
+  const response = useCaseTypeSetCategoriesQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseOptionsDataHook<CaseTypeSetCategory>(response, item => item.id, item => item.name);
+  }, [response]);
+};

package/src/dataHooks/useCaseTypeSetMembersQuery/index.ts

@@ -0,0 +1 @@
+export * from './useCaseTypeSetMembersQuery';

package/src/dataHooks/useCaseTypeSetMembersQuery/useCaseTypeSetMembersQuery.ts

@@ -0,0 +1,17 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+
+import type { CaseTypeSetMember } from '../../api';
+import { CaseApi } from '../../api';
+import { QUERY_KEY } from '../../models/query';
+import { QueryUtil } from '../../utils/QueryUtil';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+
+export const useCaseTypeSetMembersQuery = (): UseQueryResult<CaseTypeSetMember[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.CASE_TYPE_SET_MEMBERS),
+    queryFn: async ({ signal }) => {
+      const response = await CaseApi.instance.caseTypeSetMembersGetAll({ signal });
+      return response.data;
+    },
+  });
+};

package/src/dataHooks/useCaseTypeSetsQuery/index.ts

@@ -0,0 +1 @@
+export * from './useCaseTypeSetsQuery';

package/src/dataHooks/useCaseTypeSetsQuery/useCaseTypeSetsQuery.ts

@@ -0,0 +1,58 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+import { useMemo } from 'react';
+
+import type { CaseTypeSet } from '../../api';
+import { CaseApi } from '../../api';
+import type {
+  UseMap,
+  UseNameFactory,
+  UseOptions,
+} from '../../models/dataHooks';
+import { QUERY_KEY } from '../../models/query';
+import { DataHookUtil } from '../../utils/DataHookUtil';
+import { QueryUtil } from '../../utils/QueryUtil';
+import { useCaseTypeSetCategoryMapQuery } from '../useCaseTypeSetCategoriesQuery';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+
+export const useCaseTypeSetsQuery = (): UseQueryResult<CaseTypeSet[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.CASE_TYPE_SETS),
+    queryFn: async ({ signal }) => {
+      const response = await CaseApi.instance.caseTypeSetsGetAll({ signal });
+      return response.data;
+    },
+  });
+};
+
+export const useCaseTypeSetsMapQuery = (): UseMap<CaseTypeSet> => {
+  const caseTypeSetsQuery = useCaseTypeSetsQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseMapDataHook<CaseTypeSet>(caseTypeSetsQuery, item => item.id);
+  }, [caseTypeSetsQuery]);
+};
+
+export const useCaseTypeSetNameFactory = (): UseNameFactory<CaseTypeSet> => {
+  const caseTypeSetCategoryMapQuery = useCaseTypeSetCategoryMapQuery();
+
+  return useMemo(() => {
+    const getName = (item: CaseTypeSet) => {
+      return `${caseTypeSetCategoryMapQuery.map.get(item.case_type_set_category_id)?.name ?? ''} | ${item.name}`;
+    };
+    return DataHookUtil.createUseNameFactoryHook(getName, [caseTypeSetCategoryMapQuery]);
+  }, [caseTypeSetCategoryMapQuery]);
+};
+
+export const useCaseTypeSetOptionsQuery = (): UseOptions<string> => {
+  const caseTypeSetsQuery = useCaseTypeSetsQuery();
+  const caseTypeSetNameFactory = useCaseTypeSetNameFactory();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseOptionsDataHook<CaseTypeSet>(
+      caseTypeSetsQuery,
+      item => item.id,
+      caseTypeSetNameFactory.getName,
+      [caseTypeSetNameFactory],
+    );
+  }, [caseTypeSetNameFactory, caseTypeSetsQuery]);
+};

package/src/dataHooks/useCaseTypeStatsQuery/index.ts

@@ -0,0 +1 @@
+export * from './useCaseTypeStatsQuery';

package/src/dataHooks/useCaseTypeStatsQuery/useCaseTypeStatsQuery.ts

@@ -0,0 +1,20 @@
+import { type UseQueryResult } from '@tanstack/react-query';
+
+import type {
+  RetrieveCaseTypeStatsRequestBody,
+  CaseStats,
+} from '../../api';
+import { CaseApi } from '../../api';
+import { QUERY_KEY } from '../../models/query';
+import { QueryUtil } from '../../utils/QueryUtil';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+
+export const useCaseTypeStatsQuery = (options?: RetrieveCaseTypeStatsRequestBody): UseQueryResult<CaseStats[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.CASE_TYPE_STATS, options ?? {}),
+    queryFn: async ({ signal }) => {
+      const response = await CaseApi.instance.retrieveCaseTypeStats(options ?? {}, { signal });
+      return response.data;
+    },
+  });
+};

package/src/dataHooks/useCaseTypesQuery/index.ts

@@ -0,0 +1 @@
+export * from './useCaseTypesQuery';