@squonk/account-server-client 4.2.1 → 4.3.1

package/src/asset/asset.ts

@@ -1,24 +1,20 @@
-// @ts-nocheck
 /**
- * Generated by orval v7.4.1 🍺
+ * Generated by orval v7.10.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.2
+ * OpenAPI spec version: 4.3
  */
-import {
-  useMutation,
-  useQuery,
-  useSuspenseQuery
-} from '@tanstack/react-query'
+import { useMutation, useQuery, useSuspenseQuery } from "@tanstack/react-query";
 import type {
   DataTag,
   DefinedInitialDataOptions,
   DefinedUseQueryResult,
   MutationFunction,
+  QueryClient,
   QueryFunction,
   QueryKey,
   UndefinedInitialDataOptions,
@@ -27,8 +23,9 @@ import type {
   UseQueryOptions,
   UseQueryResult,
   UseSuspenseQueryOptions,
-  UseSuspenseQueryResult
-} from '@tanstack/react-query'
+  UseSuspenseQueryResult,
+} from "@tanstack/react-query";
+
 import type {
   AsError,
   AssetDetail,
@@ -38,14 +35,15 @@ import type {
   AssetPostResponse,
   AttachAssetParams,
   DetachAssetParams,
-  GetAssetParams
-} from '../account-server-api.schemas'
-import { customInstance } from '.././custom-instance';
-import type { ErrorType } from '.././custom-instance';
-
+  GetAssetParams,
+} from "../account-server-api.schemas";
 
-type SecondParameter<T extends (...args: any) => any> = Parameters<T>[1];
+import { customInstance } from ".././custom-instance";
+import type { ErrorType } from ".././custom-instance";
+import { queryMutator } from ".././options-mutator";
+import { mutationMutator } from ".././options-mutator";
 
+type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
 
 /**
  * Gets Assets you have access to.
@@ -53,144 +51,211 @@ type SecondParameter<T extends (...args: any) => any> = Parameters<T>[1];
  * @summary Gets Assets
  */
 export const getAsset = (
-    params?: GetAssetParams,
- options?: SecondParameter<typeof customInstance>,signal?: AbortSignal
+  params?: GetAssetParams,
+  options?: SecondParameter<typeof customInstance>,
+  signal?: AbortSignal,
 ) => {
-      
-      
-      return customInstance<AssetGetResponse>(
-      {url: `/asset`, method: 'GET',
-        params, signal
-    },
-      options);
-    }
-  
-
-export const getGetAssetQueryKey = (params?: GetAssetParams,) => {
-    return ["account-server-api", `/asset`, ...(params ? [params]: [])] as const;
-    }
-
-    
-export const getGetAssetQueryOptions = <TData = Awaited<ReturnType<typeof getAsset>>, TError = ErrorType<AsError | void>>(params?: GetAssetParams, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getAsset>>, TError, TData>>, request?: SecondParameter<typeof customInstance>}
+  return customInstance<AssetGetResponse>(
+    { url: `/asset`, method: "GET", params, signal },
+    options,
+  );
+};
+
+export const getGetAssetQueryKey = (params?: GetAssetParams) => {
+  return [`/asset`, ...(params ? [params] : [])] as const;
+};
+
+export const useGetAssetQueryOptions = <
+  TData = Awaited<ReturnType<typeof getAsset>>,
+  TError = ErrorType<AsError | void>,
+>(
+  params?: GetAssetParams,
+  options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getAsset>>, TError, TData>>;
+    request?: SecondParameter<typeof customInstance>;
+  },
 ) => {
+  const { query: queryOptions, request: requestOptions } = options ?? {};
 
-const {query: queryOptions, request: requestOptions} = options ?? {};
-
-  const queryKey =  queryOptions?.queryKey ?? getGetAssetQueryKey(params);
+  const queryKey = queryOptions?.queryKey ?? getGetAssetQueryKey(params);
 
-  
+  const queryFn: QueryFunction<Awaited<ReturnType<typeof getAsset>>> = ({ signal }) =>
+    getAsset(params, requestOptions, signal);
 
-    const queryFn: QueryFunction<Awaited<ReturnType<typeof getAsset>>> = ({ signal }) => getAsset(params, requestOptions, signal);
+  const customOptions = queryMutator({ ...queryOptions, queryKey, queryFn });
 
-      
+  return customOptions as UseQueryOptions<Awaited<ReturnType<typeof getAsset>>, TError, TData> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+  };
+};
 
-      
+export type GetAssetQueryResult = NonNullable<Awaited<ReturnType<typeof getAsset>>>;
+export type GetAssetQueryError = ErrorType<AsError | void>;
 
-   return  { queryKey, queryFn, ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof getAsset>>, TError, TData> & { queryKey: DataTag<QueryKey, TData, TError> }
-}
-
-export type GetAssetQueryResult = NonNullable<Awaited<ReturnType<typeof getAsset>>>
-export type GetAssetQueryError = ErrorType<AsError | void>
-
-
-export function useGetAsset<TData = Awaited<ReturnType<typeof getAsset>>, TError = ErrorType<AsError | void>>(
- params: undefined |  GetAssetParams, options: { query:Partial<UseQueryOptions<Awaited<ReturnType<typeof getAsset>>, TError, TData>> & Pick<
+export function useGetAsset<
+  TData = Awaited<ReturnType<typeof getAsset>>,
+  TError = ErrorType<AsError | void>,
+>(
+  params: undefined | GetAssetParams,
+  options: {
+    query: Partial<UseQueryOptions<Awaited<ReturnType<typeof getAsset>>, TError, TData>> &
+      Pick<
         DefinedInitialDataOptions<
           Awaited<ReturnType<typeof getAsset>>,
           TError,
-          TData
-        > , 'initialData'
-      >, request?: SecondParameter<typeof customInstance>}
-
-  ):  DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-export function useGetAsset<TData = Awaited<ReturnType<typeof getAsset>>, TError = ErrorType<AsError | void>>(
- params?: GetAssetParams, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getAsset>>, TError, TData>> & Pick<
+          Awaited<ReturnType<typeof getAsset>>
+        >,
+        "initialData"
+      >;
+    request?: SecondParameter<typeof customInstance>;
+  },
+  queryClient?: QueryClient,
+): DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> };
+export function useGetAsset<
+  TData = Awaited<ReturnType<typeof getAsset>>,
+  TError = ErrorType<AsError | void>,
+>(
+  params?: GetAssetParams,
+  options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getAsset>>, TError, TData>> &
+      Pick<
         UndefinedInitialDataOptions<
           Awaited<ReturnType<typeof getAsset>>,
           TError,
-          TData
-        > , 'initialData'
-      >, request?: SecondParameter<typeof customInstance>}
-
-  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-export function useGetAsset<TData = Awaited<ReturnType<typeof getAsset>>, TError = ErrorType<AsError | void>>(
- params?: GetAssetParams, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getAsset>>, TError, TData>>, request?: SecondParameter<typeof customInstance>}
-
-  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
+          Awaited<ReturnType<typeof getAsset>>
+        >,
+        "initialData"
+      >;
+    request?: SecondParameter<typeof customInstance>;
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> };
+export function useGetAsset<
+  TData = Awaited<ReturnType<typeof getAsset>>,
+  TError = ErrorType<AsError | void>,
+>(
+  params?: GetAssetParams,
+  options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getAsset>>, TError, TData>>;
+    request?: SecondParameter<typeof customInstance>;
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> };
 /**
  * @summary Gets Assets
  */
 
