@documenso/sdk-typescript 0.5.0 → 0.6.2

package/src/models/operations/envelopeuse.ts

@@ -8,9 +8,16 @@ import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
-export type EnvelopeUseRecipient = {
+export const EnvelopeUseEmailEnum = {
+  Unknown: "",
+} as const;
+export type EnvelopeUseEmailEnum = ClosedEnum<typeof EnvelopeUseEmailEnum>;
+
+export type EnvelopeUseEmailUnion = EnvelopeUseEmailEnum | string;
+
+export type EnvelopeUsePayloadRecipient = {
   id: number;
-  email: string;
+  email: EnvelopeUseEmailEnum | string;
   name?: string | undefined;
   signingOrder?: number | undefined;
 };
@@ -22,77 +29,43 @@ export type EnvelopeUseCustomDocumentDatum = {
   envelopeItemId: string;
 };
 
-export const EnvelopeUseTypeDate = {
-  Date: "date",
-} as const;
-export type EnvelopeUseTypeDate = ClosedEnum<typeof EnvelopeUseTypeDate>;
-
 export type EnvelopeUsePrefillFieldDate = {
-  type: EnvelopeUseTypeDate;
+  type: "date";
   value?: string | undefined;
   id: number;
 };
 
-export const EnvelopeUseTypeDropdown = {
-  Dropdown: "dropdown",
-} as const;
-export type EnvelopeUseTypeDropdown = ClosedEnum<
-  typeof EnvelopeUseTypeDropdown
->;
-
 export type EnvelopeUsePrefillFieldDropdown = {
-  type: EnvelopeUseTypeDropdown;
+  type: "dropdown";
   label?: string | undefined;
   value?: string | undefined;
   id: number;
 };
 
-export const EnvelopeUseTypeCheckbox = {
-  Checkbox: "checkbox",
-} as const;
-export type EnvelopeUseTypeCheckbox = ClosedEnum<
-  typeof EnvelopeUseTypeCheckbox
->;
-
 export type EnvelopeUsePrefillFieldCheckbox = {
-  type: EnvelopeUseTypeCheckbox;
+  type: "checkbox";
   label?: string | undefined;
   value?: Array<string> | undefined;
   id: number;
 };
 
-export const EnvelopeUseTypeRadio = {
-  Radio: "radio",
-} as const;
-export type EnvelopeUseTypeRadio = ClosedEnum<typeof EnvelopeUseTypeRadio>;
-
 export type EnvelopeUsePrefillFieldRadio = {
-  type: EnvelopeUseTypeRadio;
+  type: "radio";
   label?: string | undefined;
   value?: string | undefined;
   id: number;
 };
 
-export const EnvelopeUseTypeNumber = {
-  Number: "number",
-} as const;
-export type EnvelopeUseTypeNumber = ClosedEnum<typeof EnvelopeUseTypeNumber>;
-
 export type EnvelopeUsePrefillFieldNumber = {
-  type: EnvelopeUseTypeNumber;
+  type: "number";
   label?: string | undefined;
   placeholder?: string | undefined;
   value?: string | undefined;
   id: number;
 };
 
-export const EnvelopeUseTypeText = {
-  Text: "text",
-} as const;
-export type EnvelopeUseTypeText = ClosedEnum<typeof EnvelopeUseTypeText>;
-
 export type EnvelopeUsePrefillFieldText = {
-  type: EnvelopeUseTypeText;
+  type: "text";
   label?: string | undefined;
   placeholder?: string | undefined;
   value?: string | undefined;
@@ -157,11 +130,16 @@ export const EnvelopeUseLanguage = {
   Fr: "fr",
   Es: "es",
   It: "it",
+  Nl: "nl",
   Pl: "pl",
+  PtBR: "pt-BR",
+  Ja: "ja",
+  Ko: "ko",
+  Zh: "zh",
 } as const;
 export type EnvelopeUseLanguage = ClosedEnum<typeof EnvelopeUseLanguage>;
 
-export type Override = {
+export type EnvelopeUseOverride = {
   title?: string | undefined;
   subject?: string | undefined;
   message?: string | undefined;
@@ -188,10 +166,12 @@ export type EnvelopeUseAttachment = {
   type?: EnvelopeUseTypeLink | undefined;
 };
 
+export type EnvelopeUseFormValues = string | boolean | number;
+
 export type EnvelopeUsePayload = {
   envelopeId: string;
   externalId?: string | undefined;
-  recipients: Array<EnvelopeUseRecipient>;
+  recipients?: Array<EnvelopeUsePayloadRecipient> | undefined;
   distributeDocument?: boolean | undefined;
   customDocumentData?: Array<EnvelopeUseCustomDocumentDatum> | undefined;
   folderId?: string | undefined;
@@ -205,8 +185,9 @@ export type EnvelopeUsePayload = {
       | EnvelopeUsePrefillFieldDate
     >
     | undefined;
-  override?: Override | undefined;
+  override?: EnvelopeUseOverride | undefined;
   attachments?: Array<EnvelopeUseAttachment> | undefined;
+  formValues?: { [k: string]: string | boolean | number } | undefined;
 };
 
 export type EnvelopeUseFile = {
@@ -219,58 +200,122 @@ export type EnvelopeUseRequest = {
   files?: Array<EnvelopeUseFile> | undefined;
 };
 
+export const EnvelopeUseRole = {
+  Cc: "CC",
+  Signer: "SIGNER",
+  Viewer: "VIEWER",
+  Approver: "APPROVER",
+  Assistant: "ASSISTANT",
+} as const;
+export type EnvelopeUseRole = ClosedEnum<typeof EnvelopeUseRole>;
+
+export type EnvelopeUseRecipientResponse = {
+  id: number;
+  name: string;
+  email: string;
+  token: string;
+  role: EnvelopeUseRole;
+  signingOrder: number | null;
+  signingUrl: string;
+};
+
 /**
  * Successful response
  */
 export type EnvelopeUseResponse = {
   id: string;
+  recipients: Array<EnvelopeUseRecipientResponse>;
 };
 
 /** @internal */
-export const EnvelopeUseRecipient$inboundSchema: z.ZodType<
-  EnvelopeUseRecipient,
+export const EnvelopeUseEmailEnum$inboundSchema: z.ZodNativeEnum<
+  typeof EnvelopeUseEmailEnum
+> = z.nativeEnum(EnvelopeUseEmailEnum);
+/** @internal */
+export const EnvelopeUseEmailEnum$outboundSchema: z.ZodNativeEnum<
+  typeof EnvelopeUseEmailEnum
+> = EnvelopeUseEmailEnum$inboundSchema;
+
+/** @internal */
+export const EnvelopeUseEmailUnion$inboundSchema: z.ZodType<
+  EnvelopeUseEmailUnion,
+  z.ZodTypeDef,
+  unknown
+> = z.union([EnvelopeUseEmailEnum$inboundSchema, z.string()]);
+/** @internal */
+export type EnvelopeUseEmailUnion$Outbound = string | string;
+
+/** @internal */
+export const EnvelopeUseEmailUnion$outboundSchema: z.ZodType<
+  EnvelopeUseEmailUnion$Outbound,
+  z.ZodTypeDef,
+  EnvelopeUseEmailUnion
+> = z.union([EnvelopeUseEmailEnum$outboundSchema, z.string()]);
+
+export function envelopeUseEmailUnionToJSON(
+  envelopeUseEmailUnion: EnvelopeUseEmailUnion,
+): string {
+  return JSON.stringify(
+    EnvelopeUseEmailUnion$outboundSchema.parse(envelopeUseEmailUnion),
+  );
+}
+export function envelopeUseEmailUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<EnvelopeUseEmailUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EnvelopeUseEmailUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EnvelopeUseEmailUnion' from JSON`,
+  );
+}
+
+/** @internal */
+export const EnvelopeUsePayloadRecipient$inboundSchema: z.ZodType<
+  EnvelopeUsePayloadRecipient,
   z.ZodTypeDef,
   unknown
 > = z.object({
   id: z.number(),
-  email: z.string(),
+  email: z.union([EnvelopeUseEmailEnum$inboundSchema, z.string()]),
   name: z.string().optional(),
   signingOrder: z.number().optional(),
 });
 /** @internal */
-export type EnvelopeUseRecipient$Outbound = {
+export type EnvelopeUsePayloadRecipient$Outbound = {
   id: number;
-  email: string;
+  email: string | string;
   name?: string | undefined;
   signingOrder?: number | undefined;
 };
 
 /** @internal */
-export const EnvelopeUseRecipient$outboundSchema: z.ZodType<
-  EnvelopeUseRecipient$Outbound,
+export const EnvelopeUsePayloadRecipient$outboundSchema: z.ZodType<
+  EnvelopeUsePayloadRecipient$Outbound,
   z.ZodTypeDef,
-  EnvelopeUseRecipient
+  EnvelopeUsePayloadRecipient
 > = z.object({
   id: z.number(),
-  email: z.string(),
+  email: z.union([EnvelopeUseEmailEnum$outboundSchema, z.string()]),
   name: z.string().optional(),
   signingOrder: z.number().optional(),
 });
 
-export function envelopeUseRecipientToJSON(
-  envelopeUseRecipient: EnvelopeUseRecipient,
+export function envelopeUsePayloadRecipientToJSON(
+  envelopeUsePayloadRecipient: EnvelopeUsePayloadRecipient,
 ): string {
   return JSON.stringify(
-    EnvelopeUseRecipient$outboundSchema.parse(envelopeUseRecipient),
+    EnvelopeUsePayloadRecipient$outboundSchema.parse(
+      envelopeUsePayloadRecipient,
+    ),
   );
 }
-export function envelopeUseRecipientFromJSON(
+export function envelopeUsePayloadRecipientFromJSON(
   jsonString: string,
-): SafeParseResult<EnvelopeUseRecipient, SDKValidationError> {
+): SafeParseResult<EnvelopeUsePayloadRecipient, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => EnvelopeUseRecipient$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'EnvelopeUseRecipient' from JSON`,
+    (x) => EnvelopeUsePayloadRecipient$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EnvelopeUsePayloadRecipient' from JSON`,
   );
 }
 
@@ -351,28 +396,19 @@ export function envelopeUseCustomDocumentDatumFromJSON(
   );
 }
 
-/** @internal */
-export const EnvelopeUseTypeDate$inboundSchema: z.ZodNativeEnum<
-  typeof EnvelopeUseTypeDate
-> = z.nativeEnum(EnvelopeUseTypeDate);
-/** @internal */
-export const EnvelopeUseTypeDate$outboundSchema: z.ZodNativeEnum<
-  typeof EnvelopeUseTypeDate
-> = EnvelopeUseTypeDate$inboundSchema;
-
 /** @internal */
 export const EnvelopeUsePrefillFieldDate$inboundSchema: z.ZodType<
   EnvelopeUsePrefillFieldDate,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  type: EnvelopeUseTypeDate$inboundSchema,
+  type: z.literal("date"),
   value: z.string().optional(),
   id: z.number(),
 });
 /** @internal */
 export type EnvelopeUsePrefillFieldDate$Outbound = {
-  type: string;
+  type: "date";
   value?: string | undefined;
   id: number;
 };
@@ -383,7 +419,7 @@ export const EnvelopeUsePrefillFieldDate$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   EnvelopeUsePrefillFieldDate
 > = z.object({
-  type: EnvelopeUseTypeDate$outboundSchema,
+  type: z.literal("date"),
   value: z.string().optional(),
   id: z.number(),
 });
@@ -407,29 +443,20 @@ export function envelopeUsePrefillFieldDateFromJSON(
   );
 }
 
-/** @internal */
-export const EnvelopeUseTypeDropdown$inboundSchema: z.ZodNativeEnum<
-  typeof EnvelopeUseTypeDropdown
-> = z.nativeEnum(EnvelopeUseTypeDropdown);
-/** @internal */
-export const EnvelopeUseTypeDropdown$outboundSchema: z.ZodNativeEnum<
-  typeof EnvelopeUseTypeDropdown
-> = EnvelopeUseTypeDropdown$inboundSchema;
-
 /** @internal */
 export const EnvelopeUsePrefillFieldDropdown$inboundSchema: z.ZodType<
   EnvelopeUsePrefillFieldDropdown,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  type: EnvelopeUseTypeDropdown$inboundSchema,
+  type: z.literal("dropdown"),
   label: z.string().optional(),
   value: z.string().optional(),
   id: z.number(),
 });
 /** @internal */
 export type EnvelopeUsePrefillFieldDropdown$Outbound = {
-  type: string;
+  type: "dropdown";
   label?: string | undefined;
   value?: string | undefined;
   id: number;
@@ -441,7 +468,7 @@ export const EnvelopeUsePrefillFieldDropdown$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   EnvelopeUsePrefillFieldDropdown
 > = z.object({
-  type: EnvelopeUseTypeDropdown$outboundSchema,
+  type: z.literal("dropdown"),
   label: z.string().optional(),
   value: z.string().optional(),
   id: z.number(),
@@ -466,29 +493,20 @@ export function envelopeUsePrefillFieldDropdownFromJSON(
   );
 }
 
-/** @internal */
-export const EnvelopeUseTypeCheckbox$inboundSchema: z.ZodNativeEnum<
-  typeof EnvelopeUseTypeCheckbox
-> = z.nativeEnum(EnvelopeUseTypeCheckbox);
-/** @internal */
-export const EnvelopeUseTypeCheckbox$outboundSchema: z.ZodNativeEnum<
-  typeof EnvelopeUseTypeCheckbox
-> = EnvelopeUseTypeCheckbox$inboundSchema;
-
 /** @internal */
 export const EnvelopeUsePrefillFieldCheckbox$inboundSchema: z.ZodType<
   EnvelopeUsePrefillFieldCheckbox,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  type: EnvelopeUseTypeCheckbox$inboundSchema,
+  type: z.literal("checkbox"),
   label: z.string().optional(),
   value: z.array(z.string()).optional(),
   id: z.number(),
 });
 /** @internal */
 export type EnvelopeUsePrefillFieldCheckbox$Outbound = {
-  type: string;
+  type: "checkbox";
   label?: string | undefined;
   value?: Array<string> | undefined;
   id: number;
@@ -500,7 +518,7 @@ export const EnvelopeUsePrefillFieldCheckbox$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   EnvelopeUsePrefillFieldCheckbox
 > = z.object({
-  type: EnvelopeUseTypeCheckbox$outboundSchema,
+  type: z.literal("checkbox"),
   label: z.string().optional(),
   value: z.array(z.string()).optional(),
   id: z.number(),
@@ -525,29 +543,20 @@ export function envelopeUsePrefillFieldCheckboxFromJSON(
   );
 }
 
-/** @internal */
-export const EnvelopeUseTypeRadio$inboundSchema: z.ZodNativeEnum<
-  typeof EnvelopeUseTypeRadio
-> = z.nativeEnum(EnvelopeUseTypeRadio);
-/** @internal */
-export const EnvelopeUseTypeRadio$outboundSchema: z.ZodNativeEnum<
-  typeof EnvelopeUseTypeRadio
-> = EnvelopeUseTypeRadio$inboundSchema;
-
 /** @internal */
 export const EnvelopeUsePrefillFieldRadio$inboundSchema: z.ZodType<
   EnvelopeUsePrefillFieldRadio,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  type: EnvelopeUseTypeRadio$inboundSchema,
+  type: z.literal("radio"),
   label: z.string().optional(),
   value: z.string().optional(),
   id: z.number(),
 });
 /** @internal */
 export type EnvelopeUsePrefillFieldRadio$Outbound = {
-  type: string;
+  type: "radio";
   label?: string | undefined;
   value?: string | undefined;
   id: number;
@@ -559,7 +568,7 @@ export const EnvelopeUsePrefillFieldRadio$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   EnvelopeUsePrefillFieldRadio
 > = z.object({
-  type: EnvelopeUseTypeRadio$outboundSchema,
+  type: z.literal("radio"),
   label: z.string().optional(),
   value: z.string().optional(),
   id: z.number(),
@@ -584,22 +593,13 @@ export function envelopeUsePrefillFieldRadioFromJSON(
   );
 }
 
-/** @internal */
-export const EnvelopeUseTypeNumber$inboundSchema: z.ZodNativeEnum<
-  typeof EnvelopeUseTypeNumber
-> = z.nativeEnum(EnvelopeUseTypeNumber);
-/** @internal */
-export const EnvelopeUseTypeNumber$outboundSchema: z.ZodNativeEnum<
-  typeof EnvelopeUseTypeNumber
-> = EnvelopeUseTypeNumber$inboundSchema;
-
 /** @internal */
 export const EnvelopeUsePrefillFieldNumber$inboundSchema: z.ZodType<
   EnvelopeUsePrefillFieldNumber,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  type: EnvelopeUseTypeNumber$inboundSchema,
+  type: z.literal("number"),
   label: z.string().optional(),
   placeholder: z.string().optional(),
   value: z.string().optional(),
@@ -607,7 +607,7 @@ export const EnvelopeUsePrefillFieldNumber$inboundSchema: z.ZodType<
 });
 /** @internal */
 export type EnvelopeUsePrefillFieldNumber$Outbound = {
-  type: string;
+  type: "number";
   label?: string | undefined;
   placeholder?: string | undefined;
   value?: string | undefined;
@@ -620,7 +620,7 @@ export const EnvelopeUsePrefillFieldNumber$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   EnvelopeUsePrefillFieldNumber
 > = z.object({
-  type: EnvelopeUseTypeNumber$outboundSchema,
+  type: z.literal("number"),
   label: z.string().optional(),
   placeholder: z.string().optional(),
   value: z.string().optional(),
@@ -646,22 +646,13 @@ export function envelopeUsePrefillFieldNumberFromJSON(
   );
 }
 
-/** @internal */
-export const EnvelopeUseTypeText$inboundSchema: z.ZodNativeEnum<
-  typeof EnvelopeUseTypeText
-> = z.nativeEnum(EnvelopeUseTypeText);
-/** @internal */
-export const EnvelopeUseTypeText$outboundSchema: z.ZodNativeEnum<
-  typeof EnvelopeUseTypeText
-> = EnvelopeUseTypeText$inboundSchema;
-
 /** @internal */
 export const EnvelopeUsePrefillFieldText$inboundSchema: z.ZodType<
   EnvelopeUsePrefillFieldText,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  type: EnvelopeUseTypeText$inboundSchema,
+  type: z.literal("text"),
   label: z.string().optional(),
   placeholder: z.string().optional(),
   value: z.string().optional(),
@@ -669,7 +660,7 @@ export const EnvelopeUsePrefillFieldText$inboundSchema: z.ZodType<
 });
 /** @internal */
 export type EnvelopeUsePrefillFieldText$Outbound = {
-  type: string;
+  type: "text";
   label?: string | undefined;
   placeholder?: string | undefined;
   value?: string | undefined;
@@ -682,7 +673,7 @@ export const EnvelopeUsePrefillFieldText$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   EnvelopeUsePrefillFieldText
 > = z.object({
-  type: EnvelopeUseTypeText$outboundSchema,
+  type: z.literal("text"),
   label: z.string().optional(),
   placeholder: z.string().optional(),
   value: z.string().optional(),
@@ -848,8 +839,8 @@ export const EnvelopeUseLanguage$outboundSchema: z.ZodNativeEnum<
 > = EnvelopeUseLanguage$inboundSchema;
 
 /** @internal */
-export const Override$inboundSchema: z.ZodType<
-  Override,
+export const EnvelopeUseOverride$inboundSchema: z.ZodType<
+  EnvelopeUseOverride,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -869,7 +860,7 @@ export const Override$inboundSchema: z.ZodType<
   allowDictateNextSigner: z.boolean().optional(),
 });
 /** @internal */
-export type Override$Outbound = {
+export type EnvelopeUseOverride$Outbound = {
   title?: string | undefined;
   subject?: string | undefined;
   message?: string | undefined;
@@ -886,10 +877,10 @@ export type Override$Outbound = {
 };
 
 /** @internal */
-export const Override$outboundSchema: z.ZodType<
-  Override$Outbound,
+export const EnvelopeUseOverride$outboundSchema: z.ZodType<
+  EnvelopeUseOverride$Outbound,
   z.ZodTypeDef,
-  Override
+  EnvelopeUseOverride
 > = z.object({
   title: z.string().optional(),
   subject: z.string().optional(),
@@ -907,16 +898,20 @@ export const Override$outboundSchema: z.ZodType<
   allowDictateNextSigner: z.boolean().optional(),
 });
 
-export function overrideToJSON(override: Override): string {
-  return JSON.stringify(Override$outboundSchema.parse(override));
+export function envelopeUseOverrideToJSON(
+  envelopeUseOverride: EnvelopeUseOverride,
+): string {
+  return JSON.stringify(
+    EnvelopeUseOverride$outboundSchema.parse(envelopeUseOverride),
+  );
 }
-export function overrideFromJSON(
+export function envelopeUseOverrideFromJSON(
   jsonString: string,
-): SafeParseResult<Override, SDKValidationError> {
+): SafeParseResult<EnvelopeUseOverride, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => Override$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Override' from JSON`,
+    (x) => EnvelopeUseOverride$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EnvelopeUseOverride' from JSON`,
   );
 }
 
@@ -974,6 +969,39 @@ export function envelopeUseAttachmentFromJSON(
   );
 }
 
+/** @internal */
+export const EnvelopeUseFormValues$inboundSchema: z.ZodType<
+  EnvelopeUseFormValues,
+  z.ZodTypeDef,
+  unknown
+> = z.union([z.string(), z.boolean(), z.number()]);
+/** @internal */
+export type EnvelopeUseFormValues$Outbound = string | boolean | number;
+
+/** @internal */
+export const EnvelopeUseFormValues$outboundSchema: z.ZodType<
+  EnvelopeUseFormValues$Outbound,
+  z.ZodTypeDef,
+  EnvelopeUseFormValues
+> = z.union([z.string(), z.boolean(), z.number()]);
+
+export function envelopeUseFormValuesToJSON(
+  envelopeUseFormValues: EnvelopeUseFormValues,
+): string {
+  return JSON.stringify(
+    EnvelopeUseFormValues$outboundSchema.parse(envelopeUseFormValues),
+  );
+}
+export function envelopeUseFormValuesFromJSON(
+  jsonString: string,
+): SafeParseResult<EnvelopeUseFormValues, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EnvelopeUseFormValues$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EnvelopeUseFormValues' from JSON`,
+  );
+}
+
 /** @internal */
 export const EnvelopeUsePayload$inboundSchema: z.ZodType<
   EnvelopeUsePayload,
