@squonk/account-server-client 4.4.0-4-4.2195235454 → 4.4.0-4-4.2197069952

package/src/api/unit/unit.fetch.ts

@@ -0,0 +1,1394 @@
+/**
+ * Generated by orval v7.17.0 🍺
+ * Do not edit manually.
+ * Account Server API
+ * The Informatics Matters Account Server API.
+
+A service that provides access to the Account Server, which gives *registered* users access to and management of **Organisations**, **Units**, **Products**, **Users**, and **Assets**.
+
+ * OpenAPI spec version: 4.4
+ */
+import { useMutation, useQuery, useSuspenseQuery } from "@tanstack/react-query";
+import type {
+  InvalidateOptions,
+  MutationFunction,
+  QueryClient,
+  QueryFunction,
+  QueryKey,
+  UseMutationOptions,
+  UseMutationResult,
+  UseQueryOptions,
+  UseQueryResult,
+  UseSuspenseQueryOptions,
+  UseSuspenseQueryResult,
+} from "@tanstack/react-query";
+
+import type {
+  AsError,
+  GetUnitsParams,
+  OrganisationUnitPostBodyBody,
+  OrganisationUnitPostResponse,
+  OrganisationUnitsGetResponse,
+  PersonalUnitPutBodyBody,
+  PersonalUnitPutResponse,
+  UnitAllDetail,
+  UnitPatchBodyBody,
+  UnitsGetResponse,
+} from ".././api-schemas";
+
+import { customFetch } from "../../custom-fetch";
+import type { ErrorType } from "../../custom-fetch";
+
+type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
+
+/**
+ * Gets Organisational Units you have access to or that are public
+
+ * @summary Gets Organisational Units
+ */
+export type getOrganisationUnitsResponse200 = { data: OrganisationUnitsGetResponse; status: 200 };
+
+export type getOrganisationUnitsResponse401 = { data: void; status: 401 };
+
+export type getOrganisationUnitsResponse403 = { data: AsError; status: 403 };
+
+export type getOrganisationUnitsResponse404 = { data: AsError; status: 404 };
+
+export type getOrganisationUnitsResponseSuccess = getOrganisationUnitsResponse200 & {
+  headers: Headers;
+};
+export type getOrganisationUnitsResponseError = (
+  | getOrganisationUnitsResponse401
+  | getOrganisationUnitsResponse403
+  | getOrganisationUnitsResponse404
+) & { headers: Headers };
+
+export type getOrganisationUnitsResponse =
+  | getOrganisationUnitsResponseSuccess
+  | getOrganisationUnitsResponseError;
+
+export const getGetOrganisationUnitsUrl = (orgId: string) => {
+  return `/organisation/${orgId}/unit`;
+};
+
+export const getOrganisationUnits = async (
+  orgId: string,
+  options?: RequestInit,
+): Promise<getOrganisationUnitsResponse> => {
+  return customFetch<getOrganisationUnitsResponse>(getGetOrganisationUnitsUrl(orgId), {
+    ...options,
+    method: "GET",
+  });
+};
+
+export const getGetOrganisationUnitsQueryKey = (orgId?: string) => {
+  return ["account-server", "organisation", orgId, "unit"] as const;
+};
+
+export const getGetOrganisationUnitsQueryOptions = <
+  TData = Awaited<ReturnType<typeof getOrganisationUnits>>,
+  TError = ErrorType<void | AsError>,
+>(
+  orgId: string,
+  options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getOrganisationUnits>>, TError, TData>;
+    request?: SecondParameter<typeof customFetch>;
+  },
+) => {
+  const { query: queryOptions, request: requestOptions } = options ?? {};
+
+  const queryKey = queryOptions?.queryKey ?? getGetOrganisationUnitsQueryKey(orgId);
+
+  const queryFn: QueryFunction<Awaited<ReturnType<typeof getOrganisationUnits>>> = ({ signal }) =>
+    getOrganisationUnits(orgId, { signal, ...requestOptions });
+
+  return { queryKey, queryFn, enabled: !!orgId, ...queryOptions } as UseQueryOptions<
+    Awaited<ReturnType<typeof getOrganisationUnits>>,
+    TError,
+    TData
+  > & { queryKey: QueryKey };
+};
+
+export type GetOrganisationUnitsQueryResult = NonNullable<
+  Awaited<ReturnType<typeof getOrganisationUnits>>
+>;
+export type GetOrganisationUnitsQueryError = ErrorType<void | AsError>;
+
+/**
+ * @summary Gets Organisational Units
+ */
+
+export function useGetOrganisationUnits<
+  TData = Awaited<ReturnType<typeof getOrganisationUnits>>,
+  TError = ErrorType<void | AsError>,
+>(
+  orgId: string,
+  options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getOrganisationUnits>>, TError, TData>;
+    request?: SecondParameter<typeof customFetch>;
+  },
+): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+  const queryOptions = getGetOrganisationUnitsQueryOptions(orgId, options);
+
+  const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & { queryKey: QueryKey };
+
+  query.queryKey = queryOptions.queryKey;
+
+  return query;
+}
+
+/**
+ * @summary Gets Organisational Units
+ */
+export const invalidateGetOrganisationUnits = async (
+  queryClient: QueryClient,
+  orgId: string,
+  options?: InvalidateOptions,
+): Promise<QueryClient> => {
+  await queryClient.invalidateQueries(
+    { queryKey: getGetOrganisationUnitsQueryKey(orgId) },
+    options,
+  );
+
+  return queryClient;
+};
+
+export const getGetOrganisationUnitsSuspenseQueryOptions = <
+  TData = Awaited<ReturnType<typeof getOrganisationUnits>>,
+  TError = ErrorType<void | AsError>,
+>(
+  orgId: string,
+  options?: {
+    query?: UseSuspenseQueryOptions<
+      Awaited<ReturnType<typeof getOrganisationUnits>>,
+      TError,
+      TData
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+) => {
+  const { query: queryOptions, request: requestOptions } = options ?? {};
+
+  const queryKey = queryOptions?.queryKey ?? getGetOrganisationUnitsQueryKey(orgId);
+
+  const queryFn: QueryFunction<Awaited<ReturnType<typeof getOrganisationUnits>>> = ({ signal }) =>
+    getOrganisationUnits(orgId, { signal, ...requestOptions });
+
+  return { queryKey, queryFn, ...queryOptions } as UseSuspenseQueryOptions<
+    Awaited<ReturnType<typeof getOrganisationUnits>>,
+    TError,
+    TData
+  > & { queryKey: QueryKey };
+};
+
+export type GetOrganisationUnitsSuspenseQueryResult = NonNullable<
+  Awaited<ReturnType<typeof getOrganisationUnits>>
+>;
+export type GetOrganisationUnitsSuspenseQueryError = ErrorType<void | AsError>;
+
+/**
+ * @summary Gets Organisational Units
+ */
+
+export function useGetOrganisationUnitsSuspense<
+  TData = Awaited<ReturnType<typeof getOrganisationUnits>>,
+  TError = ErrorType<void | AsError>,
+>(
+  orgId: string,
+  options?: {
+    query?: UseSuspenseQueryOptions<
+      Awaited<ReturnType<typeof getOrganisationUnits>>,
+      TError,
+      TData
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+): UseSuspenseQueryResult<TData, TError> & { queryKey: QueryKey } {
+  const queryOptions = getGetOrganisationUnitsSuspenseQueryOptions(orgId, options);
+
+  const query = useSuspenseQuery(queryOptions) as UseSuspenseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+  };
+
+  query.queryKey = queryOptions.queryKey;
+
+  return query;
+}
+
+/**
+ * Creates a new Organisation Unit.
+
+The **User** who creates the Unit becomes the **Owner** of the Unit. They are considered a *Member* (**User**) of the Unit but are not present in the list of users, which a separate list of users explicitly added to the Unit by a member of the Organisation or another member of the Unit.
+
+You need to be  a member of the **Organisation** or have administration rights to use this endpoint
+
+ * @summary Create a new Organisational Unit
+ */
+export type createOrganisationUnitResponse201 = { data: OrganisationUnitPostResponse; status: 201 };
+
+export type createOrganisationUnitResponse400 = { data: AsError; status: 400 };
+
+export type createOrganisationUnitResponse401 = { data: void; status: 401 };
+
+export type createOrganisationUnitResponse403 = { data: AsError; status: 403 };
+
+export type createOrganisationUnitResponseSuccess = createOrganisationUnitResponse201 & {
+  headers: Headers;
+};
+export type createOrganisationUnitResponseError = (
+  | createOrganisationUnitResponse400
+  | createOrganisationUnitResponse401
+  | createOrganisationUnitResponse403
+) & { headers: Headers };
+
+export type createOrganisationUnitResponse =
+  | createOrganisationUnitResponseSuccess
+  | createOrganisationUnitResponseError;
+
+export const getCreateOrganisationUnitUrl = (orgId: string) => {
+  return `/organisation/${orgId}/unit`;
+};
+
+export const createOrganisationUnit = async (
+  orgId: string,
+  organisationUnitPostBodyBody: OrganisationUnitPostBodyBody,
+  options?: RequestInit,
+): Promise<createOrganisationUnitResponse> => {
+  return customFetch<createOrganisationUnitResponse>(getCreateOrganisationUnitUrl(orgId), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(organisationUnitPostBodyBody),
+  });
+};
+
+export const getCreateOrganisationUnitMutationOptions = <
+  TError = ErrorType<AsError | void>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof createOrganisationUnit>>,
+    TError,
+    { orgId: string; data: OrganisationUnitPostBodyBody },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationOptions<
+  Awaited<ReturnType<typeof createOrganisationUnit>>,
+  TError,
+  { orgId: string; data: OrganisationUnitPostBodyBody },
+  TContext
+> => {
+  const mutationKey = ["createOrganisationUnit"];
+  const { mutation: mutationOptions, request: requestOptions } = options
+    ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey
+      ? options
+      : { ...options, mutation: { ...options.mutation, mutationKey } }
+    : { mutation: { mutationKey }, request: undefined };
+
+  const mutationFn: MutationFunction<
+    Awaited<ReturnType<typeof createOrganisationUnit>>,
+    { orgId: string; data: OrganisationUnitPostBodyBody }
+  > = (props) => {
+    const { orgId, data } = props ?? {};
+
+    return createOrganisationUnit(orgId, data, requestOptions);
+  };
+
+  return { mutationFn, ...mutationOptions };
+};
+
+export type CreateOrganisationUnitMutationResult = NonNullable<
+  Awaited<ReturnType<typeof createOrganisationUnit>>
+>;
+export type CreateOrganisationUnitMutationBody = OrganisationUnitPostBodyBody;
+export type CreateOrganisationUnitMutationError = ErrorType<AsError | void>;
+
+/**
+ * @summary Create a new Organisational Unit
+ */
+export const useCreateOrganisationUnit = <
+  TError = ErrorType<AsError | void>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof createOrganisationUnit>>,
+    TError,
+    { orgId: string; data: OrganisationUnitPostBodyBody },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationResult<
+  Awaited<ReturnType<typeof createOrganisationUnit>>,
+  TError,
+  { orgId: string; data: OrganisationUnitPostBodyBody },
+  TContext
+> => {
+  const mutationOptions = getCreateOrganisationUnitMutationOptions(options);
+
+  return useMutation(mutationOptions);
+};
+/**
+ * Gets a Unit. You can get a Unit if you are a member of it or are its creator. You can also get a Unit if you are a member of its **Organisation**, or its creator or an admin user.
+
+ * @summary Gets an Organisational Unit
+ */
+export type getUnitResponse200 = { data: UnitAllDetail; status: 200 };
+
+export type getUnitResponse401 = { data: void; status: 401 };
+
+export type getUnitResponse403 = { data: AsError; status: 403 };
+
+export type getUnitResponse404 = { data: AsError; status: 404 };
+
+export type getUnitResponseSuccess = getUnitResponse200 & { headers: Headers };
+export type getUnitResponseError = (
+  | getUnitResponse401
+  | getUnitResponse403
+  | getUnitResponse404
+) & { headers: Headers };
+
+export type getUnitResponse = getUnitResponseSuccess | getUnitResponseError;
+
+export const getGetUnitUrl = (unitId: string) => {
+  return `/unit/${unitId}`;
+};
+
+export const getUnit = async (unitId: string, options?: RequestInit): Promise<getUnitResponse> => {
+  return customFetch<getUnitResponse>(getGetUnitUrl(unitId), { ...options, method: "GET" });
+};
+
+export const getGetUnitQueryKey = (unitId?: string) => {
+  return ["account-server", "unit", unitId] as const;
+};
+
+export const getGetUnitQueryOptions = <
+  TData = Awaited<ReturnType<typeof getUnit>>,
+  TError = ErrorType<void | AsError>,
+>(
+  unitId: string,
+  options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getUnit>>, TError, TData>;
+    request?: SecondParameter<typeof customFetch>;
+  },
+) => {
+  const { query: queryOptions, request: requestOptions } = options ?? {};
+
+  const queryKey = queryOptions?.queryKey ?? getGetUnitQueryKey(unitId);
+
+  const queryFn: QueryFunction<Awaited<ReturnType<typeof getUnit>>> = ({ signal }) =>
+    getUnit(unitId, { signal, ...requestOptions });
+
+  return { queryKey, queryFn, enabled: !!unitId, ...queryOptions } as UseQueryOptions<
+    Awaited<ReturnType<typeof getUnit>>,
+    TError,
+    TData
+  > & { queryKey: QueryKey };
+};
+
+export type GetUnitQueryResult = NonNullable<Awaited<ReturnType<typeof getUnit>>>;
+export type GetUnitQueryError = ErrorType<void | AsError>;
+
+/**
+ * @summary Gets an Organisational Unit
+ */
+
+export function useGetUnit<
+  TData = Awaited<ReturnType<typeof getUnit>>,
+  TError = ErrorType<void | AsError>,
+>(
+  unitId: string,
+  options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getUnit>>, TError, TData>;
+    request?: SecondParameter<typeof customFetch>;
+  },
+): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+  const queryOptions = getGetUnitQueryOptions(unitId, options);
+
+  const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & { queryKey: QueryKey };
+
+  query.queryKey = queryOptions.queryKey;
+
+  return query;
+}
+
+/**
+ * @summary Gets an Organisational Unit
+ */
+export const invalidateGetUnit = async (
+  queryClient: QueryClient,
+  unitId: string,
+  options?: InvalidateOptions,
+): Promise<QueryClient> => {
+  await queryClient.invalidateQueries({ queryKey: getGetUnitQueryKey(unitId) }, options);
+
+  return queryClient;
+};
+
+export const getGetUnitSuspenseQueryOptions = <
+  TData = Awaited<ReturnType<typeof getUnit>>,
+  TError = ErrorType<void | AsError>,
+>(
+  unitId: string,
+  options?: {
+    query?: UseSuspenseQueryOptions<Awaited<ReturnType<typeof getUnit>>, TError, TData>;
+    request?: SecondParameter<typeof customFetch>;
+  },
+) => {
+  const { query: queryOptions, request: requestOptions } = options ?? {};
+
+  const queryKey = queryOptions?.queryKey ?? getGetUnitQueryKey(unitId);
+
+  const queryFn: QueryFunction<Awaited<ReturnType<typeof getUnit>>> = ({ signal }) =>
+    getUnit(unitId, { signal, ...requestOptions });
+
+  return { queryKey, queryFn, ...queryOptions } as UseSuspenseQueryOptions<
+    Awaited<ReturnType<typeof getUnit>>,
+    TError,
+    TData
+  > & { queryKey: QueryKey };
+};
+
+export type GetUnitSuspenseQueryResult = NonNullable<Awaited<ReturnType<typeof getUnit>>>;
+export type GetUnitSuspenseQueryError = ErrorType<void | AsError>;
+
+/**
+ * @summary Gets an Organisational Unit
+ */
+
+export function useGetUnitSuspense<
+  TData = Awaited<ReturnType<typeof getUnit>>,
+  TError = ErrorType<void | AsError>,
+>(
+  unitId: string,
+  options?: {
+    query?: UseSuspenseQueryOptions<Awaited<ReturnType<typeof getUnit>>, TError, TData>;
+    request?: SecondParameter<typeof customFetch>;
+  },
+): UseSuspenseQueryResult<TData, TError> & { queryKey: QueryKey } {
+  const queryOptions = getGetUnitSuspenseQueryOptions(unitId, options);
+
+  const query = useSuspenseQuery(queryOptions) as UseSuspenseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+  };
+
+  query.queryKey = queryOptions.queryKey;
+
+  return query;
+}
+
+/**
+ * Used to update existing Unit. You can change a Unit's **name** or its **default_product_privacy** (as long as the new privacy does not conflict with the Organisation's value).
+
+You have to be a member of the **Unit**, a member of its **Organisation**, or an administrator to patch a Unit.
+
+ * @summary Adjust an existing Unit
+ */
+export type patchUnitResponse200 = { data: void; status: 200 };
+
+export type patchUnitResponse401 = { data: void; status: 401 };
+
+export type patchUnitResponse403 = { data: AsError; status: 403 };
+
+export type patchUnitResponse404 = { data: AsError; status: 404 };
+
+export type patchUnitResponseSuccess = patchUnitResponse200 & { headers: Headers };
+export type patchUnitResponseError = (
+  | patchUnitResponse401
+  | patchUnitResponse403
+  | patchUnitResponse404
+) & { headers: Headers };
+
+export type patchUnitResponse = patchUnitResponseSuccess | patchUnitResponseError;
+
+export const getPatchUnitUrl = (unitId: string) => {
+  return `/unit/${unitId}`;
+};
+
+export const patchUnit = async (
+  unitId: string,
+  unitPatchBodyBody: UnitPatchBodyBody,
+  options?: RequestInit,
+): Promise<patchUnitResponse> => {
+  return customFetch<patchUnitResponse>(getPatchUnitUrl(unitId), {
+    ...options,
+    method: "PATCH",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(unitPatchBodyBody),
+  });
+};
+
+export const getPatchUnitMutationOptions = <
+  TError = ErrorType<void | AsError>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof patchUnit>>,
+    TError,
+    { unitId: string; data: UnitPatchBodyBody },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationOptions<
+  Awaited<ReturnType<typeof patchUnit>>,
+  TError,
+  { unitId: string; data: UnitPatchBodyBody },
+  TContext
+> => {
+  const mutationKey = ["patchUnit"];
+  const { mutation: mutationOptions, request: requestOptions } = options
+    ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey
+      ? options
+      : { ...options, mutation: { ...options.mutation, mutationKey } }
+    : { mutation: { mutationKey }, request: undefined };
+
+  const mutationFn: MutationFunction<
+    Awaited<ReturnType<typeof patchUnit>>,
+    { unitId: string; data: UnitPatchBodyBody }
+  > = (props) => {
+    const { unitId, data } = props ?? {};
+
+    return patchUnit(unitId, data, requestOptions);
+  };
+
+  return { mutationFn, ...mutationOptions };
+};
+
+export type PatchUnitMutationResult = NonNullable<Awaited<ReturnType<typeof patchUnit>>>;
+export type PatchUnitMutationBody = UnitPatchBodyBody;
+export type PatchUnitMutationError = ErrorType<void | AsError>;
+
+/**
+ * @summary Adjust an existing Unit
+ */
+export const usePatchUnit = <TError = ErrorType<void | AsError>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof patchUnit>>,
+    TError,
+    { unitId: string; data: UnitPatchBodyBody },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationResult<
+  Awaited<ReturnType<typeof patchUnit>>,
+  TError,
+  { unitId: string; data: UnitPatchBodyBody },
+  TContext
+> => {
+  const mutationOptions = getPatchUnitMutationOptions(options);
+
+  return useMutation(mutationOptions);
+};
+/**
+ * Deletes an Organisational Unit you have access to. Units can only be deleted by members of the Unit, its Organisation users or admin users.
+
+You cannot delete Units in the **Default Organisation**. These Units are **Personal Units** and need to be deleted using the `DELETE /unit` endpoint.
+
+You cannot delete a Unit that contains undeleted **Products**
+
+ * @summary Deletes an Organisational Unit
+ */
+export type deleteOrganisationUnitResponse204 = { data: void; status: 204 };
+
+export type deleteOrganisationUnitResponse401 = { data: void; status: 401 };
+
+export type deleteOrganisationUnitResponse403 = { data: AsError; status: 403 };
+
+export type deleteOrganisationUnitResponse404 = { data: AsError; status: 404 };
+
+export type deleteOrganisationUnitResponseSuccess = deleteOrganisationUnitResponse204 & {
+  headers: Headers;
+};
+export type deleteOrganisationUnitResponseError = (
+  | deleteOrganisationUnitResponse401
+  | deleteOrganisationUnitResponse403
+  | deleteOrganisationUnitResponse404
+) & { headers: Headers };
+
+export type deleteOrganisationUnitResponse =
+  | deleteOrganisationUnitResponseSuccess
+  | deleteOrganisationUnitResponseError;
+
+export const getDeleteOrganisationUnitUrl = (unitId: string) => {
+  return `/unit/${unitId}`;
+};
+
+export const deleteOrganisationUnit = async (
+  unitId: string,
+  options?: RequestInit,
+): Promise<deleteOrganisationUnitResponse> => {
+  return customFetch<deleteOrganisationUnitResponse>(getDeleteOrganisationUnitUrl(unitId), {
+    ...options,
+    method: "DELETE",
+  });
+};
+
+export const getDeleteOrganisationUnitMutationOptions = <
+  TError = ErrorType<void | AsError>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof deleteOrganisationUnit>>,
+    TError,
+    { unitId: string },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationOptions<
+  Awaited<ReturnType<typeof deleteOrganisationUnit>>,
+  TError,
+  { unitId: string },
+  TContext
+> => {
+  const mutationKey = ["deleteOrganisationUnit"];
+  const { mutation: mutationOptions, request: requestOptions } = options
+    ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey
+      ? options
+      : { ...options, mutation: { ...options.mutation, mutationKey } }
+    : { mutation: { mutationKey }, request: undefined };
+
+  const mutationFn: MutationFunction<
+    Awaited<ReturnType<typeof deleteOrganisationUnit>>,
+    { unitId: string }
+  > = (props) => {
+    const { unitId } = props ?? {};
+
+    return deleteOrganisationUnit(unitId, requestOptions);
+  };
+
+  return { mutationFn, ...mutationOptions };
+};
+
+export type DeleteOrganisationUnitMutationResult = NonNullable<
+  Awaited<ReturnType<typeof deleteOrganisationUnit>>
+>;
+
+export type DeleteOrganisationUnitMutationError = ErrorType<void | AsError>;
+
+/**
+ * @summary Deletes an Organisational Unit
+ */
+export const useDeleteOrganisationUnit = <
+  TError = ErrorType<void | AsError>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof deleteOrganisationUnit>>,
+    TError,
+    { unitId: string },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationResult<
+  Awaited<ReturnType<typeof deleteOrganisationUnit>>,
+  TError,
+  { unitId: string },
+  TContext
+> => {
+  const mutationOptions = getDeleteOrganisationUnitMutationOptions(options);
+
+  return useMutation(mutationOptions);
+};
+/**
+ * @summary Gets your Personal Unit (if you have one)
+ */
+export type getPersonalUnitResponse200 = { data: UnitAllDetail; status: 200 };
+
+export type getPersonalUnitResponse401 = { data: void; status: 401 };
+
+export type getPersonalUnitResponse403 = { data: AsError; status: 403 };
+
+export type getPersonalUnitResponse404 = { data: AsError; status: 404 };
+
+export type getPersonalUnitResponseSuccess = getPersonalUnitResponse200 & { headers: Headers };
+export type getPersonalUnitResponseError = (
+  | getPersonalUnitResponse401
+  | getPersonalUnitResponse403
+  | getPersonalUnitResponse404
+) & { headers: Headers };
+
+export type getPersonalUnitResponse = getPersonalUnitResponseSuccess | getPersonalUnitResponseError;
+
+export const getGetPersonalUnitUrl = () => {
+  return `/personal-unit`;
+};
+
+export const getPersonalUnit = async (options?: RequestInit): Promise<getPersonalUnitResponse> => {
+  return customFetch<getPersonalUnitResponse>(getGetPersonalUnitUrl(), {
+    ...options,
+    method: "GET",
+  });
+};
+
+export const getGetPersonalUnitQueryKey = () => {
+  return ["account-server", "personal-unit"] as const;
+};
+
+export const getGetPersonalUnitQueryOptions = <
+  TData = Awaited<ReturnType<typeof getPersonalUnit>>,
+  TError = ErrorType<void | AsError>,
+>(options?: {
+  query?: UseQueryOptions<Awaited<ReturnType<typeof getPersonalUnit>>, TError, TData>;
+  request?: SecondParameter<typeof customFetch>;
+}) => {
+  const { query: queryOptions, request: requestOptions } = options ?? {};
+
+  const queryKey = queryOptions?.queryKey ?? getGetPersonalUnitQueryKey();
+
+  const queryFn: QueryFunction<Awaited<ReturnType<typeof getPersonalUnit>>> = ({ signal }) =>
+    getPersonalUnit({ signal, ...requestOptions });
+
+  return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
+    Awaited<ReturnType<typeof getPersonalUnit>>,
+    TError,
+    TData
+  > & { queryKey: QueryKey };
+};
+
+export type GetPersonalUnitQueryResult = NonNullable<Awaited<ReturnType<typeof getPersonalUnit>>>;
+export type GetPersonalUnitQueryError = ErrorType<void | AsError>;
+
+/**
+ * @summary Gets your Personal Unit (if you have one)
+ */
+
+export function useGetPersonalUnit<
+  TData = Awaited<ReturnType<typeof getPersonalUnit>>,
+  TError = ErrorType<void | AsError>,
+>(options?: {
+  query?: UseQueryOptions<Awaited<ReturnType<typeof getPersonalUnit>>, TError, TData>;
+  request?: SecondParameter<typeof customFetch>;
+}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+  const queryOptions = getGetPersonalUnitQueryOptions(options);
+
+  const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & { queryKey: QueryKey };
+
+  query.queryKey = queryOptions.queryKey;
+
+  return query;
+}
+
+/**
+ * @summary Gets your Personal Unit (if you have one)
+ */
+export const invalidateGetPersonalUnit = async (
+  queryClient: QueryClient,
+  options?: InvalidateOptions,
+): Promise<QueryClient> => {
+  await queryClient.invalidateQueries({ queryKey: getGetPersonalUnitQueryKey() }, options);
+
+  return queryClient;
+};
+
+export const getGetPersonalUnitSuspenseQueryOptions = <
+  TData = Awaited<ReturnType<typeof getPersonalUnit>>,
+  TError = ErrorType<void | AsError>,
+>(options?: {
+  query?: UseSuspenseQueryOptions<Awaited<ReturnType<typeof getPersonalUnit>>, TError, TData>;
+  request?: SecondParameter<typeof customFetch>;
+}) => {
+  const { query: queryOptions, request: requestOptions } = options ?? {};
+
+  const queryKey = queryOptions?.queryKey ?? getGetPersonalUnitQueryKey();
+
+  const queryFn: QueryFunction<Awaited<ReturnType<typeof getPersonalUnit>>> = ({ signal }) =>
+    getPersonalUnit({ signal, ...requestOptions });
+
+  return { queryKey, queryFn, ...queryOptions } as UseSuspenseQueryOptions<
+    Awaited<ReturnType<typeof getPersonalUnit>>,
+    TError,
+    TData
+  > & { queryKey: QueryKey };
+};
+
+export type GetPersonalUnitSuspenseQueryResult = NonNullable<
+  Awaited<ReturnType<typeof getPersonalUnit>>
+>;
+export type GetPersonalUnitSuspenseQueryError = ErrorType<void | AsError>;
+
+/**
+ * @summary Gets your Personal Unit (if you have one)
+ */
+
+export function useGetPersonalUnitSuspense<
+  TData = Awaited<ReturnType<typeof getPersonalUnit>>,
+  TError = ErrorType<void | AsError>,
+>(options?: {
+  query?: UseSuspenseQueryOptions<Awaited<ReturnType<typeof getPersonalUnit>>, TError, TData>;
+  request?: SecondParameter<typeof customFetch>;
+}): UseSuspenseQueryResult<TData, TError> & { queryKey: QueryKey } {
+  const queryOptions = getGetPersonalUnitSuspenseQueryOptions(options);
+
+  const query = useSuspenseQuery(queryOptions) as UseSuspenseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+  };
+
+  query.queryKey = queryOptions.queryKey;
+
+  return query;
+}
+
+/**
+ * Creates a Personal Unit for a User. The unit will belong to the built-in **Default Organisation**.
+
+Users can only create one Personal unit and you cannot add other Users to a Personal Unit.
+
+ * @summary Create a new Personal Unit
+ */
+export type createPersonalUnitResponse201 = { data: PersonalUnitPutResponse; status: 201 };
+
+export type createPersonalUnitResponse400 = { data: AsError; status: 400 };
+
+export type createPersonalUnitResponse401 = { data: void; status: 401 };
+
+export type createPersonalUnitResponse403 = { data: AsError; status: 403 };
+
+export type createPersonalUnitResponseSuccess = createPersonalUnitResponse201 & {
+  headers: Headers;
+};
+export type createPersonalUnitResponseError = (
+  | createPersonalUnitResponse400
+  | createPersonalUnitResponse401
+  | createPersonalUnitResponse403
+) & { headers: Headers };
+
+export type createPersonalUnitResponse =
+  | createPersonalUnitResponseSuccess
+  | createPersonalUnitResponseError;
+
+export const getCreatePersonalUnitUrl = () => {
+  return `/personal-unit`;
+};
+
+export const createPersonalUnit = async (
+  personalUnitPutBodyBody: PersonalUnitPutBodyBody,
+  options?: RequestInit,
+): Promise<createPersonalUnitResponse> => {
+  return customFetch<createPersonalUnitResponse>(getCreatePersonalUnitUrl(), {
+    ...options,
+    method: "PUT",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(personalUnitPutBodyBody),
+  });
+};
+
+export const getCreatePersonalUnitMutationOptions = <
+  TError = ErrorType<AsError | void>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof createPersonalUnit>>,
+    TError,
+    { data: PersonalUnitPutBodyBody },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationOptions<
+  Awaited<ReturnType<typeof createPersonalUnit>>,
+  TError,
+  { data: PersonalUnitPutBodyBody },
+  TContext
+> => {
+  const mutationKey = ["createPersonalUnit"];
+  const { mutation: mutationOptions, request: requestOptions } = options
+    ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey
+      ? options
+      : { ...options, mutation: { ...options.mutation, mutationKey } }
+    : { mutation: { mutationKey }, request: undefined };
+
+  const mutationFn: MutationFunction<
+    Awaited<ReturnType<typeof createPersonalUnit>>,
+    { data: PersonalUnitPutBodyBody }
+  > = (props) => {
+    const { data } = props ?? {};
+
+    return createPersonalUnit(data, requestOptions);
+  };
+
+  return { mutationFn, ...mutationOptions };
+};
+
+export type CreatePersonalUnitMutationResult = NonNullable<
+  Awaited<ReturnType<typeof createPersonalUnit>>
+>;
+export type CreatePersonalUnitMutationBody = PersonalUnitPutBodyBody;
+export type CreatePersonalUnitMutationError = ErrorType<AsError | void>;
+
+/**
+ * @summary Create a new Personal Unit
+ */
+export const useCreatePersonalUnit = <
+  TError = ErrorType<AsError | void>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof createPersonalUnit>>,
+    TError,
+    { data: PersonalUnitPutBodyBody },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationResult<
+  Awaited<ReturnType<typeof createPersonalUnit>>,
+  TError,
+  { data: PersonalUnitPutBodyBody },
+  TContext
+> => {
+  const mutationOptions = getCreatePersonalUnitMutationOptions(options);
+
+  return useMutation(mutationOptions);
+};
+/**
+ * Deletes a Personal Unit. The Unit is *your* Unit, and belongs to the **Default Organisation**
+
+ * @summary Deletes a Personal Unit
+ */
+export type deletePersonalUnitResponse204 = { data: void; status: 204 };
+
+export type deletePersonalUnitResponse401 = { data: void; status: 401 };
+
+export type deletePersonalUnitResponse403 = { data: AsError; status: 403 };
+
+export type deletePersonalUnitResponse404 = { data: AsError; status: 404 };
+
+export type deletePersonalUnitResponseSuccess = deletePersonalUnitResponse204 & {
+  headers: Headers;
+};
+export type deletePersonalUnitResponseError = (
+  | deletePersonalUnitResponse401
+  | deletePersonalUnitResponse403
+  | deletePersonalUnitResponse404
+) & { headers: Headers };
+
+export type deletePersonalUnitResponse =
+  | deletePersonalUnitResponseSuccess
+  | deletePersonalUnitResponseError;
+
+export const getDeletePersonalUnitUrl = () => {
+  return `/personal-unit`;
+};
+
+export const deletePersonalUnit = async (
+  options?: RequestInit,
+): Promise<deletePersonalUnitResponse> => {
+  return customFetch<deletePersonalUnitResponse>(getDeletePersonalUnitUrl(), {
+    ...options,
+    method: "DELETE",
+  });
+};
+
+export const getDeletePersonalUnitMutationOptions = <
+  TError = ErrorType<void | AsError>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof deletePersonalUnit>>,
+    TError,
+    void,
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationOptions<Awaited<ReturnType<typeof deletePersonalUnit>>, TError, void, TContext> => {
+  const mutationKey = ["deletePersonalUnit"];
+  const { mutation: mutationOptions, request: requestOptions } = options
+    ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey
+      ? options
+      : { ...options, mutation: { ...options.mutation, mutationKey } }
+    : { mutation: { mutationKey }, request: undefined };
+
+  const mutationFn: MutationFunction<Awaited<ReturnType<typeof deletePersonalUnit>>, void> = () => {
+    return deletePersonalUnit(requestOptions);
+  };
+
+  return { mutationFn, ...mutationOptions };
+};
+
+export type DeletePersonalUnitMutationResult = NonNullable<
+  Awaited<ReturnType<typeof deletePersonalUnit>>
+>;
+
+export type DeletePersonalUnitMutationError = ErrorType<void | AsError>;
+
+/**
+ * @summary Deletes a Personal Unit
+ */
+export const useDeletePersonalUnit = <
+  TError = ErrorType<void | AsError>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof deletePersonalUnit>>,
+    TError,
+    void,
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationResult<Awaited<ReturnType<typeof deletePersonalUnit>>, TError, void, TContext> => {
+  const mutationOptions = getDeletePersonalUnitMutationOptions(options);
+
+  return useMutation(mutationOptions);
+};
+/**
+ * Gets all the Units that you are a member of, or a specific Unit by name.
+
+You can see a Unit if you are a member of it, the owner (creator) of it, or a member or creator of the Unit's Organisation, or if you are an admin user.
+
+ * @summary Gets Units
+ */
+export type getUnitsResponse200 = { data: UnitsGetResponse; status: 200 };
+
+export type getUnitsResponse401 = { data: void; status: 401 };
+
+export type getUnitsResponse403 = { data: AsError; status: 403 };
+
+export type getUnitsResponse404 = { data: AsError; status: 404 };
+
+export type getUnitsResponseSuccess = getUnitsResponse200 & { headers: Headers };
+export type getUnitsResponseError = (
+  | getUnitsResponse401
+  | getUnitsResponse403
+  | getUnitsResponse404
+) & { headers: Headers };
+
+export type getUnitsResponse = getUnitsResponseSuccess | getUnitsResponseError;
+
+export const getGetUnitsUrl = (params?: GetUnitsParams) => {
+  const normalizedParams = new URLSearchParams();
+
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+
+  const stringifiedParams = normalizedParams.toString();
+
+  return stringifiedParams.length > 0 ? `/unit?${stringifiedParams}` : `/unit`;
+};
+
+export const getUnits = async (
+  params?: GetUnitsParams,
+  options?: RequestInit,
+): Promise<getUnitsResponse> => {
+  return customFetch<getUnitsResponse>(getGetUnitsUrl(params), { ...options, method: "GET" });
+};
+
+export const getGetUnitsQueryKey = (params?: GetUnitsParams) => {
+  return ["account-server", "unit", ...(params ? [params] : [])] as const;
+};
+
+export const getGetUnitsQueryOptions = <
+  TData = Awaited<ReturnType<typeof getUnits>>,
+  TError = ErrorType<void | AsError>,
+>(
+  params?: GetUnitsParams,
+  options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getUnits>>, TError, TData>;
+    request?: SecondParameter<typeof customFetch>;
+  },
+) => {
+  const { query: queryOptions, request: requestOptions } = options ?? {};
+
+  const queryKey = queryOptions?.queryKey ?? getGetUnitsQueryKey(params);
+
+  const queryFn: QueryFunction<Awaited<ReturnType<typeof getUnits>>> = ({ signal }) =>
+    getUnits(params, { signal, ...requestOptions });
+
+  return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
+    Awaited<ReturnType<typeof getUnits>>,
+    TError,
+    TData
+  > & { queryKey: QueryKey };
+};
+
+export type GetUnitsQueryResult = NonNullable<Awaited<ReturnType<typeof getUnits>>>;
+export type GetUnitsQueryError = ErrorType<void | AsError>;
+
+/**
+ * @summary Gets Units
+ */
+
+export function useGetUnits<
+  TData = Awaited<ReturnType<typeof getUnits>>,
+  TError = ErrorType<void | AsError>,
+>(
+  params?: GetUnitsParams,
+  options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getUnits>>, TError, TData>;
+    request?: SecondParameter<typeof customFetch>;
+  },
+): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+  const queryOptions = getGetUnitsQueryOptions(params, options);
+
+  const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & { queryKey: QueryKey };
+
+  query.queryKey = queryOptions.queryKey;
+
+  return query;
+}
+
+/**
+ * @summary Gets Units
+ */
+export const invalidateGetUnits = async (
+  queryClient: QueryClient,
+  params?: GetUnitsParams,
+  options?: InvalidateOptions,
+): Promise<QueryClient> => {
+  await queryClient.invalidateQueries({ queryKey: getGetUnitsQueryKey(params) }, options);
+
+  return queryClient;
+};
+
+export const getGetUnitsSuspenseQueryOptions = <
+  TData = Awaited<ReturnType<typeof getUnits>>,
+  TError = ErrorType<void | AsError>,
+>(
+  params?: GetUnitsParams,
+  options?: {
+    query?: UseSuspenseQueryOptions<Awaited<ReturnType<typeof getUnits>>, TError, TData>;
+    request?: SecondParameter<typeof customFetch>;
+  },
+) => {
+  const { query: queryOptions, request: requestOptions } = options ?? {};
+
+  const queryKey = queryOptions?.queryKey ?? getGetUnitsQueryKey(params);
+
+  const queryFn: QueryFunction<Awaited<ReturnType<typeof getUnits>>> = ({ signal }) =>
+    getUnits(params, { signal, ...requestOptions });
+
+  return { queryKey, queryFn, ...queryOptions } as UseSuspenseQueryOptions<
+    Awaited<ReturnType<typeof getUnits>>,
+    TError,
+    TData
+  > & { queryKey: QueryKey };
+};
+
+export type GetUnitsSuspenseQueryResult = NonNullable<Awaited<ReturnType<typeof getUnits>>>;
+export type GetUnitsSuspenseQueryError = ErrorType<void | AsError>;
+
+/**
+ * @summary Gets Units
+ */
+
+export function useGetUnitsSuspense<
+  TData = Awaited<ReturnType<typeof getUnits>>,
+  TError = ErrorType<void | AsError>,
+>(
+  params?: GetUnitsParams,
+  options?: {
+    query?: UseSuspenseQueryOptions<Awaited<ReturnType<typeof getUnits>>, TError, TData>;
+    request?: SecondParameter<typeof customFetch>;
+  },
+): UseSuspenseQueryResult<TData, TError> & { queryKey: QueryKey } {
+  const queryOptions = getGetUnitsSuspenseQueryOptions(params, options);
+
+  const query = useSuspenseQuery(queryOptions) as UseSuspenseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+  };
+
+  query.queryKey = queryOptions.queryKey;
+
+  return query;
+}
+
+/**
+ * Creates a Personal Unit for a User. The unit will belong to the built-in **Default Organisation**.
+
+Users can only create one Personal unit and you cannot add other Users to a Personal Unit.
+
+This endpoint is DECREMENTED and will be removed in a future release. Please use **PUT** at `/personal-unit`.
+
+ * @summary Create a new Personal Unit
+ */
+export type createDefaultUnitResponse201 = { data: PersonalUnitPutResponse; status: 201 };
+
+export type createDefaultUnitResponse400 = { data: AsError; status: 400 };
+
+export type createDefaultUnitResponse401 = { data: void; status: 401 };
+
+export type createDefaultUnitResponse403 = { data: AsError; status: 403 };
+
+export type createDefaultUnitResponseSuccess = createDefaultUnitResponse201 & { headers: Headers };
+export type createDefaultUnitResponseError = (
+  | createDefaultUnitResponse400
+  | createDefaultUnitResponse401
+  | createDefaultUnitResponse403
+) & { headers: Headers };
+
+export type createDefaultUnitResponse =
+  | createDefaultUnitResponseSuccess
+  | createDefaultUnitResponseError;
+
+export const getCreateDefaultUnitUrl = () => {
+  return `/unit`;
+};
+
+export const createDefaultUnit = async (
+  personalUnitPutBodyBody: PersonalUnitPutBodyBody,
+  options?: RequestInit,
+): Promise<createDefaultUnitResponse> => {
+  return customFetch<createDefaultUnitResponse>(getCreateDefaultUnitUrl(), {
+    ...options,
+    method: "PUT",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(personalUnitPutBodyBody),
+  });
+};
+
+export const getCreateDefaultUnitMutationOptions = <
+  TError = ErrorType<AsError | void>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof createDefaultUnit>>,
+    TError,
+    { data: PersonalUnitPutBodyBody },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationOptions<
+  Awaited<ReturnType<typeof createDefaultUnit>>,
+  TError,
+  { data: PersonalUnitPutBodyBody },
+  TContext
+> => {
+  const mutationKey = ["createDefaultUnit"];
+  const { mutation: mutationOptions, request: requestOptions } = options
+    ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey
+      ? options
+      : { ...options, mutation: { ...options.mutation, mutationKey } }
+    : { mutation: { mutationKey }, request: undefined };
+
+  const mutationFn: MutationFunction<
+    Awaited<ReturnType<typeof createDefaultUnit>>,
+    { data: PersonalUnitPutBodyBody }
+  > = (props) => {
+    const { data } = props ?? {};
+
+    return createDefaultUnit(data, requestOptions);
+  };
+
+  return { mutationFn, ...mutationOptions };
+};
+
+export type CreateDefaultUnitMutationResult = NonNullable<
+  Awaited<ReturnType<typeof createDefaultUnit>>
+>;
+export type CreateDefaultUnitMutationBody = PersonalUnitPutBodyBody;
+export type CreateDefaultUnitMutationError = ErrorType<AsError | void>;
+
+/**
+ * @summary Create a new Personal Unit
+ */
+export const useCreateDefaultUnit = <
+  TError = ErrorType<AsError | void>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof createDefaultUnit>>,
+    TError,
+    { data: PersonalUnitPutBodyBody },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationResult<
+  Awaited<ReturnType<typeof createDefaultUnit>>,
+  TError,
+  { data: PersonalUnitPutBodyBody },
+  TContext
+> => {
+  const mutationOptions = getCreateDefaultUnitMutationOptions(options);
+
+  return useMutation(mutationOptions);
+};
+/**
+ * Deletes a Personal Unit. The Unit is *your* Unit, and belongs to the **Default Organisation**
+
+This endpoint is DECREMENTED and will be removed in a future release. Please use **DELETE** at `/personal-unit`.
+
+ * @summary Deletes a Personal Unit
+ */
+export type deleteDefaultUnitResponse204 = { data: void; status: 204 };
+
+export type deleteDefaultUnitResponse401 = { data: void; status: 401 };
+
+export type deleteDefaultUnitResponse403 = { data: AsError; status: 403 };
+
+export type deleteDefaultUnitResponse404 = { data: AsError; status: 404 };
+
+export type deleteDefaultUnitResponseSuccess = deleteDefaultUnitResponse204 & { headers: Headers };
+export type deleteDefaultUnitResponseError = (
+  | deleteDefaultUnitResponse401
+  | deleteDefaultUnitResponse403
+  | deleteDefaultUnitResponse404
+) & { headers: Headers };
+
+export type deleteDefaultUnitResponse =
+  | deleteDefaultUnitResponseSuccess
+  | deleteDefaultUnitResponseError;
+
+export const getDeleteDefaultUnitUrl = () => {
+  return `/unit`;
+};
+
+export const deleteDefaultUnit = async (
+  options?: RequestInit,
+): Promise<deleteDefaultUnitResponse> => {
+  return customFetch<deleteDefaultUnitResponse>(getDeleteDefaultUnitUrl(), {
+    ...options,
+    method: "DELETE",
+  });
+};
+
+export const getDeleteDefaultUnitMutationOptions = <
+  TError = ErrorType<void | AsError>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof deleteDefaultUnit>>,
+    TError,
+    void,
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationOptions<Awaited<ReturnType<typeof deleteDefaultUnit>>, TError, void, TContext> => {
+  const mutationKey = ["deleteDefaultUnit"];
+  const { mutation: mutationOptions, request: requestOptions } = options
+    ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey
+      ? options
+      : { ...options, mutation: { ...options.mutation, mutationKey } }
+    : { mutation: { mutationKey }, request: undefined };
+
+  const mutationFn: MutationFunction<Awaited<ReturnType<typeof deleteDefaultUnit>>, void> = () => {
+    return deleteDefaultUnit(requestOptions);
+  };
+
+  return { mutationFn, ...mutationOptions };
+};
+
+export type DeleteDefaultUnitMutationResult = NonNullable<
+  Awaited<ReturnType<typeof deleteDefaultUnit>>
+>;
+
+export type DeleteDefaultUnitMutationError = ErrorType<void | AsError>;
+
+/**
+ * @summary Deletes a Personal Unit
+ */
+export const useDeleteDefaultUnit = <
+  TError = ErrorType<void | AsError>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof deleteDefaultUnit>>,
+    TError,
+    void,
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationResult<Awaited<ReturnType<typeof deleteDefaultUnit>>, TError, void, TContext> => {
+  const mutationOptions = getDeleteDefaultUnitMutationOptions(options);
+
+  return useMutation(mutationOptions);
+};