-export function useGetAsset<TData = Awaited<ReturnType<typeof getAsset>>, TError = ErrorType<AsError | void>>(
- params?: GetAssetParams, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getAsset>>, TError, TData>>, request?: SecondParameter<typeof customInstance>}
-
-  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {
-
-  const queryOptions = getGetAssetQueryOptions(params,options)
-
-  const query = useQuery(queryOptions) as  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> };
-
-  query.queryKey = queryOptions.queryKey ;
+export function useGetAsset<
+  TData = Awaited<ReturnType<typeof getAsset>>,
+  TError = ErrorType<AsError | void>,
+>(
+  params?: GetAssetParams,
+  options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getAsset>>, TError, TData>>;
+    request?: SecondParameter<typeof customInstance>;
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {
+  const queryOptions = useGetAssetQueryOptions(params, options);
+
+  const query = useQuery(queryOptions, queryClient) as UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+  };
+
+  query.queryKey = queryOptions.queryKey;
 
   return query;
 }
 
-
-
-export const getGetAssetSuspenseQueryOptions = <TData = Awaited<ReturnType<typeof getAsset>>, TError = ErrorType<AsError | void>>(params?: GetAssetParams, options?: { query?:Partial<UseSuspenseQueryOptions<Awaited<ReturnType<typeof getAsset>>, TError, TData>>, request?: SecondParameter<typeof customInstance>}
+export const useGetAssetSuspenseQueryOptions = <
+  TData = Awaited<ReturnType<typeof getAsset>>,
+  TError = ErrorType<AsError | void>,
+>(
+  params?: GetAssetParams,
+  options?: {
+    query?: Partial<UseSuspenseQueryOptions<Awaited<ReturnType<typeof getAsset>>, TError, TData>>;
+    request?: SecondParameter<typeof customInstance>;
+  },
 ) => {
-
-const {query: queryOptions, request: requestOptions} = options ?? {};
-
-  const queryKey =  queryOptions?.queryKey ?? getGetAssetQueryKey(params);
-
-  
-
-    const queryFn: QueryFunction<Awaited<ReturnType<typeof getAsset>>> = ({ signal }) => getAsset(params, requestOptions, signal);
-
-      
-
-      
-
-   return  { queryKey, queryFn, ...queryOptions} as UseSuspenseQueryOptions<Awaited<ReturnType<typeof getAsset>>, TError, TData> & { queryKey: DataTag<QueryKey, TData, TError> }
-}
-
-export type GetAssetSuspenseQueryResult = NonNullable<Awaited<ReturnType<typeof getAsset>>>
-export type GetAssetSuspenseQueryError = ErrorType<AsError | void>
-
-
-export function useGetAssetSuspense<TData = Awaited<ReturnType<typeof getAsset>>, TError = ErrorType<AsError | void>>(
- params: undefined |  GetAssetParams, options: { query:Partial<UseSuspenseQueryOptions<Awaited<ReturnType<typeof getAsset>>, TError, TData>>, request?: SecondParameter<typeof customInstance>}
-
-  ):  UseSuspenseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-export function useGetAssetSuspense<TData = Awaited<ReturnType<typeof getAsset>>, TError = ErrorType<AsError | void>>(
- params?: GetAssetParams, options?: { query?:Partial<UseSuspenseQueryOptions<Awaited<ReturnType<typeof getAsset>>, TError, TData>>, request?: SecondParameter<typeof customInstance>}
-
-  ):  UseSuspenseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-export function useGetAssetSuspense<TData = Awaited<ReturnType<typeof getAsset>>, TError = ErrorType<AsError | void>>(
- params?: GetAssetParams, options?: { query?:Partial<UseSuspenseQueryOptions<Awaited<ReturnType<typeof getAsset>>, TError, TData>>, request?: SecondParameter<typeof customInstance>}
-
-  ):  UseSuspenseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
+  const { query: queryOptions, request: requestOptions } = options ?? {};
+
+  const queryKey = queryOptions?.queryKey ?? getGetAssetQueryKey(params);
+
+  const queryFn: QueryFunction<Awaited<ReturnType<typeof getAsset>>> = ({ signal }) =>
+    getAsset(params, requestOptions, signal);
+
+  const customOptions = queryMutator({ ...queryOptions, queryKey, queryFn });
+
+  return customOptions as UseSuspenseQueryOptions<
+    Awaited<ReturnType<typeof getAsset>>,
+    TError,
+    TData
+  > & { queryKey: DataTag<QueryKey, TData, TError> };
+};
+
+export type GetAssetSuspenseQueryResult = NonNullable<Awaited<ReturnType<typeof getAsset>>>;
+export type GetAssetSuspenseQueryError = ErrorType<AsError | void>;
+
+export function useGetAssetSuspense<
+  TData = Awaited<ReturnType<typeof getAsset>>,
+  TError = ErrorType<AsError | void>,
+>(
+  params: undefined | GetAssetParams,
+  options: {
+    query: Partial<UseSuspenseQueryOptions<Awaited<ReturnType<typeof getAsset>>, TError, TData>>;
+    request?: SecondParameter<typeof customInstance>;
+  },
+  queryClient?: QueryClient,
+): UseSuspenseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> };
+export function useGetAssetSuspense<
+  TData = Awaited<ReturnType<typeof getAsset>>,
+  TError = ErrorType<AsError | void>,
+>(
+  params?: GetAssetParams,
+  options?: {
+    query?: Partial<UseSuspenseQueryOptions<Awaited<ReturnType<typeof getAsset>>, TError, TData>>;
+    request?: SecondParameter<typeof customInstance>;
+  },
+  queryClient?: QueryClient,
+): UseSuspenseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> };
+export function useGetAssetSuspense<
+  TData = Awaited<ReturnType<typeof getAsset>>,
+  TError = ErrorType<AsError | void>,
+>(
+  params?: GetAssetParams,
+  options?: {
+    query?: Partial<UseSuspenseQueryOptions<Awaited<ReturnType<typeof getAsset>>, TError, TData>>;
+    request?: SecondParameter<typeof customInstance>;
+  },
+  queryClient?: QueryClient,
+): UseSuspenseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> };
 /**
  * @summary Gets Assets
  */
 