@@ -982,7 +1010,8 @@ export const EnvelopeUsePayload$inboundSchema: z.ZodType<
 > = z.object({
   envelopeId: z.string(),
   externalId: z.string().optional(),
-  recipients: z.array(z.lazy(() => EnvelopeUseRecipient$inboundSchema)),
+  recipients: z.array(z.lazy(() => EnvelopeUsePayloadRecipient$inboundSchema))
+    .optional(),
   distributeDocument: z.boolean().optional(),
   customDocumentData: z.array(
     z.lazy(() => EnvelopeUseCustomDocumentDatum$inboundSchema),
@@ -998,15 +1027,17 @@ export const EnvelopeUsePayload$inboundSchema: z.ZodType<
       z.lazy(() => EnvelopeUsePrefillFieldDate$inboundSchema),
     ]),
   ).optional(),
-  override: z.lazy(() => Override$inboundSchema).optional(),
+  override: z.lazy(() => EnvelopeUseOverride$inboundSchema).optional(),
   attachments: z.array(z.lazy(() => EnvelopeUseAttachment$inboundSchema))
     .optional(),
+  formValues: z.record(z.union([z.string(), z.boolean(), z.number()]))
+    .optional(),
 });
 /** @internal */
 export type EnvelopeUsePayload$Outbound = {
   envelopeId: string;
   externalId?: string | undefined;
-  recipients: Array<EnvelopeUseRecipient$Outbound>;
+  recipients?: Array<EnvelopeUsePayloadRecipient$Outbound> | undefined;
   distributeDocument?: boolean | undefined;
   customDocumentData?:
     | Array<EnvelopeUseCustomDocumentDatum$Outbound>
@@ -1022,8 +1053,9 @@ export type EnvelopeUsePayload$Outbound = {
       | EnvelopeUsePrefillFieldDate$Outbound
     >
     | undefined;
-  override?: Override$Outbound | undefined;
+  override?: EnvelopeUseOverride$Outbound | undefined;
   attachments?: Array<EnvelopeUseAttachment$Outbound> | undefined;
+  formValues?: { [k: string]: string | boolean | number } | undefined;
 };
 
 /** @internal */
@@ -1034,7 +1066,8 @@ export const EnvelopeUsePayload$outboundSchema: z.ZodType<
 > = z.object({
   envelopeId: z.string(),
   externalId: z.string().optional(),
-  recipients: z.array(z.lazy(() => EnvelopeUseRecipient$outboundSchema)),
+  recipients: z.array(z.lazy(() => EnvelopeUsePayloadRecipient$outboundSchema))
+    .optional(),
   distributeDocument: z.boolean().optional(),
   customDocumentData: z.array(
     z.lazy(() => EnvelopeUseCustomDocumentDatum$outboundSchema),
@@ -1050,9 +1083,11 @@ export const EnvelopeUsePayload$outboundSchema: z.ZodType<
       z.lazy(() => EnvelopeUsePrefillFieldDate$outboundSchema),
     ]),
   ).optional(),
-  override: z.lazy(() => Override$outboundSchema).optional(),
+  override: z.lazy(() => EnvelopeUseOverride$outboundSchema).optional(),
   attachments: z.array(z.lazy(() => EnvelopeUseAttachment$outboundSchema))
     .optional(),
+  formValues: z.record(z.union([z.string(), z.boolean(), z.number()]))
+    .optional(),
 });
 
 export function envelopeUsePayloadToJSON(
@@ -1164,6 +1199,74 @@ export function envelopeUseRequestFromJSON(
   );
 }
 
