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

package/src/api/asset/asset.fetch.ts

@@ -0,0 +1,1119 @@
+/**
+ * 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,
+  AssetDetail,
+  AssetGetResponse,
+  AssetPatchBodyBody,
+  AssetPostBodyBody,
+  AssetPostResponse,
+  AttachAssetParams,
+  DetachAssetParams,
+  GetAssetParams,
+} 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 Assets you have access to.
+
+ * @summary Gets Assets
+ */
+export type getAssetResponse201 = { data: AssetGetResponse; status: 201 };
+
+export type getAssetResponse400 = { data: AsError; status: 400 };
+
+export type getAssetResponse401 = { data: void; status: 401 };
+
+export type getAssetResponse403 = { data: AsError; status: 403 };
+
+export type getAssetResponseSuccess = getAssetResponse201 & { headers: Headers };
+export type getAssetResponseError = (
+  | getAssetResponse400
+  | getAssetResponse401
+  | getAssetResponse403
+) & { headers: Headers };
+
+export type getAssetResponse = getAssetResponseSuccess | getAssetResponseError;
+
+export const getGetAssetUrl = (params?: GetAssetParams) => {
+  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 ? `/asset?${stringifiedParams}` : `/asset`;
+};
+
+export const getAsset = async (
+  params?: GetAssetParams,
+  options?: RequestInit,
+): Promise<getAssetResponse> => {
+  return customFetch<getAssetResponse>(getGetAssetUrl(params), { ...options, method: "GET" });
+};
+
+export const getGetAssetQueryKey = (params?: GetAssetParams) => {
+  return ["account-server", "asset", ...(params ? [params] : [])] as const;
+};
+
+export const getGetAssetQueryOptions = <
+  TData = Awaited<ReturnType<typeof getAsset>>,
+  TError = ErrorType<AsError | void>,
+>(
+  params?: GetAssetParams,
+  options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getAsset>>, TError, TData>;
+    request?: SecondParameter<typeof customFetch>;
+  },
+) => {
+  const { query: queryOptions, request: requestOptions } = options ?? {};
+
+  const queryKey = queryOptions?.queryKey ?? getGetAssetQueryKey(params);
+
+  const queryFn: QueryFunction<Awaited<ReturnType<typeof getAsset>>> = ({ signal }) =>
+    getAsset(params, { signal, ...requestOptions });
+
+  return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
+    Awaited<ReturnType<typeof getAsset>>,
+    TError,
+    TData
+  > & { queryKey: QueryKey };
+};
+
+export type GetAssetQueryResult = NonNullable<Awaited<ReturnType<typeof getAsset>>>;
+export type GetAssetQueryError = ErrorType<AsError | void>;
+
+/**
+ * @summary Gets Assets
+ */
+
+export function useGetAsset<
+  TData = Awaited<ReturnType<typeof getAsset>>,
+  TError = ErrorType<AsError | void>,
+>(
+  params?: GetAssetParams,
+  options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getAsset>>, TError, TData>;
+    request?: SecondParameter<typeof customFetch>;
+  },
+): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+  const queryOptions = getGetAssetQueryOptions(params, options);
+
+  const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & { queryKey: QueryKey };
+
+  query.queryKey = queryOptions.queryKey;
+
+  return query;
+}
+
+/**
+ * @summary Gets Assets
+ */
+export const invalidateGetAsset = async (
+  queryClient: QueryClient,
+  params?: GetAssetParams,
+  options?: InvalidateOptions,
+): Promise<QueryClient> => {
+  await queryClient.invalidateQueries({ queryKey: getGetAssetQueryKey(params) }, options);
+
+  return queryClient;
+};
+
+export const getGetAssetSuspenseQueryOptions = <
+  TData = Awaited<ReturnType<typeof getAsset>>,
+  TError = ErrorType<AsError | void>,
+>(
+  params?: GetAssetParams,
+  options?: {
+    query?: UseSuspenseQueryOptions<Awaited<ReturnType<typeof getAsset>>, TError, TData>;
+    request?: SecondParameter<typeof customFetch>;
+  },
+) => {
+  const { query: queryOptions, request: requestOptions } = options ?? {};
+
+  const queryKey = queryOptions?.queryKey ?? getGetAssetQueryKey(params);
+
+  const queryFn: QueryFunction<Awaited<ReturnType<typeof getAsset>>> = ({ signal }) =>
+    getAsset(params, { signal, ...requestOptions });
+
+  return { queryKey, queryFn, ...queryOptions } as UseSuspenseQueryOptions<
+    Awaited<ReturnType<typeof getAsset>>,
+    TError,
+    TData
+  > & { queryKey: QueryKey };
+};
+
+export type GetAssetSuspenseQueryResult = NonNullable<Awaited<ReturnType<typeof getAsset>>>;
+export type GetAssetSuspenseQueryError = ErrorType<AsError | void>;
+
+/**
+ * @summary Gets Assets
+ */
+
+export function useGetAssetSuspense<
+  TData = Awaited<ReturnType<typeof getAsset>>,
+  TError = ErrorType<AsError | void>,
+>(
+  params?: GetAssetParams,
+  options?: {
+    query?: UseSuspenseQueryOptions<Awaited<ReturnType<typeof getAsset>>, TError, TData>;
+    request?: SecondParameter<typeof customFetch>;
+  },
+): UseSuspenseQueryResult<TData, TError> & { queryKey: QueryKey } {
+  const queryOptions = getGetAssetSuspenseQueryOptions(params, options);
+
+  const query = useSuspenseQuery(queryOptions) as UseSuspenseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+  };
+
+  query.queryKey = queryOptions.queryKey;
+
+  return query;
+}
+
+/**
+ * Creates an Asset, which can be attached to a **User** account, a **Product**, **Unit**, **Organisation** or can be made **Global**
+
+Assets are text and file resources that can be requested by **Merchants**. The Data Manager **Merchant** uses assets to provide additional information that's often sensitive to **Job** (and **Application**) **Instances**.
+
+Assets must be *enabled* before they can be used.
+
+They must also be *attached* to a **Merchant** before the **Merchant** can ue them. Assets are only available to merchants if they are enabled and attached.
+
+ * @summary Create an Asset
+ */
+export type createAssetResponse201 = { data: AssetPostResponse; status: 201 };
+
+export type createAssetResponse400 = { data: AsError; status: 400 };
+
+export type createAssetResponse401 = { data: void; status: 401 };
+
+export type createAssetResponse403 = { data: AsError; status: 403 };
+
+export type createAssetResponseSuccess = createAssetResponse201 & { headers: Headers };
+export type createAssetResponseError = (
+  | createAssetResponse400
+  | createAssetResponse401
+  | createAssetResponse403
+) & { headers: Headers };
+
+export type createAssetResponse = createAssetResponseSuccess | createAssetResponseError;
+
+export const getCreateAssetUrl = () => {
+  return `/asset`;
+};
+
+export const createAsset = async (
+  assetPostBodyBody: AssetPostBodyBody,
+  options?: RequestInit,
+): Promise<createAssetResponse> => {
+  const formData = new FormData();
+  formData.append(`name`, assetPostBodyBody.name);
+  if (assetPostBodyBody.content_file !== undefined) {
+    formData.append(`content_file`, assetPostBodyBody.content_file);
+  }
+  if (assetPostBodyBody.content_string !== undefined) {
+    formData.append(`content_string`, assetPostBodyBody.content_string);
+  }
+  formData.append(`scope`, assetPostBodyBody.scope);
+  if (assetPostBodyBody.scope_id !== undefined) {
+    formData.append(`scope_id`, assetPostBodyBody.scope_id);
+  }
+  formData.append(`secret`, assetPostBodyBody.secret.toString());
+  if (assetPostBodyBody.description !== undefined) {
+    formData.append(`description`, assetPostBodyBody.description);
+  }
+
+  return customFetch<createAssetResponse>(getCreateAssetUrl(), {
+    ...options,
+    method: "POST",
+    body: formData,
+  });
+};
+
+export const getCreateAssetMutationOptions = <
+  TError = ErrorType<AsError | void>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof createAsset>>,
+    TError,
+    { data: AssetPostBodyBody },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationOptions<
+  Awaited<ReturnType<typeof createAsset>>,
+  TError,
+  { data: AssetPostBodyBody },
+  TContext
+> => {
+  const mutationKey = ["createAsset"];
+  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 createAsset>>,
+    { data: AssetPostBodyBody }
+  > = (props) => {
+    const { data } = props ?? {};
+
+    return createAsset(data, requestOptions);
+  };
+
+  return { mutationFn, ...mutationOptions };
+};
+
+export type CreateAssetMutationResult = NonNullable<Awaited<ReturnType<typeof createAsset>>>;
+export type CreateAssetMutationBody = AssetPostBodyBody;
+export type CreateAssetMutationError = ErrorType<AsError | void>;
+
+/**
+ * @summary Create an Asset
+ */
+export const useCreateAsset = <TError = ErrorType<AsError | void>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof createAsset>>,
+    TError,
+    { data: AssetPostBodyBody },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationResult<
+  Awaited<ReturnType<typeof createAsset>>,
+  TError,
+  { data: AssetPostBodyBody },
+  TContext
+> => {
+  const mutationOptions = getCreateAssetMutationOptions(options);
+
+  return useMutation(mutationOptions);
+};
+/**
+ * Gets a known Asset
+
+ * @summary Gets an Asset
+ */
+export type getSpecificAssetResponse201 = { data: AssetDetail; status: 201 };
+
+export type getSpecificAssetResponse400 = { data: AsError; status: 400 };
+
+export type getSpecificAssetResponse401 = { data: void; status: 401 };
+
+export type getSpecificAssetResponse403 = { data: AsError; status: 403 };
+
+export type getSpecificAssetResponseSuccess = getSpecificAssetResponse201 & { headers: Headers };
+export type getSpecificAssetResponseError = (
+  | getSpecificAssetResponse400
+  | getSpecificAssetResponse401
+  | getSpecificAssetResponse403
+) & { headers: Headers };
+
+export type getSpecificAssetResponse =
+  | getSpecificAssetResponseSuccess
+  | getSpecificAssetResponseError;
+
+export const getGetSpecificAssetUrl = (assetId: string) => {
+  return `/asset/${assetId}`;
+};
+
+export const getSpecificAsset = async (
+  assetId: string,
+  options?: RequestInit,
+): Promise<getSpecificAssetResponse> => {
+  return customFetch<getSpecificAssetResponse>(getGetSpecificAssetUrl(assetId), {
+    ...options,
+    method: "GET",
+  });
+};
+
+export const getGetSpecificAssetQueryKey = (assetId?: string) => {
+  return ["account-server", "asset", assetId] as const;
+};
+
+export const getGetSpecificAssetQueryOptions = <
+  TData = Awaited<ReturnType<typeof getSpecificAsset>>,
+  TError = ErrorType<AsError | void>,
+>(
+  assetId: string,
+  options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getSpecificAsset>>, TError, TData>;
+    request?: SecondParameter<typeof customFetch>;
+  },
+) => {
+  const { query: queryOptions, request: requestOptions } = options ?? {};
+
+  const queryKey = queryOptions?.queryKey ?? getGetSpecificAssetQueryKey(assetId);
+
+  const queryFn: QueryFunction<Awaited<ReturnType<typeof getSpecificAsset>>> = ({ signal }) =>
+    getSpecificAsset(assetId, { signal, ...requestOptions });
+
+  return { queryKey, queryFn, enabled: !!assetId, ...queryOptions } as UseQueryOptions<
+    Awaited<ReturnType<typeof getSpecificAsset>>,
+    TError,
+    TData
+  > & { queryKey: QueryKey };
+};
+
+export type GetSpecificAssetQueryResult = NonNullable<Awaited<ReturnType<typeof getSpecificAsset>>>;
+export type GetSpecificAssetQueryError = ErrorType<AsError | void>;
+
+/**
+ * @summary Gets an Asset
+ */
+
+export function useGetSpecificAsset<
+  TData = Awaited<ReturnType<typeof getSpecificAsset>>,
+  TError = ErrorType<AsError | void>,
+>(
+  assetId: string,
+  options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getSpecificAsset>>, TError, TData>;
+    request?: SecondParameter<typeof customFetch>;
+  },
+): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+  const queryOptions = getGetSpecificAssetQueryOptions(assetId, options);
+
+  const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & { queryKey: QueryKey };
+
+  query.queryKey = queryOptions.queryKey;
+
+  return query;
+}
+
+/**
+ * @summary Gets an Asset
+ */
+export const invalidateGetSpecificAsset = async (
+  queryClient: QueryClient,
+  assetId: string,
+  options?: InvalidateOptions,
+): Promise<QueryClient> => {
+  await queryClient.invalidateQueries({ queryKey: getGetSpecificAssetQueryKey(assetId) }, options);
+
+  return queryClient;
+};
+
+export const getGetSpecificAssetSuspenseQueryOptions = <
+  TData = Awaited<ReturnType<typeof getSpecificAsset>>,
+  TError = ErrorType<AsError | void>,
+>(
+  assetId: string,
+  options?: {
+    query?: UseSuspenseQueryOptions<Awaited<ReturnType<typeof getSpecificAsset>>, TError, TData>;
+    request?: SecondParameter<typeof customFetch>;
+  },
+) => {
+  const { query: queryOptions, request: requestOptions } = options ?? {};
+
+  const queryKey = queryOptions?.queryKey ?? getGetSpecificAssetQueryKey(assetId);
+
+  const queryFn: QueryFunction<Awaited<ReturnType<typeof getSpecificAsset>>> = ({ signal }) =>
+    getSpecificAsset(assetId, { signal, ...requestOptions });
+
+  return { queryKey, queryFn, ...queryOptions } as UseSuspenseQueryOptions<
+    Awaited<ReturnType<typeof getSpecificAsset>>,
+    TError,
+    TData
+  > & { queryKey: QueryKey };
+};
+
+export type GetSpecificAssetSuspenseQueryResult = NonNullable<
+  Awaited<ReturnType<typeof getSpecificAsset>>
+>;
+export type GetSpecificAssetSuspenseQueryError = ErrorType<AsError | void>;
+
+/**
+ * @summary Gets an Asset
+ */
+
+export function useGetSpecificAssetSuspense<
+  TData = Awaited<ReturnType<typeof getSpecificAsset>>,
+  TError = ErrorType<AsError | void>,
+>(
+  assetId: string,
+  options?: {
+    query?: UseSuspenseQueryOptions<Awaited<ReturnType<typeof getSpecificAsset>>, TError, TData>;
+    request?: SecondParameter<typeof customFetch>;
+  },
+): UseSuspenseQueryResult<TData, TError> & { queryKey: QueryKey } {
+  const queryOptions = getGetSpecificAssetSuspenseQueryOptions(assetId, options);
+
+  const query = useSuspenseQuery(queryOptions) as UseSuspenseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+  };
+
+  query.queryKey = queryOptions.queryKey;
+
+  return query;
+}
+
+/**
+ * Used to update or replace Asset *Content* or *Description*.
+
+The content of an Asset currently in use will not be affected by a change made here. If a **Merchant** has already obtained the Asset it may continue to use the original value until the **Merchant** requests the **Asset** again.
+
+Anyone can alter a `GLOBAL` asset. For other *scopes* you will need to be the user for `USER` scoped assets, a member of the **Unit** for `UNIT` and `PRODUCT` scoped assets, or a member of the **Organisation** for `ORGANISATION` scoped assets. Administrators can patch any asset.
+
+ * @summary Adjust an existing Asset
+ */
+export type patchAssetResponse200 = { data: void; status: 200 };
+
+export type patchAssetResponse401 = { data: void; status: 401 };
+
+export type patchAssetResponse403 = { data: AsError; status: 403 };
+
+export type patchAssetResponse404 = { data: AsError; status: 404 };
+
+export type patchAssetResponseSuccess = patchAssetResponse200 & { headers: Headers };
+export type patchAssetResponseError = (
+  | patchAssetResponse401
+  | patchAssetResponse403
+  | patchAssetResponse404
+) & { headers: Headers };
+
+export type patchAssetResponse = patchAssetResponseSuccess | patchAssetResponseError;
+
+export const getPatchAssetUrl = (assetId: string) => {
+  return `/asset/${assetId}`;
+};
+
+export const patchAsset = async (
+  assetId: string,
+  assetPatchBodyBody: AssetPatchBodyBody,
+  options?: RequestInit,
+): Promise<patchAssetResponse> => {
+  const formData = new FormData();
+  if (assetPatchBodyBody.content_file !== undefined) {
+    formData.append(`content_file`, assetPatchBodyBody.content_file);
+  }
+  if (assetPatchBodyBody.content_string !== undefined) {
+    formData.append(`content_string`, assetPatchBodyBody.content_string);
+  }
+  if (assetPatchBodyBody.description !== undefined) {
+    formData.append(`description`, assetPatchBodyBody.description);
+  }
+
+  return customFetch<patchAssetResponse>(getPatchAssetUrl(assetId), {
+    ...options,
+    method: "PATCH",
+    body: formData,
+  });
+};
+
+export const getPatchAssetMutationOptions = <
+  TError = ErrorType<void | AsError>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof patchAsset>>,
+    TError,
+    { assetId: string; data: AssetPatchBodyBody },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationOptions<
+  Awaited<ReturnType<typeof patchAsset>>,
+  TError,
+  { assetId: string; data: AssetPatchBodyBody },
+  TContext
+> => {
+  const mutationKey = ["patchAsset"];
+  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 patchAsset>>,
+    { assetId: string; data: AssetPatchBodyBody }
+  > = (props) => {
+    const { assetId, data } = props ?? {};
+
+    return patchAsset(assetId, data, requestOptions);
+  };
+
+  return { mutationFn, ...mutationOptions };
+};
+
+export type PatchAssetMutationResult = NonNullable<Awaited<ReturnType<typeof patchAsset>>>;
+export type PatchAssetMutationBody = AssetPatchBodyBody;
+export type PatchAssetMutationError = ErrorType<void | AsError>;
+
+/**
+ * @summary Adjust an existing Asset
+ */
+export const usePatchAsset = <TError = ErrorType<void | AsError>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof patchAsset>>,
+    TError,
+    { assetId: string; data: AssetPatchBodyBody },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationResult<
+  Awaited<ReturnType<typeof patchAsset>>,
+  TError,
+  { assetId: string; data: AssetPatchBodyBody },
+  TContext
+> => {
+  const mutationOptions = getPatchAssetMutationOptions(options);
+
+  return useMutation(mutationOptions);
+};
+/**
+ * Deletes a known Asset. Assets that are attached to **Merchants** cannot be deleted
+
+Anyone can alter a `GLOBAL` asset. For other *scopes* you will need to be the user for `USER` scoped assets, a member of the **Unit** for `UNIT` and `PRODUCT` scoped assets, or a member of the **Organisation** for `ORGANISATION` scoped assets. Administrators can patch any asset.
+
+ * @summary Deletes an Asset
+ */
+export type deleteAssetResponse204 = { data: void; status: 204 };
+
+export type deleteAssetResponse400 = { data: AsError; status: 400 };
+
+export type deleteAssetResponse401 = { data: void; status: 401 };
+
+export type deleteAssetResponse403 = { data: AsError; status: 403 };
+
+export type deleteAssetResponseSuccess = deleteAssetResponse204 & { headers: Headers };
+export type deleteAssetResponseError = (
+  | deleteAssetResponse400
+  | deleteAssetResponse401
+  | deleteAssetResponse403
+) & { headers: Headers };
+
+export type deleteAssetResponse = deleteAssetResponseSuccess | deleteAssetResponseError;
+
+export const getDeleteAssetUrl = (assetId: string) => {
+  return `/asset/${assetId}`;
+};
+
+export const deleteAsset = async (
+  assetId: string,
+  options?: RequestInit,
+): Promise<deleteAssetResponse> => {
+  return customFetch<deleteAssetResponse>(getDeleteAssetUrl(assetId), {
+    ...options,
+    method: "DELETE",
+  });
+};
+
+export const getDeleteAssetMutationOptions = <
+  TError = ErrorType<AsError | void>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof deleteAsset>>,
+    TError,
+    { assetId: string },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationOptions<
+  Awaited<ReturnType<typeof deleteAsset>>,
+  TError,
+  { assetId: string },
+  TContext
+> => {
+  const mutationKey = ["deleteAsset"];
+  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 deleteAsset>>,
+    { assetId: string }
+  > = (props) => {
+    const { assetId } = props ?? {};
+
+    return deleteAsset(assetId, requestOptions);
+  };
+
+  return { mutationFn, ...mutationOptions };
+};
+
+export type DeleteAssetMutationResult = NonNullable<Awaited<ReturnType<typeof deleteAsset>>>;
+
+export type DeleteAssetMutationError = ErrorType<AsError | void>;
+
+/**
+ * @summary Deletes an Asset
+ */
+export const useDeleteAsset = <TError = ErrorType<AsError | void>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof deleteAsset>>,
+    TError,
+    { assetId: string },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationResult<
+  Awaited<ReturnType<typeof deleteAsset>>,
+  TError,
+  { assetId: string },
+  TContext
+> => {
+  const mutationOptions = getDeleteAssetMutationOptions(options);
+
+  return useMutation(mutationOptions);
+};
+/**
+ * Disables a known Asset
+
+Anyone can alter a `GLOBAL` asset. For other *scopes* you will need to be the user for `USER` scoped assets, a member of the **Unit** for `UNIT` and `PRODUCT` scoped assets, or a member of the **Organisation** for `ORGANISATION` scoped assets. Administrators can patch any asset.
+
+ * @summary Disables an Asset
+ */
+export type disableAssetResponse204 = { data: void; status: 204 };
+
+export type disableAssetResponse400 = { data: AsError; status: 400 };
+
+export type disableAssetResponse401 = { data: void; status: 401 };
+
+export type disableAssetResponse403 = { data: AsError; status: 403 };
+
+export type disableAssetResponseSuccess = disableAssetResponse204 & { headers: Headers };
+export type disableAssetResponseError = (
+  | disableAssetResponse400
+  | disableAssetResponse401
+  | disableAssetResponse403
+) & { headers: Headers };
+
+export type disableAssetResponse = disableAssetResponseSuccess | disableAssetResponseError;
+
+export const getDisableAssetUrl = (assetId: string) => {
+  return `/asset/${assetId}/disable`;
+};
+
+export const disableAsset = async (
+  assetId: string,
+  options?: RequestInit,
+): Promise<disableAssetResponse> => {
+  return customFetch<disableAssetResponse>(getDisableAssetUrl(assetId), {
+    ...options,
+    method: "PATCH",
+  });
+};
+
+export const getDisableAssetMutationOptions = <
+  TError = ErrorType<AsError | void>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof disableAsset>>,
+    TError,
+    { assetId: string },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationOptions<
+  Awaited<ReturnType<typeof disableAsset>>,
+  TError,
+  { assetId: string },
+  TContext
+> => {
+  const mutationKey = ["disableAsset"];
+  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 disableAsset>>,
+    { assetId: string }
+  > = (props) => {
+    const { assetId } = props ?? {};
+
+    return disableAsset(assetId, requestOptions);
+  };
+
+  return { mutationFn, ...mutationOptions };
+};
+
+export type DisableAssetMutationResult = NonNullable<Awaited<ReturnType<typeof disableAsset>>>;
+
+export type DisableAssetMutationError = ErrorType<AsError | void>;
+
+/**
+ * @summary Disables an Asset
+ */
+export const useDisableAsset = <TError = ErrorType<AsError | void>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof disableAsset>>,
+    TError,
+    { assetId: string },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationResult<
+  Awaited<ReturnType<typeof disableAsset>>,
+  TError,
+  { assetId: string },
+  TContext
+> => {
+  const mutationOptions = getDisableAssetMutationOptions(options);
+
+  return useMutation(mutationOptions);
+};
+/**
+ * Enables a known Asset
+
+Anyone can alter a `GLOBAL` asset. For other *scopes* you will need to be the user for `USER` scoped assets, a member of the **Unit** for `UNIT` and `PRODUCT` scoped assets, or a member of the **Organisation** for `ORGANISATION` scoped assets. Administrators can patch any asset.
+
+ * @summary Enables an Asset
+ */
+export type enableAssetResponse204 = { data: void; status: 204 };
+
+export type enableAssetResponse400 = { data: AsError; status: 400 };
+
+export type enableAssetResponse401 = { data: void; status: 401 };
+
+export type enableAssetResponse403 = { data: AsError; status: 403 };
+
+export type enableAssetResponseSuccess = enableAssetResponse204 & { headers: Headers };
+export type enableAssetResponseError = (
+  | enableAssetResponse400
+  | enableAssetResponse401
+  | enableAssetResponse403
+) & { headers: Headers };
+
+export type enableAssetResponse = enableAssetResponseSuccess | enableAssetResponseError;
+
+export const getEnableAssetUrl = (assetId: string) => {
+  return `/asset/${assetId}/enable`;
+};
+
+export const enableAsset = async (
+  assetId: string,
+  options?: RequestInit,
+): Promise<enableAssetResponse> => {
+  return customFetch<enableAssetResponse>(getEnableAssetUrl(assetId), {
+    ...options,
+    method: "PATCH",
+  });
+};
+
+export const getEnableAssetMutationOptions = <
+  TError = ErrorType<AsError | void>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof enableAsset>>,
+    TError,
+    { assetId: string },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationOptions<
+  Awaited<ReturnType<typeof enableAsset>>,
+  TError,
+  { assetId: string },
+  TContext
+> => {
+  const mutationKey = ["enableAsset"];
+  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 enableAsset>>,
+    { assetId: string }
+  > = (props) => {
+    const { assetId } = props ?? {};
+
+    return enableAsset(assetId, requestOptions);
+  };
+
+  return { mutationFn, ...mutationOptions };
+};
+
+export type EnableAssetMutationResult = NonNullable<Awaited<ReturnType<typeof enableAsset>>>;
+
+export type EnableAssetMutationError = ErrorType<AsError | void>;
+
+/**
+ * @summary Enables an Asset
+ */
+export const useEnableAsset = <TError = ErrorType<AsError | void>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof enableAsset>>,
+    TError,
+    { assetId: string },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationResult<
+  Awaited<ReturnType<typeof enableAsset>>,
+  TError,
+  { assetId: string },
+  TContext
+> => {
+  const mutationOptions = getEnableAssetMutationOptions(options);
+
+  return useMutation(mutationOptions);
+};
+/**
+ * Attaches an Asset to a **Merchant**. This allows the **Merchant** to query the Asset. **Merchants** cannot obtain Assets that are not attached to them.
+
+Anyone can alter a `GLOBAL` asset. For other *scopes* you will need to be the user for `USER` scoped assets, a member of the **Unit** for `UNIT` and `PRODUCT` scoped assets, or a member of the **Organisation** for `ORGANISATION` scoped assets. Administrators can patch any asset.
+
+ * @summary Attaches an Asset to a Merchant
+ */
+export type attachAssetResponse204 = { data: void; status: 204 };
+
+export type attachAssetResponse400 = { data: AsError; status: 400 };
+
+export type attachAssetResponse401 = { data: void; status: 401 };
+
+export type attachAssetResponse403 = { data: AsError; status: 403 };
+
+export type attachAssetResponseSuccess = attachAssetResponse204 & { headers: Headers };
+export type attachAssetResponseError = (
+  | attachAssetResponse400
+  | attachAssetResponse401
+  | attachAssetResponse403
+) & { headers: Headers };
+
+export type attachAssetResponse = attachAssetResponseSuccess | attachAssetResponseError;
+
+export const getAttachAssetUrl = (assetId: string, params?: AttachAssetParams) => {
+  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
+    ? `/asset/${assetId}/attach?${stringifiedParams}`
+    : `/asset/${assetId}/attach`;
+};
+
+export const attachAsset = async (
+  assetId: string,
+  params?: AttachAssetParams,
+  options?: RequestInit,
+): Promise<attachAssetResponse> => {
+  return customFetch<attachAssetResponse>(getAttachAssetUrl(assetId, params), {
+    ...options,
+    method: "PATCH",
+  });
+};
+
+export const getAttachAssetMutationOptions = <
+  TError = ErrorType<AsError | void>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof attachAsset>>,
+    TError,
+    { assetId: string; params?: AttachAssetParams },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationOptions<
+  Awaited<ReturnType<typeof attachAsset>>,
+  TError,
+  { assetId: string; params?: AttachAssetParams },
+  TContext
+> => {
+  const mutationKey = ["attachAsset"];
+  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 attachAsset>>,
+    { assetId: string; params?: AttachAssetParams }
+  > = (props) => {
+    const { assetId, params } = props ?? {};
+
+    return attachAsset(assetId, params, requestOptions);
+  };
+
+  return { mutationFn, ...mutationOptions };
+};
+
+export type AttachAssetMutationResult = NonNullable<Awaited<ReturnType<typeof attachAsset>>>;
+
+export type AttachAssetMutationError = ErrorType<AsError | void>;
+
+/**
+ * @summary Attaches an Asset to a Merchant
+ */
+export const useAttachAsset = <TError = ErrorType<AsError | void>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof attachAsset>>,
+    TError,
+    { assetId: string; params?: AttachAssetParams },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationResult<
+  Awaited<ReturnType<typeof attachAsset>>,
+  TError,
+  { assetId: string; params?: AttachAssetParams },
+  TContext
+> => {
+  const mutationOptions = getAttachAssetMutationOptions(options);
+
+  return useMutation(mutationOptions);
+};
+/**
+ * Detaches an Asset from a **Merchant**
+
+Anyone can alter a `GLOBAL` asset. For other *scopes* you will need to be the user for `USER` scoped assets, a member of the **Unit** for `UNIT` and `PRODUCT` scoped assets, or a member of the **Organisation** for `ORGANISATION` scoped assets. Administrators can patch any asset.
+
+ * @summary Detaches an Asset from a Merchant
+ */
+export type detachAssetResponse204 = { data: void; status: 204 };
+
+export type detachAssetResponse400 = { data: AsError; status: 400 };
+
+export type detachAssetResponse401 = { data: void; status: 401 };
+
+export type detachAssetResponse403 = { data: AsError; status: 403 };
+
+export type detachAssetResponseSuccess = detachAssetResponse204 & { headers: Headers };
+export type detachAssetResponseError = (
+  | detachAssetResponse400
+  | detachAssetResponse401
+  | detachAssetResponse403
+) & { headers: Headers };
+
+export type detachAssetResponse = detachAssetResponseSuccess | detachAssetResponseError;
+
+export const getDetachAssetUrl = (assetId: string, params?: DetachAssetParams) => {
+  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
+    ? `/asset/${assetId}/detach?${stringifiedParams}`
+    : `/asset/${assetId}/detach`;
+};
+
+export const detachAsset = async (
+  assetId: string,
+  params?: DetachAssetParams,
+  options?: RequestInit,
+): Promise<detachAssetResponse> => {
+  return customFetch<detachAssetResponse>(getDetachAssetUrl(assetId, params), {
+    ...options,
+    method: "PATCH",
+  });
+};
+
+export const getDetachAssetMutationOptions = <
+  TError = ErrorType<AsError | void>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof detachAsset>>,
+    TError,
+    { assetId: string; params?: DetachAssetParams },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationOptions<
+  Awaited<ReturnType<typeof detachAsset>>,
+  TError,
+  { assetId: string; params?: DetachAssetParams },
+  TContext
+> => {
+  const mutationKey = ["detachAsset"];
+  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 detachAsset>>,
+    { assetId: string; params?: DetachAssetParams }
+  > = (props) => {
+    const { assetId, params } = props ?? {};
+
+    return detachAsset(assetId, params, requestOptions);
+  };
+
+  return { mutationFn, ...mutationOptions };
+};
+
+export type DetachAssetMutationResult = NonNullable<Awaited<ReturnType<typeof detachAsset>>>;
+
+export type DetachAssetMutationError = ErrorType<AsError | void>;
+
+/**
+ * @summary Detaches an Asset from a Merchant
+ */
+export const useDetachAsset = <TError = ErrorType<AsError | void>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof detachAsset>>,
+    TError,
+    { assetId: string; params?: DetachAssetParams },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationResult<
+  Awaited<ReturnType<typeof detachAsset>>,
+  TError,
+  { assetId: string; params?: DetachAssetParams },
+  TContext
+> => {
+  const mutationOptions = getDetachAssetMutationOptions(options);
+
+  return useMutation(mutationOptions);
+};