-export function useGetAssetSuspense<TData = Awaited<ReturnType<typeof getAsset>>, TError = ErrorType<AsError | void>>(
- params?: GetAssetParams, options?: { query?:Partial<UseSuspenseQueryOptions<Awaited<ReturnType<typeof getAsset>>, TError, TData>>, request?: SecondParameter<typeof customInstance>}
-
-  ):  UseSuspenseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {
-
-  const queryOptions = getGetAssetSuspenseQueryOptions(params,options)
-
-  const query = useSuspenseQuery(queryOptions) as  UseSuspenseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> };
-
-  query.queryKey = queryOptions.queryKey ;
+export function useGetAssetSuspense<
+  TData = Awaited<ReturnType<typeof getAsset>>,
+  TError = ErrorType<AsError | void>,
+>(
+  params?: GetAssetParams,
+  options?: {
+    query?: Partial<UseSuspenseQueryOptions<Awaited<ReturnType<typeof getAsset>>, TError, TData>>;
+    request?: SecondParameter<typeof customInstance>;
+  },
+  queryClient?: QueryClient,
+): UseSuspenseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {
+  const queryOptions = useGetAssetSuspenseQueryOptions(params, options);
+
+  const query = useSuspenseQuery(queryOptions, queryClient) as UseSuspenseQueryResult<
+    TData,
+    TError
+  > & { queryKey: DataTag<QueryKey, TData, TError> };
+
+  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**
 
@@ -203,224 +268,327 @@ They must also be *attached* to a **Merchant** before the **Merchant** can ue th
  * @summary Create an Asset
  */
 export const createAsset = (
-    assetPostBodyBody: AssetPostBodyBody,
- options?: SecondParameter<typeof customInstance>,signal?: AbortSignal
+  assetPostBodyBody: AssetPostBodyBody,
+  options?: SecondParameter<typeof customInstance>,
+  signal?: AbortSignal,
 ) => {
-      
-      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 customInstance<AssetPostResponse>(
-      {url: `/asset`, method: 'POST',
-      headers: {'Content-Type': 'multipart/form-data', },
-       data: formData, signal
+  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 customInstance<AssetPostResponse>(
+    {
+      url: `/asset`,
+      method: "POST",
+      headers: { "Content-Type": "multipart/form-data" },
+      data: formData,
+      signal,
     },
-      options);
-    }
-  
-
-
-export const getCreateAssetMutationOptions = <TData = Awaited<ReturnType<typeof createAsset>>, TError = ErrorType<AsError | void>,
-    TContext = unknown>(options?: { mutation?:UseMutationOptions<TData, TError,{data: AssetPostBodyBody}, TContext>, request?: SecondParameter<typeof customInstance>}
-) => {
-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)
-        }
+    options,
+  );
+};
+
+export const useCreateAssetMutationOptions = <
+  TError = ErrorType<AsError | void>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof createAsset>>,
+    TError,
+    { data: AssetPostBodyBody },
+    TContext
+  >;
+  request?: SecondParameter<typeof customInstance>;
+}): 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);
+  };
+
+  const customOptions = mutationMutator({ ...mutationOptions, mutationFn });
+
+  return customOptions;
+};
+
+export type CreateAssetMutationResult = NonNullable<Awaited<ReturnType<typeof createAsset>>>;
+export type CreateAssetMutationBody = AssetPostBodyBody;
+export type CreateAssetMutationError = ErrorType<AsError | void>;
 
-        
-
-
-  return  { mutationFn, ...mutationOptions } as UseMutationOptions<TData, TError,{data: AssetPostBodyBody}, TContext>}
-
-    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 = <TData = Awaited<ReturnType<typeof createAsset>>, TError = ErrorType<AsError | void>,
-    TContext = unknown>(options?: { mutation?:UseMutationOptions<TData, TError,{data: AssetPostBodyBody}, TContext>, request?: SecondParameter<typeof customInstance>}
+export const useCreateAsset = <TError = ErrorType<AsError | void>, TContext = unknown>(
+  options?: {
+    mutation?: UseMutationOptions<
+      Awaited<ReturnType<typeof createAsset>>,
+      TError,
+      { data: AssetPostBodyBody },
+      TContext
+    >;
+    request?: SecondParameter<typeof customInstance>;
+  },
+  queryClient?: QueryClient,
 ): UseMutationResult<
-        TData,
-        TError,
-        {data: AssetPostBodyBody},
-        TContext
-      > => {
-
-      const mutationOptions = getCreateAssetMutationOptions(options);
-
-      return useMutation(mutationOptions);
-    }
-    /**
+  Awaited<ReturnType<typeof createAsset>>,
+  TError,
+  { data: AssetPostBodyBody },
+  TContext
+> => {
+  const mutationOptions = useCreateAssetMutationOptions(options);
+
+  return useMutation(mutationOptions, queryClient);
+};
+/**
  * Gets a known Asset
 
  * @summary Gets an Asset
  */
 export const getSpecificAsset = (
-    assetId: string,
- options?: SecondParameter<typeof customInstance>,signal?: AbortSignal
+  assetId: string,
+  options?: SecondParameter<typeof customInstance>,
+  signal?: AbortSignal,
 ) => {
-      
-      
-      return customInstance<AssetDetail>(
-      {url: `/asset/${assetId}`, method: 'GET', signal
-    },
-      options);
-    }
-  
-
-export const getGetSpecificAssetQueryKey = (assetId: string,) => {
-    return ["account-server-api", `/asset/${assetId}`] as const;
-    }
-
-    
-export const getGetSpecificAssetQueryOptions = <TData = Awaited<ReturnType<typeof getSpecificAsset>>, TError = ErrorType<AsError | void>>(assetId: string, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getSpecificAsset>>, TError, TData>>, request?: SecondParameter<typeof customInstance>}
+  return customInstance<AssetDetail>({ url: `/asset/${assetId}`, method: "GET", signal }, options);
+};
+
+export const getGetSpecificAssetQueryKey = (assetId: string) => {
+  return [`/asset/${assetId}`] as const;
+};
+
+export const useGetSpecificAssetQueryOptions = <
+  TData = Awaited<ReturnType<typeof getSpecificAsset>>,
+  TError = ErrorType<AsError | void>,
+>(
+  assetId: string,
+  options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getSpecificAsset>>, TError, TData>>;
+    request?: SecondParameter<typeof customInstance>;
+  },
 ) => {
+  const { query: queryOptions, request: requestOptions } = options ?? {};
 
-const {query: queryOptions, request: requestOptions} = options ?? {};
-
-  const queryKey =  queryOptions?.queryKey ?? getGetSpecificAssetQueryKey(assetId);
+  const queryKey = queryOptions?.queryKey ?? getGetSpecificAssetQueryKey(assetId);
 
-  
+  const queryFn: QueryFunction<Awaited<ReturnType<typeof getSpecificAsset>>> = ({ signal }) =>
+    getSpecificAsset(assetId, requestOptions, signal);
 
-    const queryFn: QueryFunction<Awaited<ReturnType<typeof getSpecificAsset>>> = ({ signal }) => getSpecificAsset(assetId, requestOptions, signal);
+  const customOptions = queryMutator({ ...queryOptions, queryKey, queryFn });
 
-      
+  return customOptions as UseQueryOptions<
+    Awaited<ReturnType<typeof getSpecificAsset>>,
+    TError,
+    TData
+  > & { queryKey: DataTag<QueryKey, TData, TError> };
+};
 
