@gen-epix/ui 1.14.4 → 1.15.0

package/src/dataHooks/useIdentifierIssuerOwnOrganizationQuery/index.ts

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

package/src/dataHooks/useIdentifierIssuerOwnOrganizationQuery/useIdentifierIssuerOwnOrganizationQuery.ts

@@ -0,0 +1,34 @@
+import { useMemo } from 'react';
+import { type UseQueryResult } from '@tanstack/react-query';
+
+import type { IdentifierIssuer } from '../../api';
+import { OrganizationApi } from '../../api';
+import type { 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 { AuthorizationManager } from '../../classes/managers/AuthorizationManager';
+
+export const useIdentifierIssuerOwnOrganizationQuery = (): UseQueryResult<IdentifierIssuer[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.IDENTIFIER_ISSUERS_OWN_ORGANIZATION),
+    queryFn: async ({ signal }) => {
+      const links = (await OrganizationApi.instance.organizationIdentifierIssuerLinksPostQuery({
+        type: 'EQUALS_UUID',
+        key: 'organization_id',
+        value: AuthorizationManager.instance.user.organization_id,
+      }, { signal })).data;
+      const response = await OrganizationApi.instance.identifierIssuersGetSome(links.map(x => x.identifier_issuer_id).join(','), { signal });
+      return response.data;
+    },
+  });
+};
+
+export const useIdentifierIssuerOwnOrganizationOptionsQuery = (): UseOptions<string> => {
+  const response = useIdentifierIssuerOwnOrganizationQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseOptionsDataHook<IdentifierIssuer>(response, item => item.id, (item: IdentifierIssuer) => item.name);
+  }, [response]);
+};

package/src/dataHooks/useIdentifierIssuerQuery/index.ts

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

package/src/dataHooks/useIdentifierIssuerQuery/useIdentifierIssuerQuery.ts

@@ -0,0 +1,42 @@
+import { useMemo } from 'react';
+import { type UseQueryResult } from '@tanstack/react-query';
+
+import type { IdentifierIssuer } from '../../api';
+import { OrganizationApi } 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';
+
+type Select = (data: IdentifierIssuer[]) => IdentifierIssuer[];
+
+export const useIdentifierIssuersQuery = (select?: Select): UseQueryResult<IdentifierIssuer[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.IDENTIFIER_ISSUERS),
+    queryFn: async ({ signal }) => {
+      const response = await OrganizationApi.instance.identifierIssuersGetAll({ signal });
+      return response.data;
+    },
+    select: select ? (data) => select(data) : undefined,
+  });
+};
+
+export const useIdentifierIssuerMapQuery = (select?: Select): UseMap<IdentifierIssuer> => {
+  const response = useIdentifierIssuersQuery(select);
+
+  return useMemo(() => {
+    return DataHookUtil.createUseMapDataHook<IdentifierIssuer>(response, item => item.id);
+  }, [response]);
+};
+
+export const useIdentifierIssuerOptionsQuery = (select?: Select): UseOptions<string> => {
+  const response = useIdentifierIssuersQuery(select);
+
+  return useMemo(() => {
+    return DataHookUtil.createUseOptionsDataHook<IdentifierIssuer>(response, item => item.id, (item: IdentifierIssuer) => item.name);
+  }, [response]);
+};

package/src/dataHooks/useInviteUserConstraintsQuery/index.ts

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

package/src/dataHooks/useInviteUserConstraintsQuery/useInviteUserConstraintsQuery.ts

@@ -0,0 +1,32 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+
+import type { UserInvitationConstraints } from '../../api';
+import {
+  CommandName,
+  OrganizationApi,
+  PermissionType,
+} from '../../api';
+import { QUERY_KEY } from '../../models/query';
+import { QueryUtil } from '../../utils/QueryUtil';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+import { AuthorizationManager } from '../../classes/managers/AuthorizationManager';
+
+
+export const useInviteUserConstraintsQuery = (): UseQueryResult<UserInvitationConstraints> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.INVITE_USER_CONSTRAINTS),
+    queryFn: async ({ signal }) => {
+      if (!AuthorizationManager.instance.doesUserHavePermission([
+        { command_name: CommandName.RetrieveInviteUserConstraintsCommand, permission_type: PermissionType.EXECUTE },
+      ])) {
+        return {
+          roles: [],
+          organization_ids: [],
+        };
+      }
+
+      const response = await OrganizationApi.instance.inviteUserConstraints({ signal });
+      return response.data;
+    },
+  });
+};

package/src/dataHooks/useOrganizationAccessCasePoliciesQuery/index.ts

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

