@outseta/react 0.3.1 → 0.3.3

package/src/generated/email/email.ts

@@ -25,6 +25,33 @@ import type {
 
 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];
 
@@ -106,7 +133,7 @@ directly. If both are provided, they are merged.
  * @summary Create a new broadcast campaign.
  */
 export const campaignAddBroadcastEmail = (
-    campaignAddBroadcastEmailBody: CampaignAddBroadcastEmailBody,
+    campaignAddBroadcastEmailBody: NonReadonly<CampaignAddBroadcastEmailBody>,
  options?: SecondParameter<typeof customFetch>,signal?: AbortSignal
 ) => {
       
@@ -122,8 +149,8 @@ export const campaignAddBroadcastEmail = (
 
 
 export const getCampaignAddBroadcastEmailMutationOptions = <TError = void,
-    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof campaignAddBroadcastEmail>>, TError,{data: CampaignAddBroadcastEmailBody}, TContext>, request?: SecondParameter<typeof customFetch>}
-): UseMutationOptions<Awaited<ReturnType<typeof campaignAddBroadcastEmail>>, TError,{data: CampaignAddBroadcastEmailBody}, TContext> => {
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof campaignAddBroadcastEmail>>, TError,{data: NonReadonly<CampaignAddBroadcastEmailBody>}, TContext>, request?: SecondParameter<typeof customFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof campaignAddBroadcastEmail>>, TError,{data: NonReadonly<CampaignAddBroadcastEmailBody>}, TContext> => {
 
 const mutationKey = ['campaignAddBroadcastEmail'];
 const {mutation: mutationOptions, request: requestOptions} = options ?
@@ -135,7 +162,7 @@ const {mutation: mutationOptions, request: requestOptions} = options ?
       
 
 
-      const mutationFn: MutationFunction<Awaited<ReturnType<typeof campaignAddBroadcastEmail>>, {data: CampaignAddBroadcastEmailBody}> = (props) => {
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof campaignAddBroadcastEmail>>, {data: NonReadonly<CampaignAddBroadcastEmailBody>}> = (props) => {
           const {data} = props ?? {};
 
           return  campaignAddBroadcastEmail(data,requestOptions)
@@ -147,18 +174,18 @@ const {mutation: mutationOptions, request: requestOptions} = options ?
   return  { mutationFn, ...mutationOptions }}
 
     export type CampaignAddBroadcastEmailMutationResult = NonNullable<Awaited<ReturnType<typeof campaignAddBroadcastEmail>>>
-    export type CampaignAddBroadcastEmailMutationBody = CampaignAddBroadcastEmailBody
+    export type CampaignAddBroadcastEmailMutationBody = NonReadonly<CampaignAddBroadcastEmailBody>
     export type CampaignAddBroadcastEmailMutationError = void
 
     /**
  * @summary Create a new broadcast campaign.
  */
 export const useCampaignAddBroadcastEmail = <TError = void,
-    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof campaignAddBroadcastEmail>>, TError,{data: CampaignAddBroadcastEmailBody}, TContext>, request?: SecondParameter<typeof customFetch>}
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof campaignAddBroadcastEmail>>, TError,{data: NonReadonly<CampaignAddBroadcastEmailBody>}, TContext>, request?: SecondParameter<typeof customFetch>}
  ): UseMutationResult<
         Awaited<ReturnType<typeof campaignAddBroadcastEmail>>,
         TError,