-      
+export type GetSpecificAssetQueryResult = NonNullable<Awaited<ReturnType<typeof getSpecificAsset>>>;
+export type GetSpecificAssetQueryError = ErrorType<AsError | void>;
 
-   return  { queryKey, queryFn, enabled: !!(assetId), ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof getSpecificAsset>>, TError, TData> & { queryKey: DataTag<QueryKey, TData, TError> }
-}
-
-export type GetSpecificAssetQueryResult = NonNullable<Awaited<ReturnType<typeof getSpecificAsset>>>
-export type GetSpecificAssetQueryError = ErrorType<AsError | void>
-
-
-export function useGetSpecificAsset<TData = Awaited<ReturnType<typeof getSpecificAsset>>, TError = ErrorType<AsError | void>>(
- assetId: string, options: { query:Partial<UseQueryOptions<Awaited<ReturnType<typeof getSpecificAsset>>, TError, TData>> & Pick<
+export function useGetSpecificAsset<
+  TData = Awaited<ReturnType<typeof getSpecificAsset>>,
+  TError = ErrorType<AsError | void>,
+>(
+  assetId: string,
+  options: {
+    query: Partial<UseQueryOptions<Awaited<ReturnType<typeof getSpecificAsset>>, TError, TData>> &
+      Pick<
         DefinedInitialDataOptions<
           Awaited<ReturnType<typeof getSpecificAsset>>,
           TError,
-          TData
-        > , 'initialData'
-      >, request?: SecondParameter<typeof customInstance>}
-
-  ):  DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-export function useGetSpecificAsset<TData = Awaited<ReturnType<typeof getSpecificAsset>>, TError = ErrorType<AsError | void>>(
- assetId: string, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getSpecificAsset>>, TError, TData>> & Pick<
+          Awaited<ReturnType<typeof getSpecificAsset>>
+        >,
+        "initialData"
+      >;
+    request?: SecondParameter<typeof customInstance>;
+  },
+  queryClient?: QueryClient,
+): DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> };
+export function useGetSpecificAsset<
+  TData = Awaited<ReturnType<typeof getSpecificAsset>>,
+  TError = ErrorType<AsError | void>,
+>(
+  assetId: string,
+  options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getSpecificAsset>>, TError, TData>> &
+      Pick<
         UndefinedInitialDataOptions<
           Awaited<ReturnType<typeof getSpecificAsset>>,
           TError,
-          TData
-        > , 'initialData'
-      >, request?: SecondParameter<typeof customInstance>}
-
-  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-export function useGetSpecificAsset<TData = Awaited<ReturnType<typeof getSpecificAsset>>, TError = ErrorType<AsError | void>>(
- assetId: string, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getSpecificAsset>>, TError, TData>>, request?: SecondParameter<typeof customInstance>}
-
-  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
+          Awaited<ReturnType<typeof getSpecificAsset>>
+        >,
+        "initialData"
+      >;
+    request?: SecondParameter<typeof customInstance>;
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> };
+export function useGetSpecificAsset<
+  TData = Awaited<ReturnType<typeof getSpecificAsset>>,
+  TError = ErrorType<AsError | void>,
+>(
+  assetId: string,
+  options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getSpecificAsset>>, TError, TData>>;
+    request?: SecondParameter<typeof customInstance>;
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> };
 /**
  * @summary Gets an Asset
  */
 
-export function useGetSpecificAsset<TData = Awaited<ReturnType<typeof getSpecificAsset>>, TError = ErrorType<AsError | void>>(
- assetId: string, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getSpecificAsset>>, TError, TData>>, request?: SecondParameter<typeof customInstance>}
-
-  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {
-
-  const queryOptions = getGetSpecificAssetQueryOptions(assetId,options)
-
-  const query = useQuery(queryOptions) as  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> };
-
-  query.queryKey = queryOptions.queryKey ;
+export function useGetSpecificAsset<
+  TData = Awaited<ReturnType<typeof getSpecificAsset>>,
+  TError = ErrorType<AsError | void>,
+>(
+  assetId: string,
+  options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getSpecificAsset>>, TError, TData>>;
+    request?: SecondParameter<typeof customInstance>;
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {
+  const queryOptions = useGetSpecificAssetQueryOptions(assetId, options);
+
+  const query = useQuery(queryOptions, queryClient) as UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+  };
+
+  query.queryKey = queryOptions.queryKey;
 
   return query;
 }
 