package/src/dataHooks/useOrganizationAccessCasePoliciesQuery/useOrganizationAccessCasePoliciesQuery.ts

@@ -0,0 +1,20 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+
+import {
+  AbacApi,
+  type OrganizationAccessCasePolicy,
+} from '../../api';
+import { QUERY_KEY } from '../../models/query';
+import { QueryUtil } from '../../utils/QueryUtil';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+
+export const useOrganizationAccessCasePoliciesQuery = (select?: (data: OrganizationAccessCasePolicy[]) => OrganizationAccessCasePolicy[]): UseQueryResult<OrganizationAccessCasePolicy[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.ORGANIZATION_ACCESS_CASE_POLICIES),
+    queryFn: async ({ signal }) => {
+      const response = await AbacApi.instance.organizationAccessCasePoliciesGetAll({ signal });
+      return response.data;
+    },
+    select: select ? (data) => select(data) : undefined,
+  });
+};

package/src/dataHooks/useOrganizationAdminPoliciesQuery/index.ts

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

package/src/dataHooks/useOrganizationAdminPoliciesQuery/useOrganizationAdminPoliciesQuery.ts

@@ -0,0 +1,60 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+import { useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import type { OrganizationAdminPolicy } from '../../api';
+import { AbacApi } 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 { useOrganizationMapQuery } from '../useOrganizationsQuery';
+import { useUsersMapQuery } from '../useUsersQuery';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+import { DataUtil } from '../../utils/DataUtil';
+
+export const useOrganizationAdminPoliciesQuery = (): UseQueryResult<OrganizationAdminPolicy[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.ORGANIZATION_ADMIN_POLICIES),
+    queryFn: async ({ signal }) => {
+      const response = await AbacApi.instance.organizationAdminPoliciesGetAll({ signal });
+      return response.data;
+    },
+  });
+};
+
+export const useOrganizationAdminPolicyMapQuery = (): UseMap<OrganizationAdminPolicy> => {
+  const organizationAdminPoliciesQuery = useOrganizationAdminPoliciesQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseMapDataHook<OrganizationAdminPolicy>(organizationAdminPoliciesQuery, item => item.id);
+
+  }, [organizationAdminPoliciesQuery]);
+};
+
+export const useOrganizationAdminPolicyNameFactory = (): UseNameFactory<OrganizationAdminPolicy> => {
+  const { t } = useTranslation();
+
+  const organizationMapQuery = useOrganizationMapQuery();
+  const usersMapQuery = useUsersMapQuery();
+
+  return useMemo(() => {
+    const getName = (item: OrganizationAdminPolicy) => {
+      return `${organizationMapQuery.map.get(item.organization_id)?.name ?? item.organization_id} → ${DataUtil.getUserDisplayValue(usersMapQuery.map.get(item.user_id), t)}`;
+    };
+    return DataHookUtil.createUseNameFactoryHook(getName, [organizationMapQuery, usersMapQuery]);
+  }, [organizationMapQuery, t, usersMapQuery]);
+};
+
+export const useOrganizationAdminPolicyOptionsQuery = (): UseOptions<string> => {
+  const organizationAdminPoliciesQuery = useOrganizationAdminPoliciesQuery();
+  const organizationAdminPolicyNameFactory = useOrganizationAdminPolicyNameFactory();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseOptionsDataHook<OrganizationAdminPolicy>(organizationAdminPoliciesQuery, item => item.id, organizationAdminPolicyNameFactory.getName, [organizationAdminPolicyNameFactory]);
+  }, [organizationAdminPolicyNameFactory, organizationAdminPoliciesQuery]);
+};

package/src/dataHooks/useOrganizationIdentifierIssuerLinksQuery/index.ts

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

package/src/dataHooks/useOrganizationIdentifierIssuerLinksQuery/useOrganizationIdentifierIssuerLinksQuery.ts

@@ -0,0 +1,18 @@
+import { type UseQueryResult } from '@tanstack/react-query';
+
+import type { OrganizationIdentifierIssuerLink } from '../../api';
+import { OrganizationApi } from '../../api';
+import { QUERY_KEY } from '../../models/query';
+import { QueryUtil } from '../../utils/QueryUtil';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+
+
+export const useOrganizationIdentifierIssuerLinksQuery = (): UseQueryResult<OrganizationIdentifierIssuerLink[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.IDENTIFIER_ISSUER_LINKS),
+    queryFn: async ({ signal }) => {
+      const response = await OrganizationApi.instance.organizationIdentifierIssuerLinksGetAll({ signal });
+      return response.data;
+    },
+  });
+};

