@outseta/react 0.4.31 → 0.4.32

package/dist/index.js

@@ -3029,6 +3029,27 @@ function useCaseGetCase(caseUid, options) {
   query.queryKey = queryOptions.queryKey;
   return query;
 }
+var caseUpdateCase = (caseUid, caseUpdateCaseBody, options) => {
+  return customFetch2({
+    url: `/api/v1/support/cases/${caseUid}`,
+    method: "PUT",
+    headers: { "Content-Type": "application/json" },
+    data: caseUpdateCaseBody
+  }, options);
+};
+var getCaseUpdateCaseMutationOptions = (options) => {
+  const mutationKey = ["caseUpdateCase"];
+  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 = (props) => {
+    const { caseUid, data } = props ?? {};
+    return caseUpdateCase(caseUid, data, requestOptions);
+  };
+  return { mutationFn, ...mutationOptions };
+};
+var useCaseUpdateCase = (options) => {
+  const mutationOptions = getCaseUpdateCaseMutationOptions(options);
+  return useMutation(mutationOptions);
+};
 var caseAddReply = (caseUid, options, signal) => {
   return customFetch2({
     url: `/api/v1/support/cases/${caseUid}/replies`,
@@ -3848,6 +3869,7 @@ export {
   caseAddReply,
   caseGetAllCases,
   caseGetCase,
+  caseUpdateCase,
   categoryGetAllCategories,
   createClient,
   dealAddDeal,
@@ -3919,6 +3941,7 @@ export {
   getCaseGetAllCasesQueryOptions,
   getCaseGetCaseQueryKey,
   getCaseGetCaseQueryOptions,
+  getCaseUpdateCaseMutationOptions,
   getCategoryGetAllCategoriesQueryKey,
   getCategoryGetAllCategoriesQueryOptions,
   getDealAddDealMutationOptions,
@@ -4105,6 +4128,7 @@ export {
   useCaseAddReply,
   useCaseGetAllCases,
   useCaseGetCase,
+  useCaseUpdateCase,
   useCategoryGetAllCategories,
   useDealAddDeal,
   useDealDeleteDeal,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outseta/react",
-  "version": "0.4.31",
+  "version": "0.4.32",
   "description": "React hooks and components for the Outseta API",
   "license": "MIT",
   "repository": {
@@ -18,7 +18,7 @@
     }
   },
   "dependencies": {
-    "@outseta/api-client": "0.3.37"
+    "@outseta/api-client": "0.3.38"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0"

package/src/generated/attribute/attribute.ts

@@ -1,10 +1,14 @@
 // @ts-nocheck
 import {
+  useMutation,
   useQuery
 } from '../../query';
 import type {
+  MutationFunction,
   QueryFunction,
   QueryKey,
+  UseMutationOptions,
+  UseMutationResult,
   UseQueryOptions,
   UseQueryResult
 } from '../../query';
@@ -12,17 +16,398 @@ import type {
 import type {
   Definition,
   DefinitionGetAllDefinitions200,
-  DefinitionGetAllDefinitionsParams
+  DefinitionGetAllDefinitionsParams,
+  Tag,
+  TagAddTagBody,
+  TagGetAllTags200,
+  TagGetAllTagsParams,
+  TagUpdateTagBody
 } from '../outsetaAPI.schemas';
 
 import { customFetch } from '../../mutator';
 
+// https://stackoverflow.com/questions/49579094/typescript-conditional-types-filter-out-readonly-properties-pick-only-requir/49579497#49579497
+type IfEquals<X, Y, A = X, B = never> = (<T>() => T extends X ? 1 : 2) extends <
+T,
+>() => T extends Y ? 1 : 2
+? A
+: B;
+
+type WritableKeys<T> = {
+[P in keyof T]-?: IfEquals<
+  { [Q in P]: T[P] },
+  { -readonly [Q in P]: T[P] },
+  P
+>;
+}[keyof T];
+
+type UnionToIntersection<U> =
+  (U extends any ? (k: U)=>void : never) extends ((k: infer I)=>void) ? I : never;
+type DistributeReadOnlyOverUnions<T> = T extends any ? NonReadonly<T> : never;
+
+type Writable<T> = Pick<T, WritableKeys<T>>;
+type NonReadonly<T> = [T] extends [UnionToIntersection<T>] ? {
+  [P in keyof Writable<T>]: T[P] extends object
+    ? NonReadonly<NonNullable<T[P]>>
+    : T[P];
+} : DistributeReadOnlyOverUnions<T>;
+
+
 
 type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
 
 
 
 /**
+ * Each tag applies to a single entity type. Pass entityType=Case to retrieve the tags
+that can be put on support tickets.
+            
+How a tag goes onto a record depends on the entity type. A support ticket holds its
+tags in its own CaseTags collection, so you add and remove ticket tags with
+PUT /support/cases/{caseUid}. Other entity types store their tags differently. This
+documentation covers ticket tags only.
+            
+Name is unique within an entity type. SystemName and SystemDescription identify a
+built-in tag (for example Priority.Urgent) and are set by Outseta.
+ * @summary Retrieve all tags.
+ */
+export const tagGetAllTags = (
+    params?: TagGetAllTagsParams,
+ options?: SecondParameter<typeof customFetch>,signal?: AbortSignal
+) => {
+      
+      
+      return customFetch<TagGetAllTags200>(
+      {url: `/api/v1/attribute/tags`, method: 'GET',
+        params, signal
+    },
+      options);
+    }
+  
+
+
+
+export const getTagGetAllTagsQueryKey = (params?: TagGetAllTagsParams,) => {
+    return [
+    `/api/v1/attribute/tags`, ...(params ? [params]: [])
+    ] as const;
+    }
+
+    
+export const getTagGetAllTagsQueryOptions = <TData = Awaited<ReturnType<typeof tagGetAllTags>>, TError = void>(params?: TagGetAllTagsParams, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof tagGetAllTags>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
+) => {
+
+const {query: queryOptions, request: requestOptions} = options ?? {};
+
+  const queryKey =  queryOptions?.queryKey ?? getTagGetAllTagsQueryKey(params);
+
+  
+
+    const queryFn: QueryFunction<Awaited<ReturnType<typeof tagGetAllTags>>> = ({ signal }) => tagGetAllTags(params, requestOptions, signal);
+
+      
+
+      
+
+   return  { queryKey, queryFn, ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof tagGetAllTags>>, TError, TData> & { queryKey: QueryKey }
+}
+
+export type TagGetAllTagsQueryResult = NonNullable<Awaited<ReturnType<typeof tagGetAllTags>>>
+export type TagGetAllTagsQueryError = void
+
+
+/**
+ * @summary Retrieve all tags.
+ */
+
+export function useTagGetAllTags<TData = Awaited<ReturnType<typeof tagGetAllTags>>, TError = void>(
+ params?: TagGetAllTagsParams, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof tagGetAllTags>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
+  
+ ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+
+  const queryOptions = getTagGetAllTagsQueryOptions(params,options)
+
+  const query = useQuery(queryOptions) as  UseQueryResult<TData, TError> & { queryKey: QueryKey };
+
+  query.queryKey = queryOptions.queryKey ;
+
+  return query;
+}
+
+
+
+
+/**
+ * Name and EntityType are required. Use EntityType 4 (Case) for a tag that goes on
+support tickets. TagColor sets the color the tag shows in.
+            
+Name must be unique within an entity type. If the name already exists for that
+entity type, the existing tag is returned instead of a duplicate, and its color is
+updated when a different TagColor is supplied. SystemName and SystemDescription are
+set by Outseta and are ignored here.
+ * @summary Create a tag.
+ */
+export const tagAddTag = (
+    tagAddTagBody: NonReadonly<TagAddTagBody>,
+ options?: SecondParameter<typeof customFetch>,signal?: AbortSignal
+) => {
+      
+      
+      return customFetch<Tag>(
+      {url: `/api/v1/attribute/tags`, method: 'POST',
+      headers: {'Content-Type': 'application/json', },
+      data: tagAddTagBody, signal
+    },
+      options);
+    }
+  
+
+
+export const getTagAddTagMutationOptions = <TError = void,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof tagAddTag>>, TError,{data: NonReadonly<TagAddTagBody>}, TContext>, request?: SecondParameter<typeof customFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof tagAddTag>>, TError,{data: NonReadonly<TagAddTagBody>}, TContext> => {
+
+const mutationKey = ['tagAddTag'];
+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 tagAddTag>>, {data: NonReadonly<TagAddTagBody>}> = (props) => {
+          const {data} = props ?? {};
+
+          return  tagAddTag(data,requestOptions)
+        }
+
+        
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type TagAddTagMutationResult = NonNullable<Awaited<ReturnType<typeof tagAddTag>>>
+    export type TagAddTagMutationBody = NonReadonly<TagAddTagBody>
+    export type TagAddTagMutationError = void
+
+    /**
+ * @summary Create a tag.
+ */
+export const useTagAddTag = <TError = void,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof tagAddTag>>, TError,{data: NonReadonly<TagAddTagBody>}, TContext>, request?: SecondParameter<typeof customFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof tagAddTag>>,
+        TError,
+        {data: NonReadonly<TagAddTagBody>},
+        TContext
+      > => {
+
+      const mutationOptions = getTagAddTagMutationOptions(options);
+
+      return useMutation(mutationOptions);
+    }
+    /**
+ * @summary Retrieve a tag.
+ */
+export const tagGetTag = (
+    tagUid: string | null,
+ options?: SecondParameter<typeof customFetch>,signal?: AbortSignal
+) => {
+      
+      
+      return customFetch<Tag>(
+      {url: `/api/v1/attribute/tags/${tagUid}`, method: 'GET', signal
+    },
+      options);
+    }
+  
+
+
+
+export const getTagGetTagQueryKey = (tagUid?: string | null,) => {
+    return [
+    `/api/v1/attribute/tags/${tagUid}`
+    ] as const;
+    }
+
+    
+export const getTagGetTagQueryOptions = <TData = Awaited<ReturnType<typeof tagGetTag>>, TError = void>(tagUid: string | null, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof tagGetTag>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
+) => {
+
+const {query: queryOptions, request: requestOptions} = options ?? {};
+
+  const queryKey =  queryOptions?.queryKey ?? getTagGetTagQueryKey(tagUid);
+
+  
+
+    const queryFn: QueryFunction<Awaited<ReturnType<typeof tagGetTag>>> = ({ signal }) => tagGetTag(tagUid, requestOptions, signal);
+
+      
+
+      
+
+   return  { queryKey, queryFn, enabled: !!(tagUid), ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof tagGetTag>>, TError, TData> & { queryKey: QueryKey }
+}
+
+export type TagGetTagQueryResult = NonNullable<Awaited<ReturnType<typeof tagGetTag>>>
+export type TagGetTagQueryError = void
+
+
+/**
+ * @summary Retrieve a tag.
+ */
+
+export function useTagGetTag<TData = Awaited<ReturnType<typeof tagGetTag>>, TError = void>(
+ tagUid: string | null, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof tagGetTag>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
+  
+ ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+
+  const queryOptions = getTagGetTagQueryOptions(tagUid,options)
+
+  const query = useQuery(queryOptions) as  UseQueryResult<TData, TError> & { queryKey: QueryKey };
+
+  query.queryKey = queryOptions.queryKey ;
+
+  return query;
+}
+
+
+
+
+/**
+ * Use this to rename a tag or to change its color. EntityType cannot be changed after
+the tag is created. Name must stay unique within the entity type. SystemName and
+SystemDescription are set by Outseta and cannot be changed.
+ * @summary Update a tag.
+ */
+export const tagUpdateTag = (
+    tagUid: string | null,
+    tagUpdateTagBody: NonReadonly<TagUpdateTagBody>,
+ options?: SecondParameter<typeof customFetch>,) => {
+      
+      
+      return customFetch<Tag>(
+      {url: `/api/v1/attribute/tags/${tagUid}`, method: 'PUT',
+      headers: {'Content-Type': 'application/json', },
+      data: tagUpdateTagBody
+    },
+      options);
+    }
+  
+
+
+export const getTagUpdateTagMutationOptions = <TError = void,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof tagUpdateTag>>, TError,{tagUid: string | null;data: NonReadonly<TagUpdateTagBody>}, TContext>, request?: SecondParameter<typeof customFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof tagUpdateTag>>, TError,{tagUid: string | null;data: NonReadonly<TagUpdateTagBody>}, TContext> => {
+
+const mutationKey = ['tagUpdateTag'];
+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 tagUpdateTag>>, {tagUid: string | null;data: NonReadonly<TagUpdateTagBody>}> = (props) => {
+          const {tagUid,data} = props ?? {};
+
+          return  tagUpdateTag(tagUid,data,requestOptions)
+        }
+
+        
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type TagUpdateTagMutationResult = NonNullable<Awaited<ReturnType<typeof tagUpdateTag>>>
+    export type TagUpdateTagMutationBody = NonReadonly<TagUpdateTagBody>
+    export type TagUpdateTagMutationError = void
+
+    /**
+ * @summary Update a tag.
+ */
+export const useTagUpdateTag = <TError = void,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof tagUpdateTag>>, TError,{tagUid: string | null;data: NonReadonly<TagUpdateTagBody>}, TContext>, request?: SecondParameter<typeof customFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof tagUpdateTag>>,
+        TError,
+        {tagUid: string | null;data: NonReadonly<TagUpdateTagBody>},
+        TContext
+      > => {
+
+      const mutationOptions = getTagUpdateTagMutationOptions(options);
+
+      return useMutation(mutationOptions);
+    }
+    /**
+ * The tag is also taken off every record that carries it. For a Case tag, it is
+removed from all support tickets that have it.
+ * @summary Delete a tag.
+ */
+export const tagDeleteTag = (
+    tagUid: string | null,
+ options?: SecondParameter<typeof customFetch>,) => {
+      
+      
+      return customFetch<Blob>(
+      {url: `/api/v1/attribute/tags/${tagUid}`, method: 'DELETE',
+        responseType: 'blob'
+    },
+      options);
+    }
+  
+
+
+export const getTagDeleteTagMutationOptions = <TError = void,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof tagDeleteTag>>, TError,{tagUid: string | null}, TContext>, request?: SecondParameter<typeof customFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof tagDeleteTag>>, TError,{tagUid: string | null}, TContext> => {
+
+const mutationKey = ['tagDeleteTag'];
+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 tagDeleteTag>>, {tagUid: string | null}> = (props) => {
+          const {tagUid} = props ?? {};
+
+          return  tagDeleteTag(tagUid,requestOptions)
+        }
+
+        
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type TagDeleteTagMutationResult = NonNullable<Awaited<ReturnType<typeof tagDeleteTag>>>
+    
+    export type TagDeleteTagMutationError = void
+
+    /**
+ * @summary Delete a tag.
+ */
+export const useTagDeleteTag = <TError = void,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof tagDeleteTag>>, TError,{tagUid: string | null}, TContext>, request?: SecondParameter<typeof customFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof tagDeleteTag>>,
+        TError,
+        {tagUid: string | null},
+        TContext
+      > => {
+
+      const mutationOptions = getTagDeleteTagMutationOptions(options);
+
+      return useMutation(mutationOptions);
+    }
+    /**
  * entityType is the name of an EntityType enum value, for example: Account, Person,
 Deal. Definitions describe the labels, system names, and control types of
 the custom attributes that have been added to that entity.

package/src/generated/outsetaAPI.schemas.ts

@@ -3173,19 +3173,12 @@ export const SupportCaseHistoryType = {
   ContactChange: 8,
 } as const;
 
-/**
- * @nullable
- */
-export type CaseTagAllOfCase = Case | null;
-
 /**
  * @nullable
  */
 export type CaseTagAllOfTag = Tag | null;
 
 export type CaseTagAllOf = {
-  /** @nullable */
-  Case?: CaseTagAllOfCase;
   /** @nullable */
   Tag?: CaseTagAllOfTag;
 };
@@ -9206,6 +9199,37 @@ export type LimitParameter = number;
  */
 export type OffsetParameter = number;
 
+export type TagGetAllTagsParams = {
+/**
+ * The entity type whose tags to retrieve, as the name or the numeric value (for example Case or 4)
+ * @nullable
+ */
+entityType?: string | null;
+/**
+ * Requested page size. The server caps it at 100, or 25 when requested fields expand child objects or require additional queries; metadata.limit reports the applied value. Use offset=1 for the second page.
+ */
+limit?: LimitParameter;
+/**
+ * Zero-based page number, not a record offset. With limit=50, the second page is offset=1; offset=50 is page index 50 (records 2501-2550).
+ */
+offset?: OffsetParameter;
+};
+
+export type TagGetAllTags200 = {
+  metadata?: CollectionMetadata;
+  items?: Tag[];
+};
+
+/**
+ * @nullable
+ */
+export type TagAddTagBody = Tag | null;
+
+/**
+ * @nullable
+ */
+export type TagUpdateTagBody = Tag | null;
+
 export type DefinitionGetAllDefinitionsParams = {
 /**
  * Requested page size. The server caps it at 100, or 25 when requested fields expand child objects or require additional queries; metadata.limit reports the applied value. Use offset=1 for the second page.
@@ -9329,6 +9353,11 @@ sendautoresponder?: string | null;
  */
 export type CaseAddCaseBody = Case | null;
 
+/**
+ * @nullable
+ */
+export type CaseUpdateCaseBody = Case | null;
+
 export type ArticleGetAllArticlesParams = {
 /**
  * Matches on title or body of the article

package/src/generated/support/support.ts

@@ -24,6 +24,7 @@ import type {
   CaseGetAllCases200,
   CaseGetAllCasesParams,
   CaseHistory,
+  CaseUpdateCaseBody,
   CategoryGetAllCategories200,
   CategoryGetAllCategoriesParams
 } from '../outsetaAPI.schemas';
@@ -269,6 +270,88 @@ export function useCaseGetCase<TData = Awaited<ReturnType<typeof caseGetCase>>,
 
 
 /**
+ * The Uid in the URL identifies the ticket, and a Uid in the request body is ignored.
+Any property that the body does not contain keeps its current value, so a request
+can send only the properties that change.
+            
+Tags are managed through the CaseTags collection. Send the full set of tags that
+the ticket must end with:
+            
+- To keep a tag, include its entry with the CaseTag Uid that GET returned.
+- To add a tag, include an entry that has no Uid and a Tag that holds the tag's Uid.
+- To remove a tag, leave its entry out.
+- To remove all tags, send an empty array.
+            
+If the body does not contain CaseTags, the current tags stay as they are. To read
+the current tags, request them with the fields parameter, for example
+fields=Uid,CaseTags.Uid,CaseTags.Tag.Uid,CaseTags.Tag.Name. To get the tags that are
+available for tickets, use GET /attribute/tags?entityType=Case.
+            
+Case history is kept. Add replies and notes with their own endpoints.
+ * @summary Update a support ticket.
+ */
+export const caseUpdateCase = (
+    caseUid: string | null,
+    caseUpdateCaseBody: NonReadonly<CaseUpdateCaseBody>,
+ options?: SecondParameter<typeof customFetch>,) => {
+      
+      
+      return customFetch<Case>(
+      {url: `/api/v1/support/cases/${caseUid}`, method: 'PUT',
+      headers: {'Content-Type': 'application/json', },
+      data: caseUpdateCaseBody
+    },
+      options);
+    }
+  
+
+
+export const getCaseUpdateCaseMutationOptions = <TError = void,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof caseUpdateCase>>, TError,{caseUid: string | null;data: NonReadonly<CaseUpdateCaseBody>}, TContext>, request?: SecondParameter<typeof customFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof caseUpdateCase>>, TError,{caseUid: string | null;data: NonReadonly<CaseUpdateCaseBody>}, TContext> => {
+
+const mutationKey = ['caseUpdateCase'];
+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 caseUpdateCase>>, {caseUid: string | null;data: NonReadonly<CaseUpdateCaseBody>}> = (props) => {
+          const {caseUid,data} = props ?? {};
+
+          return  caseUpdateCase(caseUid,data,requestOptions)
+        }
+
+        
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type CaseUpdateCaseMutationResult = NonNullable<Awaited<ReturnType<typeof caseUpdateCase>>>
+    export type CaseUpdateCaseMutationBody = NonReadonly<CaseUpdateCaseBody>
+    export type CaseUpdateCaseMutationError = void
+
+    /**
+ * @summary Update a support ticket.
+ */
+export const useCaseUpdateCase = <TError = void,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof caseUpdateCase>>, TError,{caseUid: string | null;data: NonReadonly<CaseUpdateCaseBody>}, TContext>, request?: SecondParameter<typeof customFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof caseUpdateCase>>,
+        TError,
+        {caseUid: string | null;data: NonReadonly<CaseUpdateCaseBody>},
+        TContext
+      > => {
+
+      const mutationOptions = getCaseUpdateCaseMutationOptions(options);
+
+      return useMutation(mutationOptions);
+    }
+    /**
  * @summary Adds a reply from an agent to a support case.
  */
 export const caseAddReply = (