-
-
-export const getGetSpecificAssetSuspenseQueryOptions = <TData = Awaited<ReturnType<typeof getSpecificAsset>>, TError = ErrorType<AsError | void>>(assetId: string, options?: { query?:Partial<UseSuspenseQueryOptions<Awaited<ReturnType<typeof getSpecificAsset>>, TError, TData>>, request?: SecondParameter<typeof customInstance>}
+export const useGetSpecificAssetSuspenseQueryOptions = <
+  TData = Awaited<ReturnType<typeof getSpecificAsset>>,
+  TError = ErrorType<AsError | void>,
+>(
+  assetId: string,
+  options?: {
+    query?: Partial<
+      UseSuspenseQueryOptions<Awaited<ReturnType<typeof getSpecificAsset>>, TError, TData>
+    >;
+    request?: SecondParameter<typeof customInstance>;
+  },
 ) => {
-
-const {query: queryOptions, request: requestOptions} = options ?? {};
-
-  const queryKey =  queryOptions?.queryKey ?? getGetSpecificAssetQueryKey(assetId);
-
-  
-
-    const queryFn: QueryFunction<Awaited<ReturnType<typeof getSpecificAsset>>> = ({ signal }) => getSpecificAsset(assetId, requestOptions, signal);
-
-      
-
-      
-
-   return  { queryKey, queryFn, ...queryOptions} as UseSuspenseQueryOptions<Awaited<ReturnType<typeof getSpecificAsset>>, TError, TData> & { queryKey: DataTag<QueryKey, TData, TError> }
-}
-
-export type GetSpecificAssetSuspenseQueryResult = NonNullable<Awaited<ReturnType<typeof getSpecificAsset>>>
-export type GetSpecificAssetSuspenseQueryError = ErrorType<AsError | void>
-
-
-export function useGetSpecificAssetSuspense<TData = Awaited<ReturnType<typeof getSpecificAsset>>, TError = ErrorType<AsError | void>>(
- assetId: string, options: { query:Partial<UseSuspenseQueryOptions<Awaited<ReturnType<typeof getSpecificAsset>>, TError, TData>>, request?: SecondParameter<typeof customInstance>}
-
-  ):  UseSuspenseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-export function useGetSpecificAssetSuspense<TData = Awaited<ReturnType<typeof getSpecificAsset>>, TError = ErrorType<AsError | void>>(
- assetId: string, options?: { query?:Partial<UseSuspenseQueryOptions<Awaited<ReturnType<typeof getSpecificAsset>>, TError, TData>>, request?: SecondParameter<typeof customInstance>}
-
-  ):  UseSuspenseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-export function useGetSpecificAssetSuspense<TData = Awaited<ReturnType<typeof getSpecificAsset>>, TError = ErrorType<AsError | void>>(
- assetId: string, options?: { query?:Partial<UseSuspenseQueryOptions<Awaited<ReturnType<typeof getSpecificAsset>>, TError, TData>>, request?: SecondParameter<typeof customInstance>}
-
-  ):  UseSuspenseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
+  const { query: queryOptions, request: requestOptions } = options ?? {};
+
+  const queryKey = queryOptions?.queryKey ?? getGetSpecificAssetQueryKey(assetId);
+
+  const queryFn: QueryFunction<Awaited<ReturnType<typeof getSpecificAsset>>> = ({ signal }) =>
+    getSpecificAsset(assetId, requestOptions, signal);
+
+  const customOptions = queryMutator({ ...queryOptions, queryKey, queryFn });
+
+  return customOptions as UseSuspenseQueryOptions<
+    Awaited<ReturnType<typeof getSpecificAsset>>,
+    TError,
+    TData
+  > & { queryKey: DataTag<QueryKey, TData, TError> };
+};
+
+export type GetSpecificAssetSuspenseQueryResult = NonNullable<
+  Awaited<ReturnType<typeof getSpecificAsset>>
+>;
+export type GetSpecificAssetSuspenseQueryError = ErrorType<AsError | void>;
+
+export function useGetSpecificAssetSuspense<
+  TData = Awaited<ReturnType<typeof getSpecificAsset>>,
+  TError = ErrorType<AsError | void>,
+>(
+  assetId: string,
+  options: {
+    query: Partial<
+      UseSuspenseQueryOptions<Awaited<ReturnType<typeof getSpecificAsset>>, TError, TData>
+    >;
+    request?: SecondParameter<typeof customInstance>;
+  },
+  queryClient?: QueryClient,
+): UseSuspenseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> };
+export function useGetSpecificAssetSuspense<
+  TData = Awaited<ReturnType<typeof getSpecificAsset>>,
+  TError = ErrorType<AsError | void>,
+>(
+  assetId: string,
+  options?: {
+    query?: Partial<
+      UseSuspenseQueryOptions<Awaited<ReturnType<typeof getSpecificAsset>>, TError, TData>
+    >;
+    request?: SecondParameter<typeof customInstance>;
+  },
+  queryClient?: QueryClient,
+): UseSuspenseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> };
+export function useGetSpecificAssetSuspense<
+  TData = Awaited<ReturnType<typeof getSpecificAsset>>,
+  TError = ErrorType<AsError | void>,
+>(
+  assetId: string,
+  options?: {
+    query?: Partial<
+      UseSuspenseQueryOptions<Awaited<ReturnType<typeof getSpecificAsset>>, TError, TData>
+    >;
+    request?: SecondParameter<typeof customInstance>;
+  },
+  queryClient?: QueryClient,
+): UseSuspenseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> };
 /**
  * @summary Gets an Asset
  */
 
-export function useGetSpecificAssetSuspense<TData = Awaited<ReturnType<typeof getSpecificAsset>>, TError = ErrorType<AsError | void>>(
- assetId: string, options?: { query?:Partial<UseSuspenseQueryOptions<Awaited<ReturnType<typeof getSpecificAsset>>, TError, TData>>, request?: SecondParameter<typeof customInstance>}
-
-  ):  UseSuspenseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {
-
-  const queryOptions = getGetSpecificAssetSuspenseQueryOptions(assetId,options)
-
-  const query = useSuspenseQuery(queryOptions) as  UseSuspenseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> };
-
-  query.queryKey = queryOptions.queryKey ;
+export function useGetSpecificAssetSuspense<
+  TData = Awaited<ReturnType<typeof getSpecificAsset>>,
+  TError = ErrorType<AsError | void>,
+>(
+  assetId: string,
+  options?: {
+    query?: Partial<
+      UseSuspenseQueryOptions<Awaited<ReturnType<typeof getSpecificAsset>>, TError, TData>
+    >;
+    request?: SecondParameter<typeof customInstance>;
+  },
+  queryClient?: QueryClient,
+): UseSuspenseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {
+  const queryOptions = useGetSpecificAssetSuspenseQueryOptions(assetId, options);
+
+  const query = useSuspenseQuery(queryOptions, queryClient) as UseSuspenseQueryResult<
+    TData,
+    TError
+  > & { queryKey: DataTag<QueryKey, TData, TError> };
+
+  query.queryKey = queryOptions.queryKey;
 
   return query;
 }
 