-        {data: CampaignAddBroadcastEmailBody},
+        {data: NonReadonly<CampaignAddBroadcastEmailBody>},
         TContext
       > => {
 
@@ -243,7 +270,7 @@ directly. If both are provided, they are merged.
  */
 export const campaignUpdateBroadcastEmail = (
     broadcastCampaignUid: string | null,
-    campaignUpdateBroadcastEmailBody: CampaignUpdateBroadcastEmailBody,
+    campaignUpdateBroadcastEmailBody: NonReadonly<CampaignUpdateBroadcastEmailBody>,
  options?: SecondParameter<typeof customFetch>,) => {
       
       
@@ -258,8 +285,8 @@ export const campaignUpdateBroadcastEmail = (
 
 
 export const getCampaignUpdateBroadcastEmailMutationOptions = <TError = void,
-    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof campaignUpdateBroadcastEmail>>, TError,{broadcastCampaignUid: string | null;data: CampaignUpdateBroadcastEmailBody}, TContext>, request?: SecondParameter<typeof customFetch>}
-): UseMutationOptions<Awaited<ReturnType<typeof campaignUpdateBroadcastEmail>>, TError,{broadcastCampaignUid: string | null;data: CampaignUpdateBroadcastEmailBody}, TContext> => {
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof campaignUpdateBroadcastEmail>>, TError,{broadcastCampaignUid: string | null;data: NonReadonly<CampaignUpdateBroadcastEmailBody>}, TContext>, request?: SecondParameter<typeof customFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof campaignUpdateBroadcastEmail>>, TError,{broadcastCampaignUid: string | null;data: NonReadonly<CampaignUpdateBroadcastEmailBody>}, TContext> => {
 
 const mutationKey = ['campaignUpdateBroadcastEmail'];
 const {mutation: mutationOptions, request: requestOptions} = options ?
@@ -271,7 +298,7 @@ const {mutation: mutationOptions, request: requestOptions} = options ?
       
 
 
-      const mutationFn: MutationFunction<Awaited<ReturnType<typeof campaignUpdateBroadcastEmail>>, {broadcastCampaignUid: string | null;data: CampaignUpdateBroadcastEmailBody}> = (props) => {
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof campaignUpdateBroadcastEmail>>, {broadcastCampaignUid: string | null;data: NonReadonly<CampaignUpdateBroadcastEmailBody>}> = (props) => {
           const {broadcastCampaignUid,data} = props ?? {};
 
           return  campaignUpdateBroadcastEmail(broadcastCampaignUid,data,requestOptions)
@@ -283,18 +310,18 @@ const {mutation: mutationOptions, request: requestOptions} = options ?
   return  { mutationFn, ...mutationOptions }}
 
     export type CampaignUpdateBroadcastEmailMutationResult = NonNullable<Awaited<ReturnType<typeof campaignUpdateBroadcastEmail>>>
-    export type CampaignUpdateBroadcastEmailMutationBody = CampaignUpdateBroadcastEmailBody
+    export type CampaignUpdateBroadcastEmailMutationBody = NonReadonly<CampaignUpdateBroadcastEmailBody>
     export type CampaignUpdateBroadcastEmailMutationError = void
 
     /**
  * @summary Update a broadcast campaign.
  */
 export const useCampaignUpdateBroadcastEmail = <TError = void,
-    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof campaignUpdateBroadcastEmail>>, TError,{broadcastCampaignUid: string | null;data: CampaignUpdateBroadcastEmailBody}, TContext>, request?: SecondParameter<typeof customFetch>}
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof campaignUpdateBroadcastEmail>>, TError,{broadcastCampaignUid: string | null;data: NonReadonly<CampaignUpdateBroadcastEmailBody>}, TContext>, request?: SecondParameter<typeof customFetch>}
  ): UseMutationResult<
         Awaited<ReturnType<typeof campaignUpdateBroadcastEmail>>,
         TError,
-        {broadcastCampaignUid: string | null;data: CampaignUpdateBroadcastEmailBody},
+        {broadcastCampaignUid: string | null;data: NonReadonly<CampaignUpdateBroadcastEmailBody>},
         TContext
       > => {
 
@@ -640,7 +667,7 @@ determines if the person is sent a welcome email and defaults to false.
  */
 export const emailListAddSubscription = (
     emailListUid: string | null,
-    emailListAddSubscriptionBody: EmailListAddSubscriptionBody,
+    emailListAddSubscriptionBody: NonReadonly<EmailListAddSubscriptionBody>,
  options?: SecondParameter<typeof customFetch>,signal?: AbortSignal
 ) => {
       
@@ -656,8 +683,8 @@ export const emailListAddSubscription = (
 
 
 export const getEmailListAddSubscriptionMutationOptions = <TError = void,
-    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof emailListAddSubscription>>, TError,{emailListUid: string | null;data: EmailListAddSubscriptionBody}, TContext>, request?: SecondParameter<typeof customFetch>}
-): UseMutationOptions<Awaited<ReturnType<typeof emailListAddSubscription>>, TError,{emailListUid: string | null;data: EmailListAddSubscriptionBody}, TContext> => {
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof emailListAddSubscription>>, TError,{emailListUid: string | null;data: NonReadonly<EmailListAddSubscriptionBody>}, TContext>, request?: SecondParameter<typeof customFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof emailListAddSubscription>>, TError,{emailListUid: string | null;data: NonReadonly<EmailListAddSubscriptionBody>}, TContext> => {
 
 const mutationKey = ['emailListAddSubscription'];
 const {mutation: mutationOptions, request: requestOptions} = options ?
@@ -669,7 +696,7 @@ const {mutation: mutationOptions, request: requestOptions} = options ?
       
 
 
-      const mutationFn: MutationFunction<Awaited<ReturnType<typeof emailListAddSubscription>>, {emailListUid: string | null;data: EmailListAddSubscriptionBody}> = (props) => {
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof emailListAddSubscription>>, {emailListUid: string | null;data: NonReadonly<EmailListAddSubscriptionBody>}> = (props) => {
           const {emailListUid,data} = props ?? {};
 
           return  emailListAddSubscription(emailListUid,data,requestOptions)
@@ -681,18 +708,18 @@ const {mutation: mutationOptions, request: requestOptions} = options ?
   return  { mutationFn, ...mutationOptions }}
 
     export type EmailListAddSubscriptionMutationResult = NonNullable<Awaited<ReturnType<typeof emailListAddSubscription>>>
-    export type EmailListAddSubscriptionMutationBody = EmailListAddSubscriptionBody
+    export type EmailListAddSubscriptionMutationBody = NonReadonly<EmailListAddSubscriptionBody>
     export type EmailListAddSubscriptionMutationError = void
 
     /**
  * @summary Subscribe a person to an email list.
  */
 export const useEmailListAddSubscription = <TError = void,
-    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof emailListAddSubscription>>, TError,{emailListUid: string | null;data: EmailListAddSubscriptionBody}, TContext>, request?: SecondParameter<typeof customFetch>}
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof emailListAddSubscription>>, TError,{emailListUid: string | null;data: NonReadonly<EmailListAddSubscriptionBody>}, TContext>, request?: SecondParameter<typeof customFetch>}
  ): UseMutationResult<
         Awaited<ReturnType<typeof emailListAddSubscription>>,
         TError,
-        {emailListUid: string | null;data: EmailListAddSubscriptionBody},
+        {emailListUid: string | null;data: NonReadonly<EmailListAddSubscriptionBody>},
         TContext
       > => {
 

package/src/generated/outsetaAPI.schemas.ts

@@ -40,9 +40,9 @@ export interface AbstractBean {
   /** @nullable */
   _objectType?: string | null;
   /** @minLength 1 */
-  Created: string;
+  readonly Created: string;
   /** @minLength 1 */
-  Updated: string;
+  readonly Updated: string;
 }
 
 /**
@@ -2642,6 +2642,8 @@ export interface TokenPayload {
   /** @nullable */
   id_token?: string | null;
   /** @nullable */
+  refresh_token?: string | null;
+  /** @nullable */
   token_type?: string | null;
 }
 
@@ -3568,12 +3570,33 @@ export type SendGridDomainAuthenticationAllOf = {
    * @maxLength 250
    */
   DomainName: string;
+  /**
+   * @maxLength 100
+   * @nullable
+   */
+  SendGridSubuser?: string | null;
   IsValid?: boolean;
   IsBrandedLinksDisabled?: boolean;
+  IsLinkTrackingDnsValid?: boolean;
+  /**
+   * @maxLength 100
+   * @nullable
+   */
+  CloudflareCustomHostnameId?: string | null;
+  /**
+   * @maxLength 50
+   * @nullable
+   */
+  CloudflareSslStatus?: string | null;
+  /** @nullable */
+  CloudflareCustomHostnameCreatedAt?: string | null;
+  IsHttpsUpgradeAvailable?: boolean;
   /** @nullable */
   LastValidationAttempt?: string | null;
   /** @nullable */
   DnsEntries?: DnsEntry[] | null;
+  /** @nullable */
+  LegacyDnsEntries?: DnsEntry[] | null;
 };
 
 export type SendGridDomainAuthentication = AbstractQcountBean & SendGridDomainAuthenticationAllOf;
@@ -5845,6 +5868,13 @@ export type AuthVerifyTwoFactorRecoveryParams = {
 data: unknown | null;
 };
 
+export type AuthRefreshTokenParams = {
+/**
+ * @nullable
+ */
+data: unknown | null;
+};
+
 export type TokenTwoFactorEnrollmentBeginEmailParams = {
 /**
  * @nullable

package/src/generated/public/public.ts

@@ -10,6 +10,7 @@ import type {
 
 import type {
   AuthGetTokenParams,
+  AuthRefreshTokenParams,
   AuthResendTwoFactorParams,
   AuthSwitchTwoFactorMechanismParams,
   AuthVerifyTwoFactorRecoveryParams,
@@ -36,9 +37,9 @@ type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
             
     { "username": "user@example.com", "password": "their-password" }
             
-On success the response is `200` with an access token:
+On success the response is `200` with an access token and refresh token:
             
-    { "access_token": "eyJ...", "token_type": "Bearer", "expires_in": 31536000 }
+    { "access_token": "eyJ...", "refresh_token": "...", "token_type": "Bearer", "expires_in": 31536000 }
             
 **Two-factor authentication.** If the user has a verified 2FA method,
 the password alone is not enough. After verifying the password this
@@ -140,7 +141,7 @@ authenticator app):
 On success the response is `200` with the final access token, in the
 same shape as `POST /api/v1/tokens`:
             
-    { "access_token": "eyJ...", "token_type": "Bearer", "expires_in": 31536000 }
+    { "access_token": "eyJ...", "refresh_token": "...", "token_type": "Bearer", "expires_in": 31536000 }
             
 An incorrect code returns `400` (`invalid_grant`). A code has at most
 five attempts before the challenge locks. An expired challenge returns
@@ -439,6 +440,79 @@ export const useAuthVerifyTwoFactorRecovery = <TError = string,
       return useMutation(mutationOptions);
     }
     /**
+ * Post the refresh token returned from `POST /api/v1/tokens` or the
+two-factor completion endpoints:
+            
+    { "refresh_token": "..." }
+            
+On success the response is `200` with a new access token and refresh token:
+            
+    { "access_token": "eyJ...", "refresh_token": "...", "token_type": "Bearer", "expires_in": 31536000 }
+            
+An invalid or expired refresh token returns `400` with a body of `invalid_grant`.
+ * @summary Exchange a refresh token for a new access token.
+ */
+export const authRefreshToken = (
+    params: AuthRefreshTokenParams,
+ options?: SecondParameter<typeof customFetch>,signal?: AbortSignal
+) => {
+      
+      
+      return customFetch<TokenPayload>(
+      {url: `/api/v1/tokens/refresh-token`, method: 'POST',
+        params, signal
+    },
+      options);
+    }
+  
+
+
+export const getAuthRefreshTokenMutationOptions = <TError = string,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof authRefreshToken>>, TError,{params: AuthRefreshTokenParams}, TContext>, request?: SecondParameter<typeof customFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof authRefreshToken>>, TError,{params: AuthRefreshTokenParams}, TContext> => {
+
+const mutationKey = ['authRefreshToken'];
+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 authRefreshToken>>, {params: AuthRefreshTokenParams}> = (props) => {
+          const {params} = props ?? {};
+
+          return  authRefreshToken(params,requestOptions)
+        }
+
+        
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type AuthRefreshTokenMutationResult = NonNullable<Awaited<ReturnType<typeof authRefreshToken>>>
+    
+    export type AuthRefreshTokenMutationError = string
+
+    /**
+ * @summary Exchange a refresh token for a new access token.
+ */
+export const useAuthRefreshToken = <TError = string,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof authRefreshToken>>, TError,{params: AuthRefreshTokenParams}, TContext>, request?: SecondParameter<typeof customFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof authRefreshToken>>,
+        TError,
+        {params: AuthRefreshTokenParams},
+        TContext
+      > => {
+
+      const mutationOptions = getAuthRefreshTokenMutationOptions(options);
+
+      return useMutation(mutationOptions);
+    }
+    /**
  * Call this when `POST /api/v1/tokens` returned
 `two_factor_enrollment_required` and the user chooses email. Post the
 enrollment token from that response:

package/src/generated/support/support.ts

@@ -26,6 +26,33 @@ import type {
 
 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];
 
@@ -106,7 +133,7 @@ export function useCaseGetAllCases<TData = Awaited<ReturnType<typeof caseGetAllC
  * @summary Adds a case into the support system.
  */
 export const caseAddCase = (
-    caseAddCaseBody: CaseAddCaseBody,
+    caseAddCaseBody: NonReadonly<CaseAddCaseBody>,
     params?: CaseAddCaseParams,
  options?: SecondParameter<typeof customFetch>,signal?: AbortSignal
 ) => {
@@ -124,8 +151,8 @@ export const caseAddCase = (
 
 
 export const getCaseAddCaseMutationOptions = <TError = void,
-    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof caseAddCase>>, TError,{data: CaseAddCaseBody;params?: CaseAddCaseParams}, TContext>, request?: SecondParameter<typeof customFetch>}
-): UseMutationOptions<Awaited<ReturnType<typeof caseAddCase>>, TError,{data: CaseAddCaseBody;params?: CaseAddCaseParams}, TContext> => {
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof caseAddCase>>, TError,{data: NonReadonly<CaseAddCaseBody>;params?: CaseAddCaseParams}, TContext>, request?: SecondParameter<typeof customFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof caseAddCase>>, TError,{data: NonReadonly<CaseAddCaseBody>;params?: CaseAddCaseParams}, TContext> => {
 
 const mutationKey = ['caseAddCase'];
 const {mutation: mutationOptions, request: requestOptions} = options ?
@@ -137,7 +164,7 @@ const {mutation: mutationOptions, request: requestOptions} = options ?
       
 
 
-      const mutationFn: MutationFunction<Awaited<ReturnType<typeof caseAddCase>>, {data: CaseAddCaseBody;params?: CaseAddCaseParams}> = (props) => {
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof caseAddCase>>, {data: NonReadonly<CaseAddCaseBody>;params?: CaseAddCaseParams}> = (props) => {
           const {data,params} = props ?? {};
 
           return  caseAddCase(data,params,requestOptions)
@@ -149,18 +176,18 @@ const {mutation: mutationOptions, request: requestOptions} = options ?
   return  { mutationFn, ...mutationOptions }}
 
     export type CaseAddCaseMutationResult = NonNullable<Awaited<ReturnType<typeof caseAddCase>>>
-    export type CaseAddCaseMutationBody = CaseAddCaseBody
+    export type CaseAddCaseMutationBody = NonReadonly<CaseAddCaseBody>
     export type CaseAddCaseMutationError = void
 
     /**
  * @summary Adds a case into the support system.
  */
 export const useCaseAddCase = <TError = void,
-    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof caseAddCase>>, TError,{data: CaseAddCaseBody;params?: CaseAddCaseParams}, TContext>, request?: SecondParameter<typeof customFetch>}
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof caseAddCase>>, TError,{data: NonReadonly<CaseAddCaseBody>;params?: CaseAddCaseParams}, TContext>, request?: SecondParameter<typeof customFetch>}
  ): UseMutationResult<
         Awaited<ReturnType<typeof caseAddCase>>,
         TError,
-        {data: CaseAddCaseBody;params?: CaseAddCaseParams},
+        {data: NonReadonly<CaseAddCaseBody>;params?: CaseAddCaseParams},
         TContext
       > => {