+/** @internal */
+export const EnvelopeUseRole$inboundSchema: z.ZodNativeEnum<
+  typeof EnvelopeUseRole
+> = z.nativeEnum(EnvelopeUseRole);
+/** @internal */
+export const EnvelopeUseRole$outboundSchema: z.ZodNativeEnum<
+  typeof EnvelopeUseRole
+> = EnvelopeUseRole$inboundSchema;
+
+/** @internal */
+export const EnvelopeUseRecipientResponse$inboundSchema: z.ZodType<
+  EnvelopeUseRecipientResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.number(),
+  name: z.string(),
+  email: z.string(),
+  token: z.string(),
+  role: EnvelopeUseRole$inboundSchema,
+  signingOrder: z.nullable(z.number()),
+  signingUrl: z.string(),
+});
+/** @internal */
+export type EnvelopeUseRecipientResponse$Outbound = {
+  id: number;
+  name: string;
+  email: string;
+  token: string;
+  role: string;
+  signingOrder: number | null;
+  signingUrl: string;
+};
+
+/** @internal */
+export const EnvelopeUseRecipientResponse$outboundSchema: z.ZodType<
+  EnvelopeUseRecipientResponse$Outbound,
+  z.ZodTypeDef,
+  EnvelopeUseRecipientResponse
+> = z.object({
+  id: z.number(),
+  name: z.string(),
+  email: z.string(),
+  token: z.string(),
+  role: EnvelopeUseRole$outboundSchema,
+  signingOrder: z.nullable(z.number()),
+  signingUrl: z.string(),
+});
+
+export function envelopeUseRecipientResponseToJSON(
+  envelopeUseRecipientResponse: EnvelopeUseRecipientResponse,
+): string {
+  return JSON.stringify(
+    EnvelopeUseRecipientResponse$outboundSchema.parse(
+      envelopeUseRecipientResponse,
+    ),
+  );
+}
+export function envelopeUseRecipientResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<EnvelopeUseRecipientResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EnvelopeUseRecipientResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EnvelopeUseRecipientResponse' from JSON`,
+  );
+}
+
 /** @internal */
 export const EnvelopeUseResponse$inboundSchema: z.ZodType<
   EnvelopeUseResponse,
@@ -1171,10 +1274,12 @@ export const EnvelopeUseResponse$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string(),
+  recipients: z.array(z.lazy(() => EnvelopeUseRecipientResponse$inboundSchema)),
 });
 /** @internal */
 export type EnvelopeUseResponse$Outbound = {
   id: string;
+  recipients: Array<EnvelopeUseRecipientResponse$Outbound>;
 };
 
 /** @internal */
@@ -1184,6 +1289,9 @@ export const EnvelopeUseResponse$outboundSchema: z.ZodType<
   EnvelopeUseResponse
 > = z.object({
   id: z.string(),
+  recipients: z.array(
+    z.lazy(() => EnvelopeUseRecipientResponse$outboundSchema),
+  ),
 });
 
 export function envelopeUseResponseToJSON(