-
-
 /**
  * Used to update or replace Asset *Content* or *Description*.
 
@@ -431,268 +599,330 @@ Anyone can alter a `GLOBAL` asset. For other *scopes* you will need to be the us
  * @summary Adjust an existing Asset
  */
 export const patchAsset = (
-    assetId: string,
-    assetPatchBodyBody: AssetPatchBodyBody,
- options?: SecondParameter<typeof customInstance>,) => {
-      
-      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 customInstance<void>(
-      {url: `/asset/${assetId}`, method: 'PATCH',
-      headers: {'Content-Type': 'multipart/form-data', },
-       data: formData
-    },
-      options);
-    }
-  
-
-
-export const getPatchAssetMutationOptions = <TData = Awaited<ReturnType<typeof patchAsset>>, TError = ErrorType<void | AsError>,
-    TContext = unknown>(options?: { mutation?:UseMutationOptions<TData, TError,{assetId: string;data: AssetPatchBodyBody}, TContext>, request?: SecondParameter<typeof customInstance>}
+  assetId: string,
+  assetPatchBodyBody: AssetPatchBodyBody,
+  options?: SecondParameter<typeof customInstance>,
 ) => {
-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 } as UseMutationOptions<TData, TError,{assetId: string;data: AssetPatchBodyBody}, TContext>}
-
-    export type PatchAssetMutationResult = NonNullable<Awaited<ReturnType<typeof patchAsset>>>
-    export type PatchAssetMutationBody = AssetPatchBodyBody
-    export type PatchAssetMutationError = ErrorType<void | AsError>
+  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 customInstance<void>(
+    {
+      url: `/asset/${assetId}`,
+      method: "PATCH",
+      headers: { "Content-Type": "multipart/form-data" },
+      data: formData,
+    },
+    options,
+  );
+};
+
+export const usePatchAssetMutationOptions = <
+  TError = ErrorType<void | AsError>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof patchAsset>>,
+    TError,
+    { assetId: string; data: AssetPatchBodyBody },
+    TContext
+  >;
+  request?: SecondParameter<typeof customInstance>;
+}): 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);
+  };
+
+  const customOptions = mutationMutator({ ...mutationOptions, mutationFn });
+
+  return customOptions;
+};
+
+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 = <TData = Awaited<ReturnType<typeof patchAsset>>, TError = ErrorType<void | AsError>,
-    TContext = unknown>(options?: { mutation?:UseMutationOptions<TData, TError,{assetId: string;data: AssetPatchBodyBody}, TContext>, request?: SecondParameter<typeof customInstance>}
+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 customInstance>;
+  },
+  queryClient?: QueryClient,
 ): UseMutationResult<
-        TData,
-        TError,
-        {assetId: string;data: AssetPatchBodyBody},
-        TContext
-      > => {
-
-      const mutationOptions = getPatchAssetMutationOptions(options);
-
-      return useMutation(mutationOptions);
-    }
-    /**
+  Awaited<ReturnType<typeof patchAsset>>,
+  TError,
+  { assetId: string; data: AssetPatchBodyBody },
+  TContext
+> => {
+  const mutationOptions = usePatchAssetMutationOptions(options);
+
+  return useMutation(mutationOptions, queryClient);
+};
+/**
  * 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 const deleteAsset = (
-    assetId: string,
- options?: SecondParameter<typeof customInstance>,) => {
-      
-      
-      return customInstance<void>(
-      {url: `/asset/${assetId}`, method: 'DELETE'
-    },
-      options);
-    }
-  
-
-
-export const getDeleteAssetMutationOptions = <TData = Awaited<ReturnType<typeof deleteAsset>>, TError = ErrorType<AsError | void>,
-    TContext = unknown>(options?: { mutation?:UseMutationOptions<TData, TError,{assetId: string}, TContext>, request?: SecondParameter<typeof customInstance>}
-) => {
-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)
-        }
+export const deleteAsset = (assetId: string, options?: SecondParameter<typeof customInstance>) => {
+  return customInstance<void>({ url: `/asset/${assetId}`, method: "DELETE" }, options);
+};
+
+export const useDeleteAssetMutationOptions = <
+  TError = ErrorType<AsError | void>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof deleteAsset>>,
+    TError,
+    { assetId: string },
+    TContext
+  >;
+  request?: SecondParameter<typeof customInstance>;
+}): 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);
+  };
+
+  const customOptions = mutationMutator({ ...mutationOptions, mutationFn });
+
+  return customOptions;
+};
+
+export type DeleteAssetMutationResult = NonNullable<Awaited<ReturnType<typeof deleteAsset>>>;
+
+export type DeleteAssetMutationError = ErrorType<AsError | void>;
 
-        
-
-
-  return  { mutationFn, ...mutationOptions } as UseMutationOptions<TData, TError,{assetId: string}, TContext>}
-
-    export type DeleteAssetMutationResult = NonNullable<Awaited<ReturnType<typeof deleteAsset>>>
-    
-    export type DeleteAssetMutationError = ErrorType<AsError | void>
-
-    /**
+/**
  * @summary Deletes an Asset
  */