package/src/dataHooks/useOrganizationShareCasePoliciesQuery/index.ts

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

package/src/dataHooks/useOrganizationShareCasePoliciesQuery/useOrganizationShareCasePoliciesQuery.ts

@@ -0,0 +1,18 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+
+import type { OrganizationShareCasePolicy } from '../../api';
+import { AbacApi } from '../../api';
+import { QUERY_KEY } from '../../models/query';
+import { QueryUtil } from '../../utils/QueryUtil';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+
+export const useOrganizationShareCasePoliciesQuery = (select?: (data: OrganizationShareCasePolicy[]) => OrganizationShareCasePolicy[]): UseQueryResult<OrganizationShareCasePolicy[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.ORGANIZATION_SHARE_CASE_POLICIES),
+    queryFn: async ({ signal }) => {
+      const response = await AbacApi.instance.organizationShareCasePoliciesGetAll({ signal });
+      return response.data;
+    },
+    select: select ? (data) => select(data) : undefined,
+  });
+};

package/src/dataHooks/useOrganizationsQuery/index.ts

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

package/src/dataHooks/useOrganizationsQuery/useOrganizationsQuery.ts

@@ -0,0 +1,40 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+import { useMemo } from 'react';
+
+import type { Organization } from '../../api';
+import { OrganizationApi } 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 { StringUtil } from '../../utils/StringUtil';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+
+export const useOrganizationsQuery = (): UseQueryResult<Organization[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.ORGANIZATIONS),
+    queryFn: async ({ signal }) => {
+      const response = await OrganizationApi.instance.organizationsGetAll({ signal });
+      return response.data;
+    },
+  });
+};
+
+export const useOrganizationMapQuery = (): UseMap<Organization> => {
+  const organizationsQuery = useOrganizationsQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseMapDataHook<Organization>(organizationsQuery, item => item.id);
+  }, [organizationsQuery]);
+};
+
+export const useOrganizationOptionsQuery = (): UseOptions<string> => {
+  const organizationsQuery = useOrganizationsQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseOptionsDataHook<Organization>(organizationsQuery, item => item.id, item => item.name, [], StringUtil.advancedSortComperator);
+  }, [organizationsQuery]);
+};

package/src/dataHooks/useRefColsQuery/index.ts

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

package/src/dataHooks/useRefColsQuery/useRefColsQuery.ts

@@ -0,0 +1,39 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+import { useMemo } from 'react';
+
+import type { RefCol } 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 useRefColsQuery = (): UseQueryResult<RefCol[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.REF_COLS),
+    queryFn: async ({ signal }) => {
+      const response = await CaseApi.instance.refColsGetAll({ signal });
+      return response.data;
+    },
+  });
+};
+
+export const useRefColMapQuery = (): UseMap<RefCol> => {
+  const response = useRefColsQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseMapDataHook<RefCol>(response, item => item.id);
+  }, [response]);
+};
+
+export const useRefColOptionsQuery = (): UseOptions<string> => {
+  const colsQuery = useRefColsQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseOptionsDataHook<RefCol>(colsQuery, item => item.id, item => item.label);
+  }, [colsQuery]);
+};

package/src/dataHooks/useRefColsValidationRulesQuery/index.ts

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

package/src/dataHooks/useRefColsValidationRulesQuery/useRefColsValidationRulesQuery.ts

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

package/src/dataHooks/useRefDimsQuery/index.ts

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

package/src/dataHooks/useRefDimsQuery/useRefDimsQuery.ts

@@ -0,0 +1,39 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+import { useMemo } from 'react';
+
+import type { RefDim } 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 useRefDimsQuery = (): UseQueryResult<RefDim[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.REF_DIMS),
+    queryFn: async ({ signal }) => {
+      const response = await CaseApi.instance.refDimsGetAll({ signal });
+      return response.data;
+    },
+  });
+};
+
+export const useRefDimMapQuery = (): UseMap<RefDim> => {
+  const response = useRefDimsQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseMapDataHook<RefDim>(response, item => item.id);
+  }, [response]);
+};
+
+export const useRefDimOptionsQuery = (): UseOptions<string> => {
+  const dimsQuery = useRefDimsQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseOptionsDataHook<RefDim>(dimsQuery, item => item.id, item => item.label);
+  }, [dimsQuery]);
+};

package/src/dataHooks/useRegionQuery/index.ts

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

package/src/dataHooks/useRegionQuery/useRegionQuery.ts

