@squonk/account-server-client 1.0.2-rc.3 → 1.0.3-rc.1

package/src/asset/asset.ts

@@ -8,15 +8,18 @@ A service that provides access to the Account Server, which gives *registered* u
 
  * OpenAPI spec version: 1.0
  */
-import { useQuery, useMutation } from "react-query";
+import {
+  useQuery,
+  useMutation
+} from 'react-query'
 import type {
   UseQueryOptions,
   UseMutationOptions,
   QueryFunction,
   MutationFunction,
   UseQueryResult,
-  QueryKey,
-} from "react-query";
+  QueryKey
+} from 'react-query'
 import type {
   AssetGetResponse,
   AsError,
@@ -24,15 +27,16 @@ import type {
   AssetPostResponse,
   AssetPostBodyBody,
   AttachAssetParams,
-  DetachAssetParams,
-} from "../account-server-api.schemas";
-import { customInstance } from ".././custom-instance";
-import type { ErrorType } from ".././custom-instance";
+  DetachAssetParams
+} from '../account-server-api.schemas'
+import { customInstance } from '.././custom-instance'
+import type { ErrorType } from '.././custom-instance'
+
 
 // eslint-disable-next-line
-type SecondParameter<T extends (...args: any) => any> = T extends (
+  type SecondParameter<T extends (...args: any) => any> = T extends (
   config: any,
-  args: infer P
+  args: infer P,
 ) => any
   ? P
   : never;
@@ -43,58 +47,42 @@ type SecondParameter<T extends (...args: any) => any> = T extends (
  * @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) => [
-  `/asset`,
-  ...(params ? [params] : []),
-];
-
-export type GetAssetQueryResult = NonNullable<
-  Awaited<ReturnType<typeof getAsset>>
->;
-export type GetAssetQueryError = ErrorType<AsError | void>;
-
-export const useGetAsset = <
-  TData = Awaited<ReturnType<typeof getAsset>>,
-  TError = ErrorType<AsError | void>
->(
-  params?: GetAssetParams,
-  options?: {
-    query?: UseQueryOptions<
-      Awaited<ReturnType<typeof getAsset>>,
-      TError,
-      TData
-    >;
-    request?: SecondParameter<typeof customInstance>;
-  }
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } => {
-  const { query: queryOptions, request: requestOptions } = options ?? {};
+      return customInstance<AssetGetResponse>(
+      {url: `/asset`, method: 'get',
+        params, signal
+    },
+      options);
+    }
+  
+
+export const getGetAssetQueryKey = (params?: GetAssetParams,) => [`/asset`, ...(params ? [params]: [])];
+
+    
+export type GetAssetQueryResult = NonNullable<Awaited<ReturnType<typeof getAsset>>>
+export type GetAssetQueryError = ErrorType<AsError | void>
+
+export const useGetAsset = <TData = Awaited<ReturnType<typeof getAsset>>, TError = ErrorType<AsError | void>>(
+ params?: GetAssetParams, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getAsset>>, TError, TData>, request?: SecondParameter<typeof customInstance>}
+
+  ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } => {
+
+  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 query = useQuery<Awaited<ReturnType<typeof getAsset>>, TError, TData>(
-    queryKey,
-    queryFn,
-    queryOptions
-  ) as UseQueryResult<TData, TError> & { queryKey: QueryKey };
+  const queryFn: QueryFunction<Awaited<ReturnType<typeof getAsset>>> = ({ signal }) => getAsset(params, requestOptions, signal);
+
+  const query = useQuery<Awaited<ReturnType<typeof getAsset>>, TError, TData>(queryKey, queryFn, queryOptions) as  UseQueryResult<TData, TError> & { queryKey: QueryKey };
 
   query.queryKey = queryKey;
 
   return query;
-};
+}
 
 /**
  * Creates an Asset, which can be attached to our User account, or a Product, Unit or Organisation you have access to
@@ -102,327 +90,242 @@ export const useGetAsset = <
  * @summary Create an Asset
  */
 export const createAsset = (
-  assetPostBodyBody: AssetPostBodyBody,
-  options?: SecondParameter<typeof customInstance>
-) => {
-  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,
+    assetPostBodyBody: AssetPostBodyBody,
+ options?: SecondParameter<typeof customInstance>,) => {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
     },