-export const useDeleteAsset = <TData = Awaited<ReturnType<typeof deleteAsset>>, TError = ErrorType<AsError | void>,
-    TContext = unknown>(options?: { mutation?:UseMutationOptions<TData, TError,{assetId: string}, TContext>, request?: SecondParameter<typeof customInstance>}
+export const useDeleteAsset = <TError = ErrorType<AsError | void>, TContext = unknown>(
+  options?: {
+    mutation?: UseMutationOptions<
+      Awaited<ReturnType<typeof deleteAsset>>,
+      TError,
+      { assetId: string },
+      TContext
+    >;
+    request?: SecondParameter<typeof customInstance>;
+  },
+  queryClient?: QueryClient,
 ): UseMutationResult<
-        TData,
-        TError,
-        {assetId: string},
-        TContext
-      > => {
-
-      const mutationOptions = getDeleteAssetMutationOptions(options);
-
-      return useMutation(mutationOptions);
-    }
-    /**
+  Awaited<ReturnType<typeof deleteAsset>>,
+  TError,
+  { assetId: string },
+  TContext
+> => {
+  const mutationOptions = useDeleteAssetMutationOptions(options);
+
+  return useMutation(mutationOptions, queryClient);
+};
+/**
  * 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 const disableAsset = (
-    assetId: string,
- options?: SecondParameter<typeof customInstance>,) => {
-      
-      
-      return customInstance<void>(
-      {url: `/asset/${assetId}/disable`, method: 'PATCH'
-    },
-      options);
-    }
-  
-
-
-export const getDisableAssetMutationOptions = <TData = Awaited<ReturnType<typeof disableAsset>>, TError = ErrorType<AsError | void>,
-    TContext = unknown>(options?: { mutation?:UseMutationOptions<TData, TError,{assetId: string}, TContext>, request?: SecondParameter<typeof customInstance>}
-) => {
-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};
+export const disableAsset = (assetId: string, options?: SecondParameter<typeof customInstance>) => {
+  return customInstance<void>({ url: `/asset/${assetId}/disable`, method: "PATCH" }, options);
+};
+
+export const useDisableAssetMutationOptions = <
+  TError = ErrorType<AsError | void>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof disableAsset>>,
+    TError,
+    { assetId: string },
+    TContext
+  >;
+  request?: SecondParameter<typeof customInstance>;
+}): 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);
+  };
+
+  const customOptions = mutationMutator({ ...mutationOptions, mutationFn });
+
+  return customOptions;
+};
+
+export type DisableAssetMutationResult = NonNullable<Awaited<ReturnType<typeof disableAsset>>>;
+
+export type DisableAssetMutationError = ErrorType<AsError | void>;
 
-      
-
-
-      const mutationFn: MutationFunction<Awaited<ReturnType<typeof disableAsset>>, {assetId: string}> = (props) => {
-          const {assetId} = props ?? {};
-
-          return  disableAsset(assetId,requestOptions)
-        }
-
-        
-
-
-  return  { mutationFn, ...mutationOptions } as UseMutationOptions<TData, TError,{assetId: string}, TContext>}
-
-    export type DisableAssetMutationResult = NonNullable<Awaited<ReturnType<typeof disableAsset>>>
-    
-    export type DisableAssetMutationError = ErrorType<AsError | void>
-
-    /**
+/**
  * @summary Disables an Asset
  */
-export const useDisableAsset = <TData = Awaited<ReturnType<typeof disableAsset>>, TError = ErrorType<AsError | void>,
-    TContext = unknown>(options?: { mutation?:UseMutationOptions<TData, TError,{assetId: string}, TContext>, request?: SecondParameter<typeof customInstance>}
+export const useDisableAsset = <TError = ErrorType<AsError | void>, TContext = unknown>(
+  options?: {
+    mutation?: UseMutationOptions<
+      Awaited<ReturnType<typeof disableAsset>>,
+      TError,
+      { assetId: string },
+      TContext
+    >;
+    request?: SecondParameter<typeof customInstance>;
+  },
+  queryClient?: QueryClient,
 ): UseMutationResult<
-        TData,
-        TError,
-        {assetId: string},
-        TContext
-      > => {
-
-      const mutationOptions = getDisableAssetMutationOptions(options);
-
-      return useMutation(mutationOptions);
-    }
-    /**
+  Awaited<ReturnType<typeof disableAsset>>,
+  TError,
+  { assetId: string },
+  TContext
+> => {
+  const mutationOptions = useDisableAssetMutationOptions(options);
+
+  return useMutation(mutationOptions, queryClient);
+};
+/**
  * 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 const enableAsset = (
-    assetId: string,
- options?: SecondParameter<typeof customInstance>,) => {
-      
-      
-      return customInstance<void>(
-      {url: `/asset/${assetId}/enable`, method: 'PATCH'
-    },
-      options);
-    }
-  
-
-
-export const getEnableAssetMutationOptions = <TData = Awaited<ReturnType<typeof enableAsset>>, TError = ErrorType<AsError | void>,
-    TContext = unknown>(options?: { mutation?:UseMutationOptions<TData, TError,{assetId: string}, TContext>, request?: SecondParameter<typeof customInstance>}
-) => {
-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 } as UseMutationOptions<TData, TError,{assetId: string}, TContext>}
+export const enableAsset = (assetId: string, options?: SecondParameter<typeof customInstance>) => {
+  return customInstance<void>({ url: `/asset/${assetId}/enable`, method: "PATCH" }, options);
+};
+
+export const useEnableAssetMutationOptions = <
+  TError = ErrorType<AsError | void>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof enableAsset>>,
+    TError,
+    { assetId: string },
+    TContext
+  >;
+  request?: SecondParameter<typeof customInstance>;
+}): 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);
+  };
+
+  const customOptions = mutationMutator({ ...mutationOptions, mutationFn });
+
+  return customOptions;
+};
+
+export type EnableAssetMutationResult = NonNullable<Awaited<ReturnType<typeof enableAsset>>>;
+
+export type EnableAssetMutationError = ErrorType<AsError | void>;
 
-    export type EnableAssetMutationResult = NonNullable<Awaited<ReturnType<typeof enableAsset>>>
-    
-    export type EnableAssetMutationError = ErrorType<AsError | void>
-
-    /**
+/**
  * @summary Enables an Asset
  */
-export const useEnableAsset = <TData = Awaited<ReturnType<typeof enableAsset>>, TError = ErrorType<AsError | void>,
-    TContext = unknown>(options?: { mutation?:UseMutationOptions<TData, TError,{assetId: string}, TContext>, request?: SecondParameter<typeof customInstance>}
+export const useEnableAsset = <TError = ErrorType<AsError | void>, TContext = unknown>(
+  options?: {
+    mutation?: UseMutationOptions<
+      Awaited<ReturnType<typeof enableAsset>>,
+      TError,
+      { assetId: string },
+      TContext
+    >;
+    request?: SecondParameter<typeof customInstance>;
+  },
+  queryClient?: QueryClient,
 ): UseMutationResult<
-        TData,
-        TError,
-        {assetId: string},
-        TContext
-      > => {
-
-      const mutationOptions = getEnableAssetMutationOptions(options);
-
-      return useMutation(mutationOptions);
-    }
-    /**
+  Awaited<ReturnType<typeof enableAsset>>,
+  TError,
+  { assetId: string },
+  TContext
+> => {
+  const mutationOptions = useEnableAssetMutationOptions(options);
+
+  return useMutation(mutationOptions, queryClient);
+};
+/**
  * 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.
@@ -700,65 +930,83 @@ Anyone can alter a `GLOBAL` asset. For other *scopes* you will need to be the us
  * @summary Attaches an Asset to a Merchant
  */
 export const attachAsset = (
-    assetId: string,
-    params?: AttachAssetParams,
- options?: SecondParameter<typeof customInstance>,) => {
-      
-      
-      return customInstance<void>(
-      {url: `/asset/${assetId}/attach`, method: 'PATCH',
-        params
-    },
-      options);
-    }
-  
-
-
-export const getAttachAssetMutationOptions = <TData = Awaited<ReturnType<typeof attachAsset>>, TError = ErrorType<AsError | void>,
-    TContext = unknown>(options?: { mutation?:UseMutationOptions<TData, TError,{assetId: string;params?: AttachAssetParams}, TContext>, request?: SecondParameter<typeof customInstance>}
+  assetId: string,
+  params?: AttachAssetParams,
+  options?: SecondParameter<typeof customInstance>,
 ) => {
-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 customInstance<void>(
+    { url: `/asset/${assetId}/attach`, method: "PATCH", params },
+    options,
+  );
+};
+
+export const useAttachAssetMutationOptions = <
+  TError = ErrorType<AsError | void>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof attachAsset>>,
+    TError,
+    { assetId: string; params?: AttachAssetParams },
+    TContext
+  >;
+  request?: SecondParameter<typeof customInstance>;
+}): 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);
+  };
+
+  const customOptions = mutationMutator({ ...mutationOptions, mutationFn });
+
+  return customOptions;
+};
+
+export type AttachAssetMutationResult = NonNullable<Awaited<ReturnType<typeof attachAsset>>>;
+
+export type AttachAssetMutationError = ErrorType<AsError | void>;
 