@@ -0,0 +1,52 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+import { useMemo } from 'react';
+
+import type { Region } from '../../api';
+import { GeoApi } 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 { useQueryMemo } from '../../hooks/useQueryMemo';
+import { useRegionSetsMapQuery } from '../useRegionSetsQuery';
+
+export const useRegionQuery = (): UseQueryResult<Region[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.REGIONS),
+    queryFn: async ({ signal }) => {
+      const response = await GeoApi.instance.regionsGetAll({ signal });
+      return response.data;
+    },
+  });
+};
+
+export const useRegionMapQuery = (): UseMap<Region> => {
+  const response = useRegionQuery();
+  return useMemo(() => {
+    return DataHookUtil.createUseMapDataHook<Region>(response, item => item.id);
+  }, [response]);
+};
+
+export const useRegionNameFactory = (): UseNameFactory<Region> => {
+  const regionSetsMapQuery = useRegionSetsMapQuery();
+
+  return useMemo(() => {
+    const getName = (item: Region) => {
+      return `${regionSetsMapQuery.map.get(item.region_set_id)?.name ?? item.region_set_id} → ${item.name}`;
+    };
+    return DataHookUtil.createUseNameFactoryHook(getName, [regionSetsMapQuery]);
+  }, [regionSetsMapQuery]);
+};
+
+export const useRegionOptionsQuery = (): UseOptions<string> => {
+  const regionQuery = useRegionQuery();
+  const regionMapQuery = useRegionNameFactory();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseOptionsDataHook<Region>(regionQuery, item => item.id, regionMapQuery.getName, [regionMapQuery]);
+  }, [regionMapQuery, regionQuery]);
+};

package/src/dataHooks/useRegionRelationTypeQuery/index.ts

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

package/src/dataHooks/useRegionRelationTypeQuery/useRegionRelationTypeQuery.ts

@@ -0,0 +1,24 @@
+import { useMemo } from 'react';
+
+import { RegionRelationType } from '../../api';
+import type { UseOptions } from '../../models/dataHooks';
+import type { OptionBase } from '../../models/form';
+
+
+export const regionRelationTypePresentationValues: Partial<Record<RegionRelationType, string>> = {
+  [RegionRelationType.CONTAINS]: 'CONTAINS',
+  [RegionRelationType.IS_SEPARATE_FROM]: 'IS_SEPARATE_FROM',
+  [RegionRelationType.IS_ADJACENT_TO]: 'IS_ADJACENT_TO',
+  [RegionRelationType.OVERLAPS_WITH]: 'OVERLAPS_WITH',
+};
+
+export const useRegionRelationTypeOptionsQuery = (): UseOptions<string> => {
+  return useMemo(() => {
+    const options: OptionBase<string>[] = Object.entries(regionRelationTypePresentationValues).map(([value, label]) => ({ value, label }));
+    return {
+      isLoading: false,
+      options,
+      error: null,
+    } as UseOptions<string>;
+  }, []);
+};

package/src/dataHooks/useRegionSetsQuery/index.ts

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

package/src/dataHooks/useRegionSetsQuery/useRegionSetsQuery.ts

@@ -0,0 +1,39 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+import { useMemo } from 'react';
+
+import type { RegionSet } from '../../api';
+import { GeoApi } from '../../api';
+import type {
+  UseOptions,
+  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 useRegionSetsQuery = (): UseQueryResult<RegionSet[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.REGION_SETS),
+    queryFn: async ({ signal }) => {
+      const response = await GeoApi.instance.regionSetsGetAll({ signal });
+      return response.data;
+    },
+  });
+};
+
+export const useRegionSetOptionsQuery = (): UseOptions<string> => {
+  const regionSetsQuery = useRegionSetsQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseOptionsDataHook<RegionSet>(regionSetsQuery, item => item.id, item => item.name);
+  }, [regionSetsQuery]);
+};
+
+export const useRegionSetsMapQuery = (): UseMap<RegionSet> => {
+  const regionSetsQuery = useRegionSetsQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseMapDataHook<RegionSet>(regionSetsQuery, item => item.id);
+  }, [regionSetsQuery]);
+};

package/src/dataHooks/useSequencingProtocolsQuery/index.ts

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

package/src/dataHooks/useSequencingProtocolsQuery/useSequencingProtocolsQuery.ts