-    options
-  );
-};
-
-export type CreateAssetMutationResult = NonNullable<
-  Awaited<ReturnType<typeof createAsset>>
->;
-export type CreateAssetMutationBody = AssetPostBodyBody;
-export type CreateAssetMutationError = ErrorType<AsError | void>;
-
-export const useCreateAsset = <
-  TError = ErrorType<AsError | void>,
-  TContext = unknown
->(options?: {
-  mutation?: UseMutationOptions<
-    Awaited<ReturnType<typeof createAsset>>,
-    TError,
-    { data: AssetPostBodyBody },
-    TContext
-  >;
-  request?: SecondParameter<typeof customInstance>;
-}) => {
-  const { mutation: mutationOptions, request: requestOptions } = options ?? {};
-
-  const mutationFn: MutationFunction<
-    Awaited<ReturnType<typeof createAsset>>,
-    { data: AssetPostBodyBody }
-  > = (props) => {
-    const { data } = props ?? {};
-
-    return createAsset(data, requestOptions);
-  };
-
-  return useMutation<
-    Awaited<ReturnType<typeof createAsset>>,
-    TError,
-    { data: AssetPostBodyBody },
-    TContext
-  >(mutationFn, mutationOptions);
-};
-/**
+      options);
+    }
+  
+
+
+    export type CreateAssetMutationResult = NonNullable<Awaited<ReturnType<typeof createAsset>>>
+    export type CreateAssetMutationBody = AssetPostBodyBody
+    export type CreateAssetMutationError = ErrorType<AsError | void>
+
+    export const useCreateAsset = <TError = ErrorType<AsError | void>,
+    
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createAsset>>, TError,{data: AssetPostBodyBody}, TContext>, request?: SecondParameter<typeof customInstance>}
+) => {
+      const {mutation: mutationOptions, request: requestOptions} = options ?? {}
+
+      
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof createAsset>>, {data: AssetPostBodyBody}> = (props) => {
+          const {data} = props ?? {};
+
+          return  createAsset(data,requestOptions)
+        }
+
+      return useMutation<Awaited<ReturnType<typeof createAsset>>, TError, {data: AssetPostBodyBody}, TContext>(mutationFn, mutationOptions)
+    }
+    /**
  * Deletes a known Asset. Assets that are attached to merchants cannot be deleted
 
  * @summary Deletes an Asset
  */
 export const deleteAsset = (
-  assetId: string,
-  options?: SecondParameter<typeof customInstance>
+    assetId: string,
+ options?: SecondParameter<typeof customInstance>,) => {
+      return customInstance<void>(
+      {url: `/asset/${assetId}`, method: 'delete'
+    },
+      options);
+    }
+  
+
+
+    export type DeleteAssetMutationResult = NonNullable<Awaited<ReturnType<typeof deleteAsset>>>
+    
+    export type DeleteAssetMutationError = ErrorType<AsError>
+
+    export const useDeleteAsset = <TError = ErrorType<AsError>,
+    
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteAsset>>, TError,{assetId: string}, TContext>, request?: SecondParameter<typeof customInstance>}
 ) => {
-  return customInstance<void>(
-    { url: `/asset/${assetId}`, method: "delete" },
-    options
-  );
-};
-
-export type DeleteAssetMutationResult = NonNullable<
-  Awaited<ReturnType<typeof deleteAsset>>
->;
-
-export type DeleteAssetMutationError = ErrorType<AsError>;
-
-export const useDeleteAsset = <
-  TError = ErrorType<AsError>,
-  TContext = unknown
->(options?: {
-  mutation?: UseMutationOptions<
-    Awaited<ReturnType<typeof deleteAsset>>,
-    TError,
-    { assetId: string },
-    TContext
-  >;
-  request?: SecondParameter<typeof customInstance>;
-}) => {
-  const { mutation: mutationOptions, request: requestOptions } = options ?? {};
-
-  const mutationFn: MutationFunction<
-    Awaited<ReturnType<typeof deleteAsset>>,
-    { assetId: string }
-  > = (props) => {
-    const { assetId } = props ?? {};
-
-    return deleteAsset(assetId, requestOptions);
-  };
-
-  return useMutation<
-    Awaited<ReturnType<typeof deleteAsset>>,
-    TError,
-    { assetId: string },
-    TContext
-  >(mutationFn, mutationOptions);
-};
-/**
+      const {mutation: mutationOptions, request: requestOptions} = options ?? {}
+
+      
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof deleteAsset>>, {assetId: string}> = (props) => {
+          const {assetId} = props ?? {};
+
+          return  deleteAsset(assetId,requestOptions)
+        }
+
+      return useMutation<Awaited<ReturnType<typeof deleteAsset>>, TError, {assetId: string}, TContext>(mutationFn, mutationOptions)
+    }
+    /**
  * Disables a known Asset
 
  * @summary Disables an Asset
  */
 export const disableAsset = (
-  assetId: string,
-  options?: SecondParameter<typeof customInstance>
+    assetId: string,
+ options?: SecondParameter<typeof customInstance>,) => {
+      return customInstance<void>(
+      {url: `/asset/${assetId}/disable`, method: 'patch'
+    },
+      options);
+    }
+  
+
+
+    export type DisableAssetMutationResult = NonNullable<Awaited<ReturnType<typeof disableAsset>>>
+    
+    export type DisableAssetMutationError = ErrorType<AsError>
+
+    export const useDisableAsset = <TError = ErrorType<AsError>,
+    
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof disableAsset>>, TError,{assetId: string}, TContext>, request?: SecondParameter<typeof customInstance>}
 ) => {
-  return customInstance<void>(
-    { url: `/asset/${assetId}/disable`, method: "patch" },
-    options
-  );
-};
-
-export type DisableAssetMutationResult = NonNullable<
-  Awaited<ReturnType<typeof disableAsset>>
->;
-
-export type DisableAssetMutationError = ErrorType<AsError>;
-
-export const useDisableAsset = <
-  TError = ErrorType<AsError>,
-  TContext = unknown
->(options?: {
-  mutation?: UseMutationOptions<
-    Awaited<ReturnType<typeof disableAsset>>,
-    TError,
-    { assetId: string },
-    TContext
-  >;
-  request?: SecondParameter<typeof customInstance>;
-}) => {
-  const { mutation: mutationOptions, request: requestOptions } = options ?? {};
-
-  const mutationFn: MutationFunction<
-    Awaited<ReturnType<typeof disableAsset>>,
-    { assetId: string }
-  > = (props) => {
-    const { assetId } = props ?? {};
-
-    return disableAsset(assetId, requestOptions);
-  };
-
-  return useMutation<
-    Awaited<ReturnType<typeof disableAsset>>,
-    TError,
-    { assetId: string },
-    TContext
-  >(mutationFn, mutationOptions);
-};
-/**
+      const {mutation: mutationOptions, request: requestOptions} = options ?? {}
+
+      
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof disableAsset>>, {assetId: string}> = (props) => {
+          const {assetId} = props ?? {};
+
+          return  disableAsset(assetId,requestOptions)
+        }
+
+      return useMutation<Awaited<ReturnType<typeof disableAsset>>, TError, {assetId: string}, TContext>(mutationFn, mutationOptions)
+    }
+    /**
  * Enables a known Asset
 
  * @summary Enables an Asset
  */
 export const enableAsset = (
-  assetId: string,
-  options?: SecondParameter<typeof customInstance>
+    assetId: string,
+ options?: SecondParameter<typeof customInstance>,) => {
+      return customInstance<void>(
+      {url: `/asset/${assetId}/enable`, method: 'patch'
+    },
+      options);
+    }
+  
+
+
+    export type EnableAssetMutationResult = NonNullable<Awaited<ReturnType<typeof enableAsset>>>
+    
+    export type EnableAssetMutationError = ErrorType<AsError>
+
+    export const useEnableAsset = <TError = ErrorType<AsError>,
+    
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof enableAsset>>, TError,{assetId: string}, TContext>, request?: SecondParameter<typeof customInstance>}
 ) => {
-  return customInstance<void>(
-    { url: `/asset/${assetId}/enable`, method: "patch" },
-    options
-  );
-};
-
-export type EnableAssetMutationResult = NonNullable<
-  Awaited<ReturnType<typeof enableAsset>>
->;
-
-export type EnableAssetMutationError = ErrorType<AsError>;
-
-export const useEnableAsset = <
-  TError = ErrorType<AsError>,
-  TContext = unknown
->(options?: {
-  mutation?: UseMutationOptions<
-    Awaited<ReturnType<typeof enableAsset>>,
-    TError,
-    { assetId: string },
-    TContext
-  >;
-  request?: SecondParameter<typeof customInstance>;
-}) => {
-  const { mutation: mutationOptions, request: requestOptions } = options ?? {};
-
-  const mutationFn: MutationFunction<
-    Awaited<ReturnType<typeof enableAsset>>,
-    { assetId: string }
-  > = (props) => {
-    const { assetId } = props ?? {};
-
-    return enableAsset(assetId, requestOptions);
-  };
-
-  return useMutation<
-    Awaited<ReturnType<typeof enableAsset>>,
-    TError,
-    { assetId: string },
-    TContext
-  >(mutationFn, mutationOptions);
-};
-/**
+      const {mutation: mutationOptions, request: requestOptions} = options ?? {}
+
+      
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof enableAsset>>, {assetId: string}> = (props) => {
+          const {assetId} = props ?? {};
+
+          return  enableAsset(assetId,requestOptions)
+        }
+
+      return useMutation<Awaited<ReturnType<typeof enableAsset>>, TError, {assetId: string}, TContext>(mutationFn, mutationOptions)
+    }
+    /**
  * Attaches an Asset to a merchant
 
  * @summary Attaches an Asset to a Merchant
  */
 export const attachAsset = (
-  assetId: string,
-  params?: AttachAssetParams,
-  options?: SecondParameter<typeof customInstance>
+    assetId: string,
+    params?: AttachAssetParams,
+ options?: SecondParameter<typeof customInstance>,) => {
+      return customInstance<void>(
+      {url: `/asset/${assetId}/attach`, method: 'patch',
+        params
+    },
+      options);
+    }
+  
+
+
+    export type AttachAssetMutationResult = NonNullable<Awaited<ReturnType<typeof attachAsset>>>
+    
+    export type AttachAssetMutationError = ErrorType<AsError>
+
+    export const useAttachAsset = <TError = ErrorType<AsError>,
+    
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof attachAsset>>, TError,{assetId: string;params?: AttachAssetParams}, TContext>, request?: SecondParameter<typeof customInstance>}
 ) => {
-  return customInstance<void>(
-    { url: `/asset/${assetId}/attach`, method: "patch", params },
-    options
-  );
-};
-
-export type AttachAssetMutationResult = NonNullable<
-  Awaited<ReturnType<typeof attachAsset>>
->;
-
-export type AttachAssetMutationError = ErrorType<AsError>;
-
-export const useAttachAsset = <
-  TError = ErrorType<AsError>,
-  TContext = unknown
->(options?: {
-  mutation?: UseMutationOptions<
-    Awaited<ReturnType<typeof attachAsset>>,
-    TError,
-    { assetId: string; params?: AttachAssetParams },
-    TContext
-  >;
-  request?: SecondParameter<typeof customInstance>;
-}) => {
-  const { mutation: mutationOptions, request: requestOptions } = options ?? {};
-
-  const mutationFn: MutationFunction<
-    Awaited<ReturnType<typeof attachAsset>>,
-    { assetId: string; params?: AttachAssetParams }
-  > = (props) => {
-    const { assetId, params } = props ?? {};
-
-    return attachAsset(assetId, params, requestOptions);
-  };
-
-  return useMutation<
-    Awaited<ReturnType<typeof attachAsset>>,
-    TError,
-    { assetId: string; params?: AttachAssetParams },
-    TContext
-  >(mutationFn, mutationOptions);
-};
-/**
+      const {mutation: mutationOptions, request: requestOptions} = options ?? {}
+
+      
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof attachAsset>>, {assetId: string;params?: AttachAssetParams}> = (props) => {
+          const {assetId,params} = props ?? {};
+
+          return  attachAsset(assetId,params,requestOptions)
+        }
+
+      return useMutation<Awaited<ReturnType<typeof attachAsset>>, TError, {assetId: string;params?: AttachAssetParams}, TContext>(mutationFn, mutationOptions)
+    }
+    /**
  * Detaches an Asset from a merchant
 
  * @summary Detaches an Asset from a Merchant
  */
 export const detachAsset = (
-  assetId: string,
-  params?: DetachAssetParams,
-  options?: SecondParameter<typeof customInstance>
+    assetId: string,
+    params?: DetachAssetParams,
+ options?: SecondParameter<typeof customInstance>,) => {
+      return customInstance<void>(
+      {url: `/asset/${assetId}/detach`, method: 'patch',
+        params
+    },
+      options);
+    }
+  
+
+
+    export type DetachAssetMutationResult = NonNullable<Awaited<ReturnType<typeof detachAsset>>>
+    
+    export type DetachAssetMutationError = ErrorType<AsError>
+
+    export const useDetachAsset = <TError = ErrorType<AsError>,
+    
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof detachAsset>>, TError,{assetId: string;params?: DetachAssetParams}, TContext>, request?: SecondParameter<typeof customInstance>}
 ) => {
-  return customInstance<void>(
-    { url: `/asset/${assetId}/detach`, method: "patch", params },
-    options
-  );
-};
-
-export type DetachAssetMutationResult = NonNullable<
-  Awaited<ReturnType<typeof detachAsset>>
->;
-
-export type DetachAssetMutationError = ErrorType<AsError>;
-
-export const useDetachAsset = <
-  TError = ErrorType<AsError>,
-  TContext = unknown
->(options?: {
-  mutation?: UseMutationOptions<
-    Awaited<ReturnType<typeof detachAsset>>,
-    TError,
-    { assetId: string; params?: DetachAssetParams },
-    TContext
-  >;
-  request?: SecondParameter<typeof customInstance>;
-}) => {
-  const { mutation: mutationOptions, request: requestOptions } = options ?? {};
-
-  const mutationFn: MutationFunction<
-    Awaited<ReturnType<typeof detachAsset>>,
-    { assetId: string; params?: DetachAssetParams }
-  > = (props) => {
-    const { assetId, params } = props ?? {};
-
-    return detachAsset(assetId, params, requestOptions);
-  };
-
-  return useMutation<
-    Awaited<ReturnType<typeof detachAsset>>,
-    TError,
-    { assetId: string; params?: DetachAssetParams },
-    TContext
-  >(mutationFn, mutationOptions);
-};
+      const {mutation: mutationOptions, request: requestOptions} = options ?? {}
+
+      
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof detachAsset>>, {assetId: string;params?: DetachAssetParams}> = (props) => {
+          const {assetId,params} = props ?? {};
+
+          return  detachAsset(assetId,params,requestOptions)
+        }
+
+      return useMutation<Awaited<ReturnType<typeof detachAsset>>, TError, {assetId: string;params?: DetachAssetParams}, TContext>(mutationFn, mutationOptions)
+    }
+