-          return  attachAsset(assetId,params,requestOptions)
-        }
-
-        
-
-
-  return  { mutationFn, ...mutationOptions } as UseMutationOptions<TData, TError,{assetId: string;params?: AttachAssetParams}, TContext>}
-
-    export type AttachAssetMutationResult = NonNullable<Awaited<ReturnType<typeof attachAsset>>>
-    
-    export type AttachAssetMutationError = ErrorType<AsError | void>
-
-    /**
+/**
  * @summary Attaches an Asset to a Merchant
  */
-export const useAttachAsset = <TData = Awaited<ReturnType<typeof attachAsset>>, TError = ErrorType<AsError | void>,
-    TContext = unknown>(options?: { mutation?:UseMutationOptions<TData, TError,{assetId: string;params?: AttachAssetParams}, TContext>, request?: SecondParameter<typeof customInstance>}
+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 customInstance>;
+  },
+  queryClient?: QueryClient,
 ): UseMutationResult<
-        TData,
-        TError,
-        {assetId: string;params?: AttachAssetParams},
-        TContext
-      > => {
-
-      const mutationOptions = getAttachAssetMutationOptions(options);
-
-      return useMutation(mutationOptions);
-    }
-    /**
+  Awaited<ReturnType<typeof attachAsset>>,
+  TError,
+  { assetId: string; params?: AttachAssetParams },
+  TContext
+> => {
+  const mutationOptions = useAttachAssetMutationOptions(options);
+
+  return useMutation(mutationOptions, queryClient);
+};
+/**
  * 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.
@@ -766,62 +1014,79 @@ Anyone can alter a `GLOBAL` asset. For other *scopes* you will need to be the us
  * @summary Detaches an Asset from a Merchant
  */
 export const detachAsset = (
-    assetId: string,
-    params?: DetachAssetParams,
- options?: SecondParameter<typeof customInstance>,) => {
-      
-      
-      return customInstance<void>(
-      {url: `/asset/${assetId}/detach`, method: 'PATCH',
-        params
-    },
-      options);
-    }
-  
-
-
-export const getDetachAssetMutationOptions = <TData = Awaited<ReturnType<typeof detachAsset>>, TError = ErrorType<AsError | void>,
-    TContext = unknown>(options?: { mutation?:UseMutationOptions<TData, TError,{assetId: string;params?: DetachAssetParams}, TContext>, request?: SecondParameter<typeof customInstance>}
+  assetId: string,
+  params?: DetachAssetParams,
+  options?: SecondParameter<typeof customInstance>,
 ) => {
-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};
+  return customInstance<void>(
+    { url: `/asset/${assetId}/detach`, method: "PATCH", params },
+    options,
+  );
+};
+
+export const useDetachAssetMutationOptions = <
+  TError = ErrorType<AsError | void>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof detachAsset>>,
+    TError,
+    { assetId: string; params?: DetachAssetParams },
+    TContext
+  >;
+  request?: SecondParameter<typeof customInstance>;
+}): 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);
+  };
+
+  const customOptions = mutationMutator({ ...mutationOptions, mutationFn });
+
+  return customOptions;
+};
+
+export type DetachAssetMutationResult = NonNullable<Awaited<ReturnType<typeof detachAsset>>>;
+
+export type DetachAssetMutationError = ErrorType<AsError | void>;
 
-      
-
-
-      const mutationFn: MutationFunction<Awaited<ReturnType<typeof detachAsset>>, {assetId: string;params?: DetachAssetParams}> = (props) => {
-          const {assetId,params} = props ?? {};
-
-          return  detachAsset(assetId,params,requestOptions)
-        }
-
-        
-
-
-  return  { mutationFn, ...mutationOptions } as UseMutationOptions<TData, TError,{assetId: string;params?: DetachAssetParams}, TContext>}
-
-    export type DetachAssetMutationResult = NonNullable<Awaited<ReturnType<typeof detachAsset>>>
-    
-    export type DetachAssetMutationError = ErrorType<AsError | void>
-
-    /**
+/**
  * @summary Detaches an Asset from a Merchant
  */
-export const useDetachAsset = <TData = Awaited<ReturnType<typeof detachAsset>>, TError = ErrorType<AsError | void>,
-    TContext = unknown>(options?: { mutation?:UseMutationOptions<TData, TError,{assetId: string;params?: DetachAssetParams}, TContext>, request?: SecondParameter<typeof customInstance>}
+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 customInstance>;
+  },
+  queryClient?: QueryClient,
 ): UseMutationResult<
-        TData,
-        TError,
-        {assetId: string;params?: DetachAssetParams},
-        TContext
-      > => {
-
-      const mutationOptions = getDetachAssetMutationOptions(options);
-
-      return useMutation(mutationOptions);
-    }
-    
+  Awaited<ReturnType<typeof detachAsset>>,
+  TError,
+  { assetId: string; params?: DetachAssetParams },
+  TContext
+> => {
+  const mutationOptions = useDetachAssetMutationOptions(options);
+
+  return useMutation(mutationOptions, queryClient);
+};