@@ -0,0 +1,39 @@
+import { useMemo } from 'react';
+import { type UseQueryResult } from '@tanstack/react-query';
+
+import type { SequencingProtocol } 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 useSequencingProtocolsQuery = (): UseQueryResult<SequencingProtocol[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.SEQUENCING_PROTOCOLS),
+    queryFn: async ({ signal }) => {
+      const response = await CaseApi.instance.retrieveSequencingProtocols({ signal });
+      return response.data;
+    },
+  });
+};
+
+export const useSequencingProtocolMapQuery = (): UseMap<SequencingProtocol> => {
+  const response = useSequencingProtocolsQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseMapDataHook<SequencingProtocol>(response, item => item.id);
+  }, [response]);
+};
+
+export const useSequencingProtocolOptionsQuery = (): UseOptions<string> => {
+  const response = useSequencingProtocolsQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseOptionsDataHook<SequencingProtocol>(response, item => item.id, (item: SequencingProtocol) => item.name);
+  }, [response]);
+};

package/src/dataHooks/useTreeAlgorithmCodesQuery/index.ts

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

package/src/dataHooks/useTreeAlgorithmCodesQuery/useTreeAlgorithmCodesQuery.ts

@@ -0,0 +1,42 @@
+import { useMemo } from 'react';
+
+import { TreeAlgorithmType } from '../../api';
+import type { UseOptions } from '../../models/dataHooks';
+import type { OptionBase } from '../../models/form';
+
+export const treeAlgorithmCodeValues: Record<TreeAlgorithmType, string> = {
+  [TreeAlgorithmType.SLINK]: 'SLINK',
+  [TreeAlgorithmType.CLINK]: 'CLINK',
+  [TreeAlgorithmType.UPGMA]: 'UPGMA',
+  [TreeAlgorithmType.WPGMA]: 'WPGMA',
+  [TreeAlgorithmType.UPGMC]: 'UPGMC',
+  [TreeAlgorithmType.WPGMC]: 'WPGMC',
+  [TreeAlgorithmType.VERSATILE]: 'VERSATILE',
+  [TreeAlgorithmType.MISSQ]: 'MISSQ',
+  [TreeAlgorithmType.MNSSQ]: 'MNSSQ',
+  [TreeAlgorithmType.MIVAR]: 'MIVAR',
+  [TreeAlgorithmType.MNVAR]: 'MNVAR',
+  [TreeAlgorithmType.MINI_MAX]: 'MINI_MAX',
+  [TreeAlgorithmType.HAUSDORFF]: 'HAUSDORFF',
+  [TreeAlgorithmType.MIN_SUM_MEDOID]: 'MIN_SUM_MEDOID',
+  [TreeAlgorithmType.MIN_SUM_INCREASE_MEDOID]: 'MIN_SUM_INCREASE_MEDOID',
+  [TreeAlgorithmType.MEDOID]: 'MEDOID',
+  [TreeAlgorithmType.MIN_ENERGY]: 'MIN_ENERGY',
+  [TreeAlgorithmType.FITCH_MARGOLIASH]: 'FITCH_MARGOLIASH',
+  [TreeAlgorithmType.MAX_PARSIMONY]: 'MAX_PARSIMONY',
+  [TreeAlgorithmType.ML]: 'ML',
+  [TreeAlgorithmType.BAYESIAN_INFERENCE]: 'BAYESIAN_INFERENCE',
+  [TreeAlgorithmType.MIN_SPANNING]: 'MIN_SPANNING',
+  [TreeAlgorithmType.NJ]: 'NJ',
+};
+
+export const useTreeAlgorithmCodeOptionsQuery = (): UseOptions<string> => {
+  return useMemo(() => {
+    const options: OptionBase<string>[] = Object.entries(treeAlgorithmCodeValues).map(([value, label]) => ({ value, label }));
+    return {
+      isLoading: false,
+      options,
+      error: null as UseOptions<string>,
+    };
+  }, []);
+};

package/src/dataHooks/useUserAccessCasePoliciesQuery/index.ts

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

package/src/dataHooks/useUserAccessCasePoliciesQuery/useUserAccessCasePoliciesQuery.ts

@@ -0,0 +1,18 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+
+import type { UserAccessCasePolicy } from '../../api';
+import { AbacApi } from '../../api';
+import { QUERY_KEY } from '../../models/query';
+import { QueryUtil } from '../../utils/QueryUtil';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+
+export const useUserAccessCasePoliciesQuery = (select?: (data: UserAccessCasePolicy[]) => UserAccessCasePolicy[]): UseQueryResult<UserAccessCasePolicy[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.USER_ACCESS_CASE_POLICIES),
+    queryFn: async ({ signal }) => {
+      const response = await AbacApi.instance.userAccessCasePoliciesGetAll({ signal });
+      return response.data;
+    },
+    select: select ? (data) => select(data) : undefined,
+  });
+};

package/src/dataHooks/useUserEffectiveRightsQuery/index.ts

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