@documenso/sdk-typescript 0.7.0 → 0.8.1

package/src/models/operations/templatecreatedocumentfromtemplate.ts

@@ -85,12 +85,15 @@ export const TemplateCreateDocumentFromTemplateDateFormat = {
   YyyyMMddHhMmA: "yyyy-MM-dd hh:mm a",
   YyyyMMdd: "yyyy-MM-dd",
   DdMMSlashYyyy: "dd/MM/yyyy",
+  DdMMDashYyyy: "dd-MM-yyyy",
   MmDdSlashYyyy: "MM/dd/yyyy",
   YyMMdd: "yy-MM-dd",
   MmmmDdCommaYyyy: "MMMM dd, yyyy",
   EeeeMmmmDdCommaYyyy: "EEEE, MMMM dd, yyyy",
   DdMMSlashYyyyHhMMA: "dd/MM/yyyy hh:mm a",
   DdMMSlashYyyyHHmm: "dd/MM/yyyy HH:mm",
+  DdMMDashYyyyHhMMA: "dd-MM-yyyy hh:mm a",
+  DdMMDashYyyyHHmm: "dd-MM-yyyy HH:mm",
   MmDdSlashYyyyHhMmA: "MM/dd/yyyy hh:mm a",
   MmDdSlashYyyyHHmm: "MM/dd/yyyy HH:mm",
   DdDotMmDotYyyy: "dd.MM.yyyy",
@@ -126,6 +129,8 @@ export type TemplateCreateDocumentFromTemplateOverrideEmailSettings = {
   documentCompleted?: boolean | undefined;
   documentDeleted?: boolean | undefined;
   ownerDocumentCompleted?: boolean | undefined;
+  ownerRecipientExpired?: boolean | undefined;
+  ownerDocumentCreated?: boolean | undefined;
 };
 
 export const TemplateCreateDocumentFromTemplateLanguage = {
@@ -145,6 +150,31 @@ export type TemplateCreateDocumentFromTemplateLanguage = ClosedEnum<
   typeof TemplateCreateDocumentFromTemplateLanguage
 >;
 
+export type TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride2 =
+  {
+    disabled: true;
+  };
+
+export const TemplateCreateDocumentFromTemplateOverrideUnit = {
+  Day: "day",
+  Week: "week",
+  Month: "month",
+  Year: "year",
+} as const;
+export type TemplateCreateDocumentFromTemplateOverrideUnit = ClosedEnum<
+  typeof TemplateCreateDocumentFromTemplateOverrideUnit
+>;
+
+export type TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride1 =
+  {
+    unit: TemplateCreateDocumentFromTemplateOverrideUnit;
+    amount: number;
+  };
+
+export type TemplateCreateDocumentFromTemplateOverrideEnvelopeExpirationPeriodUnion =
+  | TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride1
+  | TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride2;
+
 export type TemplateCreateDocumentFromTemplateOverride = {
   title?: string | undefined;
   subject?: string | undefined;
@@ -163,6 +193,11 @@ export type TemplateCreateDocumentFromTemplateOverride = {
   uploadSignatureEnabled?: boolean | undefined;
   drawSignatureEnabled?: boolean | undefined;
   allowDictateNextSigner?: boolean | undefined;
+  envelopeExpirationPeriod?:
+    | TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride1
+    | TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride2
+    | null
+    | undefined;
 };
 
 export const TemplateCreateDocumentFromTemplateTypeLink = {
@@ -307,6 +342,89 @@ export type TemplateCreateDocumentFromTemplateDocumentMetaEmailSettings = {
   documentCompleted?: boolean | undefined;
   documentDeleted?: boolean | undefined;
   ownerDocumentCompleted?: boolean | undefined;
+  ownerRecipientExpired?: boolean | undefined;
+  ownerDocumentCreated?: boolean | undefined;
+};
+
+export type TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse2 =
+  {
+    disabled: true;
+  };
+
+export const TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodUnitResponse =
+  {
+    Day: "day",
+    Week: "week",
+    Month: "month",
+    Year: "year",
+  } as const;
+export type TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodUnitResponse =
+  ClosedEnum<
+    typeof TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodUnitResponse
+  >;
+
+export type TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse1 =
+  {
+    unit:
+      TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodUnitResponse;
+    amount: number;
+  };
+
+export type TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponseUnion =
+  | TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse1
+  | TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse2;
+
+export type TemplateCreateDocumentFromTemplateSendAfter2 = {
+  disabled: true;
+};
+
+export const TemplateCreateDocumentFromTemplateSendAfterUnit = {
+  Day: "day",
+  Week: "week",
+  Month: "month",
+} as const;
+export type TemplateCreateDocumentFromTemplateSendAfterUnit = ClosedEnum<
+  typeof TemplateCreateDocumentFromTemplateSendAfterUnit
+>;
+
+export type TemplateCreateDocumentFromTemplateSendAfter1 = {
+  unit: TemplateCreateDocumentFromTemplateSendAfterUnit;
+  amount: number;
+};
+
+export type TemplateCreateDocumentFromTemplateSendAfterUnion =
+  | TemplateCreateDocumentFromTemplateSendAfter1
+  | TemplateCreateDocumentFromTemplateSendAfter2;
+
+export type TemplateCreateDocumentFromTemplateRepeatEvery2 = {
+  disabled: true;
+};
+
+export const TemplateCreateDocumentFromTemplateRepeatEveryUnit = {
+  Day: "day",
+  Week: "week",
+  Month: "month",
+} as const;
+export type TemplateCreateDocumentFromTemplateRepeatEveryUnit = ClosedEnum<
+  typeof TemplateCreateDocumentFromTemplateRepeatEveryUnit
+>;
+
+export type TemplateCreateDocumentFromTemplateRepeatEvery1 = {
+  unit: TemplateCreateDocumentFromTemplateRepeatEveryUnit;
+  amount: number;
+};
+
+export type TemplateCreateDocumentFromTemplateRepeatEveryUnion =
+  | TemplateCreateDocumentFromTemplateRepeatEvery1
+  | TemplateCreateDocumentFromTemplateRepeatEvery2;
+
+export type TemplateCreateDocumentFromTemplateReminderSettings = {
+  sendAfter:
+    | TemplateCreateDocumentFromTemplateSendAfter1
+    | TemplateCreateDocumentFromTemplateSendAfter2;
+  repeatEvery:
+    | TemplateCreateDocumentFromTemplateRepeatEvery1
+    | TemplateCreateDocumentFromTemplateRepeatEvery2;
 };
 
 export type TemplateCreateDocumentFromTemplateDocumentMeta = {
@@ -329,6 +447,11 @@ export type TemplateCreateDocumentFromTemplateDocumentMeta = {
     | null;
   emailId: string | null;
   emailReplyTo: string | null;
+  envelopeExpirationPeriod:
+    | TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse1
+    | TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse2
+    | null;
+  reminderSettings: TemplateCreateDocumentFromTemplateReminderSettings | null;
   password?: string | null | undefined;
   documentId?: number | undefined;
 };
@@ -440,6 +563,8 @@ export type TemplateCreateDocumentFromTemplateRecipientResponse = {
   token: string;
   documentDeletedAt: string | null;
   expired: string | null;
+  expiresAt: string | null;
+  expirationNotifiedAt: string | null;
   signedAt: string | null;
   authOptions: TemplateCreateDocumentFromTemplateRecipientAuthOptions | null;
   signingOrder: number | null;
@@ -465,6 +590,16 @@ export type TemplateCreateDocumentFromTemplateFieldTypeEnum = ClosedEnum<
   typeof TemplateCreateDocumentFromTemplateFieldTypeEnum
 >;
 
+export const TemplateCreateDocumentFromTemplateOverflow10 = {
+  Auto: "auto",
+  Horizontal: "horizontal",
+  Vertical: "vertical",
+  Crop: "crop",
+} as const;
+export type TemplateCreateDocumentFromTemplateOverflow10 = ClosedEnum<
+  typeof TemplateCreateDocumentFromTemplateOverflow10
+>;
+
 export type TemplateCreateDocumentFromTemplateValue3 = {
   value: string;
 };
@@ -475,11 +610,22 @@ export type TemplateCreateDocumentFromTemplateFieldMetaDropdown = {
   required?: boolean | undefined;
   readOnly?: boolean | undefined;
   fontSize?: number | undefined;
+  overflow?: TemplateCreateDocumentFromTemplateOverflow10 | undefined;
   type: "dropdown";
   values?: Array<TemplateCreateDocumentFromTemplateValue3> | undefined;
   defaultValue?: string | undefined;
 };
 
+export const TemplateCreateDocumentFromTemplateOverflow9 = {
+  Auto: "auto",
+  Horizontal: "horizontal",
+  Vertical: "vertical",
+  Crop: "crop",
+} as const;
+export type TemplateCreateDocumentFromTemplateOverflow9 = ClosedEnum<
+  typeof TemplateCreateDocumentFromTemplateOverflow9
+>;
+
 export type TemplateCreateDocumentFromTemplateValue2 = {
   id: number;
   checked: boolean;
@@ -500,6 +646,7 @@ export type TemplateCreateDocumentFromTemplateFieldMetaCheckbox = {
   required?: boolean | undefined;
   readOnly?: boolean | undefined;
   fontSize?: number | undefined;
+  overflow?: TemplateCreateDocumentFromTemplateOverflow9 | undefined;
   type: "checkbox";
   values?: Array<TemplateCreateDocumentFromTemplateValue2> | undefined;
   validationRule?: string | undefined;
@@ -507,6 +654,16 @@ export type TemplateCreateDocumentFromTemplateFieldMetaCheckbox = {
   direction?: TemplateCreateDocumentFromTemplateDirection2 | undefined;
 };
 
+export const TemplateCreateDocumentFromTemplateOverflow8 = {
+  Auto: "auto",
+  Horizontal: "horizontal",
+  Vertical: "vertical",
+  Crop: "crop",
+} as const;
+export type TemplateCreateDocumentFromTemplateOverflow8 = ClosedEnum<
+  typeof TemplateCreateDocumentFromTemplateOverflow8
+>;
+
 export type TemplateCreateDocumentFromTemplateValue1 = {
   id: number;
   checked: boolean;
@@ -527,11 +684,22 @@ export type TemplateCreateDocumentFromTemplateFieldMetaRadio = {
   required?: boolean | undefined;
   readOnly?: boolean | undefined;
   fontSize?: number | undefined;
+  overflow?: TemplateCreateDocumentFromTemplateOverflow8 | undefined;
   type: "radio";
   values?: Array<TemplateCreateDocumentFromTemplateValue1> | undefined;
   direction?: TemplateCreateDocumentFromTemplateDirection1 | undefined;
 };
 
+export const TemplateCreateDocumentFromTemplateOverflow7 = {
+  Auto: "auto",
+  Horizontal: "horizontal",
+  Vertical: "vertical",
+  Crop: "crop",
+} as const;
+export type TemplateCreateDocumentFromTemplateOverflow7 = ClosedEnum<
+  typeof TemplateCreateDocumentFromTemplateOverflow7
+>;
+
 export const TemplateCreateDocumentFromTemplateTextAlign6 = {
   Left: "left",
   Center: "center",
@@ -556,6 +724,7 @@ export type TemplateCreateDocumentFromTemplateFieldMetaNumber = {
   required?: boolean | undefined;
   readOnly?: boolean | undefined;
   fontSize?: number | undefined;
+  overflow?: TemplateCreateDocumentFromTemplateOverflow7 | undefined;
   type: "number";
   numberFormat?: string | null | undefined;
   value?: string | undefined;
@@ -570,6 +739,16 @@ export type TemplateCreateDocumentFromTemplateFieldMetaNumber = {
     | undefined;
 };
 
+export const TemplateCreateDocumentFromTemplateOverflow6 = {
+  Auto: "auto",
+  Horizontal: "horizontal",
+  Vertical: "vertical",
+  Crop: "crop",
+} as const;
+export type TemplateCreateDocumentFromTemplateOverflow6 = ClosedEnum<
+  typeof TemplateCreateDocumentFromTemplateOverflow6
+>;
+
 export const TemplateCreateDocumentFromTemplateTextAlign5 = {
   Left: "left",
   Center: "center",
@@ -594,6 +773,7 @@ export type TemplateCreateDocumentFromTemplateFieldMetaText = {
   required?: boolean | undefined;
   readOnly?: boolean | undefined;
   fontSize?: number | undefined;
+  overflow?: TemplateCreateDocumentFromTemplateOverflow6 | undefined;
   type: "text";
   text?: string | undefined;
   characterLimit?: number | undefined;
@@ -606,6 +786,16 @@ export type TemplateCreateDocumentFromTemplateFieldMetaText = {
     | undefined;
 };
 
+export const TemplateCreateDocumentFromTemplateOverflow5 = {
+  Auto: "auto",
+  Horizontal: "horizontal",
+  Vertical: "vertical",
+  Crop: "crop",
+} as const;
+export type TemplateCreateDocumentFromTemplateOverflow5 = ClosedEnum<
+  typeof TemplateCreateDocumentFromTemplateOverflow5
+>;
+
 export const TemplateCreateDocumentFromTemplateTextAlign4 = {
   Left: "left",
   Center: "center",
@@ -621,10 +811,21 @@ export type TemplateCreateDocumentFromTemplateFieldMetaDate = {
   required?: boolean | undefined;
   readOnly?: boolean | undefined;
   fontSize?: number | undefined;
+  overflow?: TemplateCreateDocumentFromTemplateOverflow5 | undefined;
   type: "date";
   textAlign?: TemplateCreateDocumentFromTemplateTextAlign4 | undefined;
 };
 
+export const TemplateCreateDocumentFromTemplateOverflow4 = {
+  Auto: "auto",
+  Horizontal: "horizontal",
+  Vertical: "vertical",
+  Crop: "crop",
+} as const;
+export type TemplateCreateDocumentFromTemplateOverflow4 = ClosedEnum<
+  typeof TemplateCreateDocumentFromTemplateOverflow4
+>;
+
 export const TemplateCreateDocumentFromTemplateTextAlign3 = {
   Left: "left",
   Center: "center",
@@ -640,10 +841,21 @@ export type TemplateCreateDocumentFromTemplateFieldMetaEmail = {
   required?: boolean | undefined;
   readOnly?: boolean | undefined;
   fontSize?: number | undefined;
+  overflow?: TemplateCreateDocumentFromTemplateOverflow4 | undefined;
   type: "email";
   textAlign?: TemplateCreateDocumentFromTemplateTextAlign3 | undefined;
 };
 
+export const TemplateCreateDocumentFromTemplateOverflow3 = {
+  Auto: "auto",
+  Horizontal: "horizontal",
+  Vertical: "vertical",
+  Crop: "crop",
+} as const;
+export type TemplateCreateDocumentFromTemplateOverflow3 = ClosedEnum<
+  typeof TemplateCreateDocumentFromTemplateOverflow3
+>;
+
 export const TemplateCreateDocumentFromTemplateTextAlign2 = {
   Left: "left",
   Center: "center",
@@ -659,10 +871,21 @@ export type TemplateCreateDocumentFromTemplateFieldMetaName = {
   required?: boolean | undefined;
   readOnly?: boolean | undefined;
   fontSize?: number | undefined;
+  overflow?: TemplateCreateDocumentFromTemplateOverflow3 | undefined;
   type: "name";
   textAlign?: TemplateCreateDocumentFromTemplateTextAlign2 | undefined;
 };
 
+export const TemplateCreateDocumentFromTemplateOverflow2 = {
+  Auto: "auto",
+  Horizontal: "horizontal",
+  Vertical: "vertical",
+  Crop: "crop",
+} as const;
+export type TemplateCreateDocumentFromTemplateOverflow2 = ClosedEnum<
+  typeof TemplateCreateDocumentFromTemplateOverflow2
+>;
+
 export const TemplateCreateDocumentFromTemplateTextAlign1 = {
   Left: "left",
   Center: "center",
@@ -678,16 +901,28 @@ export type TemplateCreateDocumentFromTemplateFieldMetaInitials = {
   required?: boolean | undefined;
   readOnly?: boolean | undefined;
   fontSize?: number | undefined;
+  overflow?: TemplateCreateDocumentFromTemplateOverflow2 | undefined;
   type: "initials";
   textAlign?: TemplateCreateDocumentFromTemplateTextAlign1 | undefined;
 };
 
+export const TemplateCreateDocumentFromTemplateOverflow1 = {
+  Auto: "auto",
+  Horizontal: "horizontal",
+  Vertical: "vertical",
+  Crop: "crop",
+} as const;
+export type TemplateCreateDocumentFromTemplateOverflow1 = ClosedEnum<
+  typeof TemplateCreateDocumentFromTemplateOverflow1
+>;
+
 export type TemplateCreateDocumentFromTemplateFieldMetaSignature = {
   label?: string | undefined;
   placeholder?: string | undefined;
   required?: boolean | undefined;
   readOnly?: boolean | undefined;
   fontSize?: number | undefined;
+  overflow?: TemplateCreateDocumentFromTemplateOverflow1 | undefined;
   type: "signature";
 };
 
@@ -1420,6 +1655,8 @@ export const TemplateCreateDocumentFromTemplateOverrideEmailSettings$inboundSche
     documentCompleted: z.boolean().default(true),
     documentDeleted: z.boolean().default(true),
     ownerDocumentCompleted: z.boolean().default(true),
+    ownerRecipientExpired: z.boolean().default(true),
+    ownerDocumentCreated: z.boolean().default(true),
   });
 /** @internal */
 export type TemplateCreateDocumentFromTemplateOverrideEmailSettings$Outbound = {
@@ -1430,6 +1667,8 @@ export type TemplateCreateDocumentFromTemplateOverrideEmailSettings$Outbound = {
   documentCompleted: boolean;
   documentDeleted: boolean;
   ownerDocumentCompleted: boolean;
+  ownerRecipientExpired: boolean;
+  ownerDocumentCreated: boolean;
 };
 
 /** @internal */
@@ -1446,6 +1685,8 @@ export const TemplateCreateDocumentFromTemplateOverrideEmailSettings$outboundSch
     documentCompleted: z.boolean().default(true),
     documentDeleted: z.boolean().default(true),
     ownerDocumentCompleted: z.boolean().default(true),
+    ownerRecipientExpired: z.boolean().default(true),
+    ownerDocumentCreated: z.boolean().default(true),
   });
 
 export function templateCreateDocumentFromTemplateOverrideEmailSettingsToJSON(
@@ -1481,6 +1722,180 @@ export const TemplateCreateDocumentFromTemplateLanguage$outboundSchema:
   z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateLanguage> =
     TemplateCreateDocumentFromTemplateLanguage$inboundSchema;
 
+/** @internal */
+export const TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride2$inboundSchema:
+  z.ZodType<
+    TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride2,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    disabled: z.literal(true),
+  });
+/** @internal */
+export type TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride2$Outbound =
+  {
+    disabled: true;
+  };
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride2$outboundSchema:
+  z.ZodType<
+    TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride2$Outbound,
+    z.ZodTypeDef,
+    TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride2
+  > = z.object({
+    disabled: z.literal(true),
+  });
+
+export function templateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride2ToJSON(
+  templateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride2:
+    TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride2,
+): string {
+  return JSON.stringify(
+    TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride2$outboundSchema
+      .parse(
+        templateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride2,
+      ),
+  );
+}
+export function templateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride2FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride2,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride2$inboundSchema
+        .parse(JSON.parse(x)),
+    `Failed to parse 'TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride2' from JSON`,
+  );
+}
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateOverrideUnit$inboundSchema:
+  z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateOverrideUnit> = z
+    .nativeEnum(TemplateCreateDocumentFromTemplateOverrideUnit);
+/** @internal */
+export const TemplateCreateDocumentFromTemplateOverrideUnit$outboundSchema:
+  z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateOverrideUnit> =
+    TemplateCreateDocumentFromTemplateOverrideUnit$inboundSchema;
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride1$inboundSchema:
+  z.ZodType<
+    TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride1,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    unit: TemplateCreateDocumentFromTemplateOverrideUnit$inboundSchema,
+    amount: z.number().int(),
+  });
+/** @internal */
+export type TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride1$Outbound =
+  {
+    unit: string;
+    amount: number;
+  };
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride1$outboundSchema:
+  z.ZodType<
+    TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride1$Outbound,
+    z.ZodTypeDef,
+    TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride1
+  > = z.object({
+    unit: TemplateCreateDocumentFromTemplateOverrideUnit$outboundSchema,
+    amount: z.number().int(),
+  });
+
+export function templateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride1ToJSON(
+  templateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride1:
+    TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride1,
+): string {
+  return JSON.stringify(
+    TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride1$outboundSchema
+      .parse(
+        templateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride1,
+      ),
+  );
+}
+export function templateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride1FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride1,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride1$inboundSchema
+        .parse(JSON.parse(x)),
+    `Failed to parse 'TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride1' from JSON`,
+  );
+}
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateOverrideEnvelopeExpirationPeriodUnion$inboundSchema:
+  z.ZodType<
+    TemplateCreateDocumentFromTemplateOverrideEnvelopeExpirationPeriodUnion,
+    z.ZodTypeDef,
+    unknown
+  > = z.union([
+    z.lazy(() =>
+      TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride1$inboundSchema
+    ),
+    z.lazy(() =>
+      TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride2$inboundSchema
+    ),
+  ]);
+/** @internal */
+export type TemplateCreateDocumentFromTemplateOverrideEnvelopeExpirationPeriodUnion$Outbound =
+  | TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride1$Outbound
+  | TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride2$Outbound;
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateOverrideEnvelopeExpirationPeriodUnion$outboundSchema:
+  z.ZodType<
+    TemplateCreateDocumentFromTemplateOverrideEnvelopeExpirationPeriodUnion$Outbound,
+    z.ZodTypeDef,
+    TemplateCreateDocumentFromTemplateOverrideEnvelopeExpirationPeriodUnion
+  > = z.union([
+    z.lazy(() =>
+      TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride1$outboundSchema
+    ),
+    z.lazy(() =>
+      TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride2$outboundSchema
+    ),
+  ]);
+
+export function templateCreateDocumentFromTemplateOverrideEnvelopeExpirationPeriodUnionToJSON(
+  templateCreateDocumentFromTemplateOverrideEnvelopeExpirationPeriodUnion:
+    TemplateCreateDocumentFromTemplateOverrideEnvelopeExpirationPeriodUnion,
+): string {
+  return JSON.stringify(
+    TemplateCreateDocumentFromTemplateOverrideEnvelopeExpirationPeriodUnion$outboundSchema
+      .parse(
+        templateCreateDocumentFromTemplateOverrideEnvelopeExpirationPeriodUnion,
+      ),
+  );
+}
+export function templateCreateDocumentFromTemplateOverrideEnvelopeExpirationPeriodUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  TemplateCreateDocumentFromTemplateOverrideEnvelopeExpirationPeriodUnion,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      TemplateCreateDocumentFromTemplateOverrideEnvelopeExpirationPeriodUnion$inboundSchema
+        .parse(JSON.parse(x)),
+    `Failed to parse 'TemplateCreateDocumentFromTemplateOverrideEnvelopeExpirationPeriodUnion' from JSON`,
+  );
+}
+
 /** @internal */
 export const TemplateCreateDocumentFromTemplateOverride$inboundSchema:
   z.ZodType<TemplateCreateDocumentFromTemplateOverride, z.ZodTypeDef, unknown> =
@@ -1504,6 +1919,16 @@ export const TemplateCreateDocumentFromTemplateOverride$inboundSchema:
       uploadSignatureEnabled: z.boolean().optional(),
       drawSignatureEnabled: z.boolean().optional(),
       allowDictateNextSigner: z.boolean().optional(),
+      envelopeExpirationPeriod: z.nullable(
+        z.union([
+          z.lazy(() =>
+            TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride1$inboundSchema
+          ),
+          z.lazy(() =>
+            TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride2$inboundSchema
+          ),
+        ]),
+      ).optional(),
     });
 /** @internal */
 export type TemplateCreateDocumentFromTemplateOverride$Outbound = {
@@ -1522,6 +1947,11 @@ export type TemplateCreateDocumentFromTemplateOverride$Outbound = {
   uploadSignatureEnabled?: boolean | undefined;
   drawSignatureEnabled?: boolean | undefined;
   allowDictateNextSigner?: boolean | undefined;
+  envelopeExpirationPeriod?:
+    | TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride1$Outbound
+    | TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride2$Outbound
+    | null
+    | undefined;
 };
 
 /** @internal */
@@ -1550,6 +1980,16 @@ export const TemplateCreateDocumentFromTemplateOverride$outboundSchema:
     uploadSignatureEnabled: z.boolean().optional(),
     drawSignatureEnabled: z.boolean().optional(),
     allowDictateNextSigner: z.boolean().optional(),
+    envelopeExpirationPeriod: z.nullable(
+      z.union([
+        z.lazy(() =>
+          TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride1$outboundSchema
+        ),
+        z.lazy(() =>
+          TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodOverride2$outboundSchema
+        ),
+      ]),
+    ).optional(),
   });
 
 export function templateCreateDocumentFromTemplateOverrideToJSON(
@@ -2117,6 +2557,8 @@ export const TemplateCreateDocumentFromTemplateDocumentMetaEmailSettings$inbound
     documentCompleted: z.boolean().default(true),
     documentDeleted: z.boolean().default(true),
     ownerDocumentCompleted: z.boolean().default(true),
+    ownerRecipientExpired: z.boolean().default(true),
+    ownerDocumentCreated: z.boolean().default(true),
   });
 /** @internal */
 export type TemplateCreateDocumentFromTemplateDocumentMetaEmailSettings$Outbound =
@@ -2128,6 +2570,8 @@ export type TemplateCreateDocumentFromTemplateDocumentMetaEmailSettings$Outbound
     documentCompleted: boolean;
     documentDeleted: boolean;
     ownerDocumentCompleted: boolean;
+    ownerRecipientExpired: boolean;
+    ownerDocumentCreated: boolean;
   };
 
 /** @internal */
@@ -2144,6 +2588,8 @@ export const TemplateCreateDocumentFromTemplateDocumentMetaEmailSettings$outboun
     documentCompleted: z.boolean().default(true),
     documentDeleted: z.boolean().default(true),
     ownerDocumentCompleted: z.boolean().default(true),
+    ownerRecipientExpired: z.boolean().default(true),
+    ownerDocumentCreated: z.boolean().default(true),
   });
 
 export function templateCreateDocumentFromTemplateDocumentMetaEmailSettingsToJSON(
@@ -2171,59 +2617,667 @@ export function templateCreateDocumentFromTemplateDocumentMetaEmailSettingsFromJ
 }
 
 /** @internal */
-export const TemplateCreateDocumentFromTemplateDocumentMeta$inboundSchema:
+export const TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse2$inboundSchema:
   z.ZodType<
-    TemplateCreateDocumentFromTemplateDocumentMeta,
+    TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse2,
     z.ZodTypeDef,
     unknown
   > = z.object({
-    signingOrder: TemplateCreateDocumentFromTemplateSigningOrder$inboundSchema,
-    distributionMethod:
-      TemplateCreateDocumentFromTemplateDocumentMetaDistributionMethod$inboundSchema,
-    id: z.string(),
-    subject: z.nullable(z.string()),
-    message: z.nullable(z.string()),
-    timezone: z.nullable(z.string()),
-    dateFormat: z.nullable(z.string()),
-    redirectUrl: z.nullable(z.string()),
-    typedSignatureEnabled: z.boolean(),
-    uploadSignatureEnabled: z.boolean(),
-    drawSignatureEnabled: z.boolean(),
-    allowDictateNextSigner: z.boolean(),
-    language: z.string(),
-    emailSettings: z.nullable(
-      z.lazy(() =>
-        TemplateCreateDocumentFromTemplateDocumentMetaEmailSettings$inboundSchema
-      ),
-    ),
-    emailId: z.nullable(z.string()),
-    emailReplyTo: z.nullable(z.string()),
-    password: z.nullable(z.string()).default(null),
-    documentId: z.number().default(-1),
+    disabled: z.literal(true),
   });
 /** @internal */
-export type TemplateCreateDocumentFromTemplateDocumentMeta$Outbound = {
-  signingOrder: string;
-  distributionMethod: string;
-  id: string;
-  subject: string | null;
-  message: string | null;
-  timezone: string | null;
-  dateFormat: string | null;
-  redirectUrl: string | null;
-  typedSignatureEnabled: boolean;
-  uploadSignatureEnabled: boolean;
-  drawSignatureEnabled: boolean;
-  allowDictateNextSigner: boolean;
-  language: string;
-  emailSettings:
-    | TemplateCreateDocumentFromTemplateDocumentMetaEmailSettings$Outbound
-    | null;
-  emailId: string | null;
-  emailReplyTo: string | null;
-  password: string | null;
-  documentId: number;
-};
+export type TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse2$Outbound =
+  {
+    disabled: true;
+  };
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse2$outboundSchema:
+  z.ZodType<
+    TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse2$Outbound,
+    z.ZodTypeDef,
+    TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse2
+  > = z.object({
+    disabled: z.literal(true),
+  });
+
+export function templateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse2ToJSON(
+  templateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse2:
+    TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse2,
+): string {
+  return JSON.stringify(
+    TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse2$outboundSchema
+      .parse(
+        templateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse2,
+      ),
+  );
+}
+export function templateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse2FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse2,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse2$inboundSchema
+        .parse(JSON.parse(x)),
+    `Failed to parse 'TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse2' from JSON`,
+  );
+}
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodUnitResponse$inboundSchema:
+  z.ZodNativeEnum<
+    typeof TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodUnitResponse
+  > = z.nativeEnum(
+    TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodUnitResponse,
+  );
+/** @internal */
+export const TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodUnitResponse$outboundSchema:
+  z.ZodNativeEnum<
+    typeof TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodUnitResponse
+  > =
+    TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodUnitResponse$inboundSchema;
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse1$inboundSchema:
+  z.ZodType<
+    TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse1,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    unit:
+      TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodUnitResponse$inboundSchema,
+    amount: z.number().int(),
+  });
+/** @internal */
+export type TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse1$Outbound =
+  {
+    unit: string;
+    amount: number;
+  };
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse1$outboundSchema:
+  z.ZodType<
+    TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse1$Outbound,
+    z.ZodTypeDef,
+    TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse1
+  > = z.object({
+    unit:
+      TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodUnitResponse$outboundSchema,
+    amount: z.number().int(),
+  });
+
+export function templateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse1ToJSON(
+  templateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse1:
+    TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse1,
+): string {
+  return JSON.stringify(
+    TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse1$outboundSchema
+      .parse(
+        templateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse1,
+      ),
+  );
+}
+export function templateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse1FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse1,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse1$inboundSchema
+        .parse(JSON.parse(x)),
+    `Failed to parse 'TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse1' from JSON`,
+  );
+}
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponseUnion$inboundSchema:
+  z.ZodType<
+    TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponseUnion,
+    z.ZodTypeDef,
+    unknown
+  > = z.union([
+    z.lazy(() =>
+      TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse1$inboundSchema
+    ),
+    z.lazy(() =>
+      TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse2$inboundSchema
+    ),
+  ]);
+/** @internal */
+export type TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponseUnion$Outbound =
+  | TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse1$Outbound
+  | TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse2$Outbound;
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponseUnion$outboundSchema:
+  z.ZodType<
+    TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponseUnion$Outbound,
+    z.ZodTypeDef,
+    TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponseUnion
+  > = z.union([
+    z.lazy(() =>
+      TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse1$outboundSchema
+    ),
+    z.lazy(() =>
+      TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse2$outboundSchema
+    ),
+  ]);
+
+export function templateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponseUnionToJSON(
+  templateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponseUnion:
+    TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponseUnion,
+): string {
+  return JSON.stringify(
+    TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponseUnion$outboundSchema
+      .parse(
+        templateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponseUnion,
+      ),
+  );
+}
+export function templateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponseUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponseUnion,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponseUnion$inboundSchema
+        .parse(JSON.parse(x)),
+    `Failed to parse 'TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponseUnion' from JSON`,
+  );
+}
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateSendAfter2$inboundSchema:
+  z.ZodType<
+    TemplateCreateDocumentFromTemplateSendAfter2,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    disabled: z.literal(true),
+  });
+/** @internal */
+export type TemplateCreateDocumentFromTemplateSendAfter2$Outbound = {
+  disabled: true;
+};
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateSendAfter2$outboundSchema:
+  z.ZodType<
+    TemplateCreateDocumentFromTemplateSendAfter2$Outbound,
+    z.ZodTypeDef,
+    TemplateCreateDocumentFromTemplateSendAfter2
+  > = z.object({
+    disabled: z.literal(true),
+  });
+
+export function templateCreateDocumentFromTemplateSendAfter2ToJSON(
+  templateCreateDocumentFromTemplateSendAfter2:
+    TemplateCreateDocumentFromTemplateSendAfter2,
+): string {
+  return JSON.stringify(
+    TemplateCreateDocumentFromTemplateSendAfter2$outboundSchema.parse(
+      templateCreateDocumentFromTemplateSendAfter2,
+    ),
+  );
+}
+export function templateCreateDocumentFromTemplateSendAfter2FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  TemplateCreateDocumentFromTemplateSendAfter2,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      TemplateCreateDocumentFromTemplateSendAfter2$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'TemplateCreateDocumentFromTemplateSendAfter2' from JSON`,
+  );
+}
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateSendAfterUnit$inboundSchema:
+  z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateSendAfterUnit> = z
+    .nativeEnum(TemplateCreateDocumentFromTemplateSendAfterUnit);
+/** @internal */
+export const TemplateCreateDocumentFromTemplateSendAfterUnit$outboundSchema:
+  z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateSendAfterUnit> =
+    TemplateCreateDocumentFromTemplateSendAfterUnit$inboundSchema;
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateSendAfter1$inboundSchema:
+  z.ZodType<
+    TemplateCreateDocumentFromTemplateSendAfter1,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    unit: TemplateCreateDocumentFromTemplateSendAfterUnit$inboundSchema,
+    amount: z.number().int(),
+  });
+/** @internal */
+export type TemplateCreateDocumentFromTemplateSendAfter1$Outbound = {
+  unit: string;
+  amount: number;
+};
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateSendAfter1$outboundSchema:
+  z.ZodType<
+    TemplateCreateDocumentFromTemplateSendAfter1$Outbound,
+    z.ZodTypeDef,
+    TemplateCreateDocumentFromTemplateSendAfter1
+  > = z.object({
+    unit: TemplateCreateDocumentFromTemplateSendAfterUnit$outboundSchema,
+    amount: z.number().int(),
+  });
+
+export function templateCreateDocumentFromTemplateSendAfter1ToJSON(
+  templateCreateDocumentFromTemplateSendAfter1:
+    TemplateCreateDocumentFromTemplateSendAfter1,
+): string {
+  return JSON.stringify(
+    TemplateCreateDocumentFromTemplateSendAfter1$outboundSchema.parse(
+      templateCreateDocumentFromTemplateSendAfter1,
+    ),
+  );
+}
+export function templateCreateDocumentFromTemplateSendAfter1FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  TemplateCreateDocumentFromTemplateSendAfter1,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      TemplateCreateDocumentFromTemplateSendAfter1$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'TemplateCreateDocumentFromTemplateSendAfter1' from JSON`,
+  );
+}
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateSendAfterUnion$inboundSchema:
+  z.ZodType<
+    TemplateCreateDocumentFromTemplateSendAfterUnion,
+    z.ZodTypeDef,
+    unknown
+  > = z.union([
+    z.lazy(() => TemplateCreateDocumentFromTemplateSendAfter1$inboundSchema),
+    z.lazy(() => TemplateCreateDocumentFromTemplateSendAfter2$inboundSchema),
+  ]);
+/** @internal */
+export type TemplateCreateDocumentFromTemplateSendAfterUnion$Outbound =
+  | TemplateCreateDocumentFromTemplateSendAfter1$Outbound
+  | TemplateCreateDocumentFromTemplateSendAfter2$Outbound;
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateSendAfterUnion$outboundSchema:
+  z.ZodType<
+    TemplateCreateDocumentFromTemplateSendAfterUnion$Outbound,
+    z.ZodTypeDef,
+    TemplateCreateDocumentFromTemplateSendAfterUnion
+  > = z.union([
+    z.lazy(() => TemplateCreateDocumentFromTemplateSendAfter1$outboundSchema),
+    z.lazy(() => TemplateCreateDocumentFromTemplateSendAfter2$outboundSchema),
+  ]);
+
+export function templateCreateDocumentFromTemplateSendAfterUnionToJSON(
+  templateCreateDocumentFromTemplateSendAfterUnion:
+    TemplateCreateDocumentFromTemplateSendAfterUnion,
+): string {
+  return JSON.stringify(
+    TemplateCreateDocumentFromTemplateSendAfterUnion$outboundSchema.parse(
+      templateCreateDocumentFromTemplateSendAfterUnion,
+    ),
+  );
+}
+export function templateCreateDocumentFromTemplateSendAfterUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  TemplateCreateDocumentFromTemplateSendAfterUnion,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      TemplateCreateDocumentFromTemplateSendAfterUnion$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'TemplateCreateDocumentFromTemplateSendAfterUnion' from JSON`,
+  );
+}
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateRepeatEvery2$inboundSchema:
+  z.ZodType<
+    TemplateCreateDocumentFromTemplateRepeatEvery2,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    disabled: z.literal(true),
+  });
+/** @internal */
+export type TemplateCreateDocumentFromTemplateRepeatEvery2$Outbound = {
+  disabled: true;
+};
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateRepeatEvery2$outboundSchema:
+  z.ZodType<
+    TemplateCreateDocumentFromTemplateRepeatEvery2$Outbound,
+    z.ZodTypeDef,
+    TemplateCreateDocumentFromTemplateRepeatEvery2
+  > = z.object({
+    disabled: z.literal(true),
+  });
+
+export function templateCreateDocumentFromTemplateRepeatEvery2ToJSON(
+  templateCreateDocumentFromTemplateRepeatEvery2:
+    TemplateCreateDocumentFromTemplateRepeatEvery2,
+): string {
+  return JSON.stringify(
+    TemplateCreateDocumentFromTemplateRepeatEvery2$outboundSchema.parse(
+      templateCreateDocumentFromTemplateRepeatEvery2,
+    ),
+  );
+}
+export function templateCreateDocumentFromTemplateRepeatEvery2FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  TemplateCreateDocumentFromTemplateRepeatEvery2,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      TemplateCreateDocumentFromTemplateRepeatEvery2$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'TemplateCreateDocumentFromTemplateRepeatEvery2' from JSON`,
+  );
+}
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateRepeatEveryUnit$inboundSchema:
+  z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateRepeatEveryUnit> = z
+    .nativeEnum(TemplateCreateDocumentFromTemplateRepeatEveryUnit);
+/** @internal */
+export const TemplateCreateDocumentFromTemplateRepeatEveryUnit$outboundSchema:
+  z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateRepeatEveryUnit> =
+    TemplateCreateDocumentFromTemplateRepeatEveryUnit$inboundSchema;
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateRepeatEvery1$inboundSchema:
+  z.ZodType<
+    TemplateCreateDocumentFromTemplateRepeatEvery1,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    unit: TemplateCreateDocumentFromTemplateRepeatEveryUnit$inboundSchema,
+    amount: z.number().int(),
+  });
+/** @internal */
+export type TemplateCreateDocumentFromTemplateRepeatEvery1$Outbound = {
+  unit: string;
+  amount: number;
+};
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateRepeatEvery1$outboundSchema:
+  z.ZodType<
+    TemplateCreateDocumentFromTemplateRepeatEvery1$Outbound,
+    z.ZodTypeDef,
+    TemplateCreateDocumentFromTemplateRepeatEvery1
+  > = z.object({
+    unit: TemplateCreateDocumentFromTemplateRepeatEveryUnit$outboundSchema,
+    amount: z.number().int(),
+  });
+
+export function templateCreateDocumentFromTemplateRepeatEvery1ToJSON(
+  templateCreateDocumentFromTemplateRepeatEvery1:
+    TemplateCreateDocumentFromTemplateRepeatEvery1,
+): string {
+  return JSON.stringify(
+    TemplateCreateDocumentFromTemplateRepeatEvery1$outboundSchema.parse(
+      templateCreateDocumentFromTemplateRepeatEvery1,
+    ),
+  );
+}
+export function templateCreateDocumentFromTemplateRepeatEvery1FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  TemplateCreateDocumentFromTemplateRepeatEvery1,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      TemplateCreateDocumentFromTemplateRepeatEvery1$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'TemplateCreateDocumentFromTemplateRepeatEvery1' from JSON`,
+  );
+}
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateRepeatEveryUnion$inboundSchema:
+  z.ZodType<
+    TemplateCreateDocumentFromTemplateRepeatEveryUnion,
+    z.ZodTypeDef,
+    unknown
+  > = z.union([
+    z.lazy(() => TemplateCreateDocumentFromTemplateRepeatEvery1$inboundSchema),
+    z.lazy(() => TemplateCreateDocumentFromTemplateRepeatEvery2$inboundSchema),
+  ]);
+/** @internal */
+export type TemplateCreateDocumentFromTemplateRepeatEveryUnion$Outbound =
+  | TemplateCreateDocumentFromTemplateRepeatEvery1$Outbound
+  | TemplateCreateDocumentFromTemplateRepeatEvery2$Outbound;
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateRepeatEveryUnion$outboundSchema:
+  z.ZodType<
+    TemplateCreateDocumentFromTemplateRepeatEveryUnion$Outbound,
+    z.ZodTypeDef,
+    TemplateCreateDocumentFromTemplateRepeatEveryUnion
+  > = z.union([
+    z.lazy(() => TemplateCreateDocumentFromTemplateRepeatEvery1$outboundSchema),
+    z.lazy(() => TemplateCreateDocumentFromTemplateRepeatEvery2$outboundSchema),
+  ]);
+
+export function templateCreateDocumentFromTemplateRepeatEveryUnionToJSON(
+  templateCreateDocumentFromTemplateRepeatEveryUnion:
+    TemplateCreateDocumentFromTemplateRepeatEveryUnion,
+): string {
+  return JSON.stringify(
+    TemplateCreateDocumentFromTemplateRepeatEveryUnion$outboundSchema.parse(
+      templateCreateDocumentFromTemplateRepeatEveryUnion,
+    ),
+  );
+}
+export function templateCreateDocumentFromTemplateRepeatEveryUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  TemplateCreateDocumentFromTemplateRepeatEveryUnion,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      TemplateCreateDocumentFromTemplateRepeatEveryUnion$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'TemplateCreateDocumentFromTemplateRepeatEveryUnion' from JSON`,
+  );
+}
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateReminderSettings$inboundSchema:
+  z.ZodType<
+    TemplateCreateDocumentFromTemplateReminderSettings,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    sendAfter: z.union([
+      z.lazy(() => TemplateCreateDocumentFromTemplateSendAfter1$inboundSchema),
+      z.lazy(() => TemplateCreateDocumentFromTemplateSendAfter2$inboundSchema),
+    ]),
+    repeatEvery: z.union([
+      z.lazy(() =>
+        TemplateCreateDocumentFromTemplateRepeatEvery1$inboundSchema
+      ),
+      z.lazy(() =>
+        TemplateCreateDocumentFromTemplateRepeatEvery2$inboundSchema
+      ),
+    ]),
+  });
+/** @internal */
+export type TemplateCreateDocumentFromTemplateReminderSettings$Outbound = {
+  sendAfter:
+    | TemplateCreateDocumentFromTemplateSendAfter1$Outbound
+    | TemplateCreateDocumentFromTemplateSendAfter2$Outbound;
+  repeatEvery:
+    | TemplateCreateDocumentFromTemplateRepeatEvery1$Outbound
+    | TemplateCreateDocumentFromTemplateRepeatEvery2$Outbound;
+};
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateReminderSettings$outboundSchema:
+  z.ZodType<
+    TemplateCreateDocumentFromTemplateReminderSettings$Outbound,
+    z.ZodTypeDef,
+    TemplateCreateDocumentFromTemplateReminderSettings
+  > = z.object({
+    sendAfter: z.union([
+      z.lazy(() => TemplateCreateDocumentFromTemplateSendAfter1$outboundSchema),
+      z.lazy(() => TemplateCreateDocumentFromTemplateSendAfter2$outboundSchema),
+    ]),
+    repeatEvery: z.union([
+      z.lazy(() =>
+        TemplateCreateDocumentFromTemplateRepeatEvery1$outboundSchema
+      ),
+      z.lazy(() =>
+        TemplateCreateDocumentFromTemplateRepeatEvery2$outboundSchema
+      ),
+    ]),
+  });
+
+export function templateCreateDocumentFromTemplateReminderSettingsToJSON(
+  templateCreateDocumentFromTemplateReminderSettings:
+    TemplateCreateDocumentFromTemplateReminderSettings,
+): string {
+  return JSON.stringify(
+    TemplateCreateDocumentFromTemplateReminderSettings$outboundSchema.parse(
+      templateCreateDocumentFromTemplateReminderSettings,
+    ),
+  );
+}
+export function templateCreateDocumentFromTemplateReminderSettingsFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  TemplateCreateDocumentFromTemplateReminderSettings,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      TemplateCreateDocumentFromTemplateReminderSettings$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'TemplateCreateDocumentFromTemplateReminderSettings' from JSON`,
+  );
+}
+
+/** @internal */
+export const TemplateCreateDocumentFromTemplateDocumentMeta$inboundSchema:
+  z.ZodType<
+    TemplateCreateDocumentFromTemplateDocumentMeta,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    signingOrder: TemplateCreateDocumentFromTemplateSigningOrder$inboundSchema,
+    distributionMethod:
+      TemplateCreateDocumentFromTemplateDocumentMetaDistributionMethod$inboundSchema,
+    id: z.string(),
+    subject: z.nullable(z.string()),
+    message: z.nullable(z.string()),
+    timezone: z.nullable(z.string()),
+    dateFormat: z.nullable(z.string()),
+    redirectUrl: z.nullable(z.string()),
+    typedSignatureEnabled: z.boolean(),
+    uploadSignatureEnabled: z.boolean(),
+    drawSignatureEnabled: z.boolean(),
+    allowDictateNextSigner: z.boolean(),
+    language: z.string(),
+    emailSettings: z.nullable(
+      z.lazy(() =>
+        TemplateCreateDocumentFromTemplateDocumentMetaEmailSettings$inboundSchema
+      ),
+    ),
+    emailId: z.nullable(z.string()),
+    emailReplyTo: z.nullable(z.string()),
+    envelopeExpirationPeriod: z.nullable(
+      z.union([
+        z.lazy(() =>
+          TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse1$inboundSchema
+        ),
+        z.lazy(() =>
+          TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse2$inboundSchema
+        ),
+      ]),
+    ),
+    reminderSettings: z.nullable(
+      z.lazy(() =>
+        TemplateCreateDocumentFromTemplateReminderSettings$inboundSchema
+      ),
+    ),
+    password: z.nullable(z.string()).default(null),
+    documentId: z.number().default(-1),
+  });
+/** @internal */
+export type TemplateCreateDocumentFromTemplateDocumentMeta$Outbound = {
+  signingOrder: string;
+  distributionMethod: string;
+  id: string;
+  subject: string | null;
+  message: string | null;
+  timezone: string | null;
+  dateFormat: string | null;
+  redirectUrl: string | null;
+  typedSignatureEnabled: boolean;
+  uploadSignatureEnabled: boolean;
+  drawSignatureEnabled: boolean;
+  allowDictateNextSigner: boolean;
+  language: string;
+  emailSettings:
+    | TemplateCreateDocumentFromTemplateDocumentMetaEmailSettings$Outbound
+    | null;
+  emailId: string | null;
+  emailReplyTo: string | null;
+  envelopeExpirationPeriod:
+    | TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse1$Outbound
+    | TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse2$Outbound
+    | null;
+  reminderSettings:
+    | TemplateCreateDocumentFromTemplateReminderSettings$Outbound
+    | null;
+  password: string | null;
+  documentId: number;
+};
 
 /** @internal */
 export const TemplateCreateDocumentFromTemplateDocumentMeta$outboundSchema:
@@ -2253,6 +3307,21 @@ export const TemplateCreateDocumentFromTemplateDocumentMeta$outboundSchema:
     ),
     emailId: z.nullable(z.string()),
     emailReplyTo: z.nullable(z.string()),
+    envelopeExpirationPeriod: z.nullable(
+      z.union([
+        z.lazy(() =>
+          TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse1$outboundSchema
+        ),
+        z.lazy(() =>
+          TemplateCreateDocumentFromTemplateEnvelopeExpirationPeriodResponse2$outboundSchema
+        ),
+      ]),
+    ),
+    reminderSettings: z.nullable(
+      z.lazy(() =>
+        TemplateCreateDocumentFromTemplateReminderSettings$outboundSchema
+      ),
+    ),
     password: z.nullable(z.string()).default(null),
     documentId: z.number().default(-1),
   });
@@ -2563,6 +3632,8 @@ export const TemplateCreateDocumentFromTemplateRecipientResponse$inboundSchema:
     token: z.string(),
     documentDeletedAt: z.nullable(z.string()),
     expired: z.nullable(z.string()),
+    expiresAt: z.nullable(z.string()),
+    expirationNotifiedAt: z.nullable(z.string()),
     signedAt: z.nullable(z.string()),
     authOptions: z.nullable(
       z.lazy(() =>
@@ -2587,6 +3658,8 @@ export type TemplateCreateDocumentFromTemplateRecipientResponse$Outbound = {
   token: string;
   documentDeletedAt: string | null;
   expired: string | null;
+  expiresAt: string | null;
+  expirationNotifiedAt: string | null;
   signedAt: string | null;
   authOptions:
     | TemplateCreateDocumentFromTemplateRecipientAuthOptions$Outbound
@@ -2616,6 +3689,8 @@ export const TemplateCreateDocumentFromTemplateRecipientResponse$outboundSchema:
     token: z.string(),
     documentDeletedAt: z.nullable(z.string()),
     expired: z.nullable(z.string()),
+    expiresAt: z.nullable(z.string()),
+    expirationNotifiedAt: z.nullable(z.string()),
     signedAt: z.nullable(z.string()),
     authOptions: z.nullable(
       z.lazy(() =>
@@ -2663,6 +3738,15 @@ export const TemplateCreateDocumentFromTemplateFieldTypeEnum$outboundSchema:
   z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateFieldTypeEnum> =
     TemplateCreateDocumentFromTemplateFieldTypeEnum$inboundSchema;
 
+/** @internal */
+export const TemplateCreateDocumentFromTemplateOverflow10$inboundSchema:
+  z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateOverflow10> = z
+    .nativeEnum(TemplateCreateDocumentFromTemplateOverflow10);
+/** @internal */
+export const TemplateCreateDocumentFromTemplateOverflow10$outboundSchema:
+  z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateOverflow10> =
+    TemplateCreateDocumentFromTemplateOverflow10$inboundSchema;
+
 /** @internal */
 export const TemplateCreateDocumentFromTemplateValue3$inboundSchema: z.ZodType<
   TemplateCreateDocumentFromTemplateValue3,
@@ -2723,6 +3807,8 @@ export const TemplateCreateDocumentFromTemplateFieldMetaDropdown$inboundSchema:
     required: z.boolean().optional(),
     readOnly: z.boolean().optional(),
     fontSize: z.number().default(12),
+    overflow: TemplateCreateDocumentFromTemplateOverflow10$inboundSchema
+      .optional(),
     type: z.literal("dropdown"),
     values: z.array(
       z.lazy(() => TemplateCreateDocumentFromTemplateValue3$inboundSchema),
@@ -2736,6 +3822,7 @@ export type TemplateCreateDocumentFromTemplateFieldMetaDropdown$Outbound = {
   required?: boolean | undefined;
   readOnly?: boolean | undefined;
   fontSize: number;
+  overflow?: string | undefined;
   type: "dropdown";
   values?: Array<TemplateCreateDocumentFromTemplateValue3$Outbound> | undefined;
   defaultValue?: string | undefined;
@@ -2753,6 +3840,8 @@ export const TemplateCreateDocumentFromTemplateFieldMetaDropdown$outboundSchema:
     required: z.boolean().optional(),
     readOnly: z.boolean().optional(),
     fontSize: z.number().default(12),
+    overflow: TemplateCreateDocumentFromTemplateOverflow10$outboundSchema
+      .optional(),
     type: z.literal("dropdown"),
     values: z.array(
       z.lazy(() => TemplateCreateDocumentFromTemplateValue3$outboundSchema),
@@ -2786,6 +3875,15 @@ export function templateCreateDocumentFromTemplateFieldMetaDropdownFromJSON(
   );
 }
 
+/** @internal */
+export const TemplateCreateDocumentFromTemplateOverflow9$inboundSchema:
+  z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateOverflow9> = z
+    .nativeEnum(TemplateCreateDocumentFromTemplateOverflow9);
+/** @internal */
+export const TemplateCreateDocumentFromTemplateOverflow9$outboundSchema:
+  z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateOverflow9> =
+    TemplateCreateDocumentFromTemplateOverflow9$inboundSchema;
+
 /** @internal */
 export const TemplateCreateDocumentFromTemplateValue2$inboundSchema: z.ZodType<
   TemplateCreateDocumentFromTemplateValue2,
@@ -2861,6 +3959,8 @@ export const TemplateCreateDocumentFromTemplateFieldMetaCheckbox$inboundSchema:
     required: z.boolean().optional(),
     readOnly: z.boolean().optional(),
     fontSize: z.number().default(12),
+    overflow: TemplateCreateDocumentFromTemplateOverflow9$inboundSchema
+      .optional(),
     type: z.literal("checkbox"),
     values: z.array(
       z.lazy(() => TemplateCreateDocumentFromTemplateValue2$inboundSchema),
@@ -2877,6 +3977,7 @@ export type TemplateCreateDocumentFromTemplateFieldMetaCheckbox$Outbound = {
   required?: boolean | undefined;
   readOnly?: boolean | undefined;
   fontSize: number;
+  overflow?: string | undefined;
   type: "checkbox";
   values?: Array<TemplateCreateDocumentFromTemplateValue2$Outbound> | undefined;
   validationRule?: string | undefined;
@@ -2896,6 +3997,8 @@ export const TemplateCreateDocumentFromTemplateFieldMetaCheckbox$outboundSchema:
     required: z.boolean().optional(),
     readOnly: z.boolean().optional(),
     fontSize: z.number().default(12),
+    overflow: TemplateCreateDocumentFromTemplateOverflow9$outboundSchema
+      .optional(),
     type: z.literal("checkbox"),
     values: z.array(
       z.lazy(() => TemplateCreateDocumentFromTemplateValue2$outboundSchema),
@@ -2932,6 +4035,15 @@ export function templateCreateDocumentFromTemplateFieldMetaCheckboxFromJSON(
   );
 }
 
+/** @internal */
+export const TemplateCreateDocumentFromTemplateOverflow8$inboundSchema:
+  z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateOverflow8> = z
+    .nativeEnum(TemplateCreateDocumentFromTemplateOverflow8);
+/** @internal */
+export const TemplateCreateDocumentFromTemplateOverflow8$outboundSchema:
+  z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateOverflow8> =
+    TemplateCreateDocumentFromTemplateOverflow8$inboundSchema;
+
 /** @internal */
 export const TemplateCreateDocumentFromTemplateValue1$inboundSchema: z.ZodType<
   TemplateCreateDocumentFromTemplateValue1,
@@ -3007,6 +4119,8 @@ export const TemplateCreateDocumentFromTemplateFieldMetaRadio$inboundSchema:
     required: z.boolean().optional(),
     readOnly: z.boolean().optional(),
     fontSize: z.number().default(12),
+    overflow: TemplateCreateDocumentFromTemplateOverflow8$inboundSchema
+      .optional(),
     type: z.literal("radio"),
     values: z.array(
       z.lazy(() => TemplateCreateDocumentFromTemplateValue1$inboundSchema),
@@ -3021,6 +4135,7 @@ export type TemplateCreateDocumentFromTemplateFieldMetaRadio$Outbound = {
   required?: boolean | undefined;
   readOnly?: boolean | undefined;
   fontSize: number;
+  overflow?: string | undefined;
   type: "radio";
   values?: Array<TemplateCreateDocumentFromTemplateValue1$Outbound> | undefined;
   direction: string;
@@ -3038,6 +4153,8 @@ export const TemplateCreateDocumentFromTemplateFieldMetaRadio$outboundSchema:
     required: z.boolean().optional(),
     readOnly: z.boolean().optional(),
     fontSize: z.number().default(12),
+    overflow: TemplateCreateDocumentFromTemplateOverflow8$outboundSchema
+      .optional(),
     type: z.literal("radio"),
     values: z.array(
       z.lazy(() => TemplateCreateDocumentFromTemplateValue1$outboundSchema),
@@ -3072,6 +4189,15 @@ export function templateCreateDocumentFromTemplateFieldMetaRadioFromJSON(
   );
 }
 
+/** @internal */
+export const TemplateCreateDocumentFromTemplateOverflow7$inboundSchema:
+  z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateOverflow7> = z
+    .nativeEnum(TemplateCreateDocumentFromTemplateOverflow7);
+/** @internal */
+export const TemplateCreateDocumentFromTemplateOverflow7$outboundSchema:
+  z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateOverflow7> =
+    TemplateCreateDocumentFromTemplateOverflow7$inboundSchema;
+
 /** @internal */
 export const TemplateCreateDocumentFromTemplateTextAlign6$inboundSchema:
   z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateTextAlign6> = z
@@ -3102,6 +4228,8 @@ export const TemplateCreateDocumentFromTemplateFieldMetaNumber$inboundSchema:
     required: z.boolean().optional(),
     readOnly: z.boolean().optional(),
     fontSize: z.number().default(12),
+    overflow: TemplateCreateDocumentFromTemplateOverflow7$inboundSchema
+      .optional(),
     type: z.literal("number"),
     numberFormat: z.nullable(z.string()).optional(),
     value: z.string().optional(),
@@ -3122,6 +4250,7 @@ export type TemplateCreateDocumentFromTemplateFieldMetaNumber$Outbound = {
   required?: boolean | undefined;
   readOnly?: boolean | undefined;
   fontSize: number;
+  overflow?: string | undefined;
   type: "number";
   numberFormat?: string | null | undefined;
   value?: string | undefined;
@@ -3145,6 +4274,8 @@ export const TemplateCreateDocumentFromTemplateFieldMetaNumber$outboundSchema:
     required: z.boolean().optional(),
     readOnly: z.boolean().optional(),
     fontSize: z.number().default(12),
+    overflow: TemplateCreateDocumentFromTemplateOverflow7$outboundSchema
+      .optional(),
     type: z.literal("number"),
     numberFormat: z.nullable(z.string()).optional(),
     value: z.string().optional(),
@@ -3185,6 +4316,15 @@ export function templateCreateDocumentFromTemplateFieldMetaNumberFromJSON(
   );
 }
 
+/** @internal */
+export const TemplateCreateDocumentFromTemplateOverflow6$inboundSchema:
+  z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateOverflow6> = z
+    .nativeEnum(TemplateCreateDocumentFromTemplateOverflow6);
+/** @internal */
+export const TemplateCreateDocumentFromTemplateOverflow6$outboundSchema:
+  z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateOverflow6> =
+    TemplateCreateDocumentFromTemplateOverflow6$inboundSchema;
+
 /** @internal */
 export const TemplateCreateDocumentFromTemplateTextAlign5$inboundSchema:
   z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateTextAlign5> = z
@@ -3215,6 +4355,8 @@ export const TemplateCreateDocumentFromTemplateFieldMetaText$inboundSchema:
     required: z.boolean().optional(),
     readOnly: z.boolean().optional(),
     fontSize: z.number().default(12),
+    overflow: TemplateCreateDocumentFromTemplateOverflow6$inboundSchema
+      .optional(),
     type: z.literal("text"),
     text: z.string().optional(),
     characterLimit: z.number().optional(),
@@ -3233,6 +4375,7 @@ export type TemplateCreateDocumentFromTemplateFieldMetaText$Outbound = {
   required?: boolean | undefined;
   readOnly?: boolean | undefined;
   fontSize: number;
+  overflow?: string | undefined;
   type: "text";
   text?: string | undefined;
   characterLimit?: number | undefined;
@@ -3254,6 +4397,8 @@ export const TemplateCreateDocumentFromTemplateFieldMetaText$outboundSchema:
     required: z.boolean().optional(),
     readOnly: z.boolean().optional(),
     fontSize: z.number().default(12),
+    overflow: TemplateCreateDocumentFromTemplateOverflow6$outboundSchema
+      .optional(),
     type: z.literal("text"),
     text: z.string().optional(),
     characterLimit: z.number().optional(),
@@ -3292,6 +4437,15 @@ export function templateCreateDocumentFromTemplateFieldMetaTextFromJSON(
   );
 }
 
+/** @internal */
+export const TemplateCreateDocumentFromTemplateOverflow5$inboundSchema:
+  z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateOverflow5> = z
+    .nativeEnum(TemplateCreateDocumentFromTemplateOverflow5);
+/** @internal */
+export const TemplateCreateDocumentFromTemplateOverflow5$outboundSchema:
+  z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateOverflow5> =
+    TemplateCreateDocumentFromTemplateOverflow5$inboundSchema;
+
 /** @internal */
 export const TemplateCreateDocumentFromTemplateTextAlign4$inboundSchema:
   z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateTextAlign4> = z
@@ -3313,6 +4467,9 @@ export const TemplateCreateDocumentFromTemplateFieldMetaDate$inboundSchema:
     required: z.boolean().optional(),
     readOnly: z.boolean().optional(),
     fontSize: z.number().default(12),
+    overflow: TemplateCreateDocumentFromTemplateOverflow5$inboundSchema.default(
+      "auto",
+    ),
     type: z.literal("date"),
     textAlign: TemplateCreateDocumentFromTemplateTextAlign4$inboundSchema
       .optional(),
@@ -3324,6 +4481,7 @@ export type TemplateCreateDocumentFromTemplateFieldMetaDate$Outbound = {
   required?: boolean | undefined;
   readOnly?: boolean | undefined;
   fontSize: number;
+  overflow: string;
   type: "date";
   textAlign?: string | undefined;
 };
@@ -3340,6 +4498,8 @@ export const TemplateCreateDocumentFromTemplateFieldMetaDate$outboundSchema:
     required: z.boolean().optional(),
     readOnly: z.boolean().optional(),
     fontSize: z.number().default(12),
+    overflow: TemplateCreateDocumentFromTemplateOverflow5$outboundSchema
+      .default("auto"),
     type: z.literal("date"),
     textAlign: TemplateCreateDocumentFromTemplateTextAlign4$outboundSchema
       .optional(),
@@ -3371,6 +4531,15 @@ export function templateCreateDocumentFromTemplateFieldMetaDateFromJSON(
   );
 }
 
+/** @internal */
+export const TemplateCreateDocumentFromTemplateOverflow4$inboundSchema:
+  z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateOverflow4> = z
+    .nativeEnum(TemplateCreateDocumentFromTemplateOverflow4);
+/** @internal */
+export const TemplateCreateDocumentFromTemplateOverflow4$outboundSchema:
+  z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateOverflow4> =
+    TemplateCreateDocumentFromTemplateOverflow4$inboundSchema;
+
 /** @internal */
 export const TemplateCreateDocumentFromTemplateTextAlign3$inboundSchema:
   z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateTextAlign3> = z
@@ -3392,6 +4561,9 @@ export const TemplateCreateDocumentFromTemplateFieldMetaEmail$inboundSchema:
     required: z.boolean().optional(),
     readOnly: z.boolean().optional(),
     fontSize: z.number().default(12),
+    overflow: TemplateCreateDocumentFromTemplateOverflow4$inboundSchema.default(
+      "auto",
+    ),
     type: z.literal("email"),
     textAlign: TemplateCreateDocumentFromTemplateTextAlign3$inboundSchema
       .optional(),
@@ -3403,6 +4575,7 @@ export type TemplateCreateDocumentFromTemplateFieldMetaEmail$Outbound = {
   required?: boolean | undefined;
   readOnly?: boolean | undefined;
   fontSize: number;
+  overflow: string;
   type: "email";
   textAlign?: string | undefined;
 };
@@ -3419,6 +4592,8 @@ export const TemplateCreateDocumentFromTemplateFieldMetaEmail$outboundSchema:
     required: z.boolean().optional(),
     readOnly: z.boolean().optional(),
     fontSize: z.number().default(12),
+    overflow: TemplateCreateDocumentFromTemplateOverflow4$outboundSchema
+      .default("auto"),
     type: z.literal("email"),
     textAlign: TemplateCreateDocumentFromTemplateTextAlign3$outboundSchema
       .optional(),
@@ -3450,6 +4625,15 @@ export function templateCreateDocumentFromTemplateFieldMetaEmailFromJSON(
   );
 }
 
+/** @internal */
+export const TemplateCreateDocumentFromTemplateOverflow3$inboundSchema:
+  z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateOverflow3> = z
+    .nativeEnum(TemplateCreateDocumentFromTemplateOverflow3);
+/** @internal */
+export const TemplateCreateDocumentFromTemplateOverflow3$outboundSchema:
+  z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateOverflow3> =
+    TemplateCreateDocumentFromTemplateOverflow3$inboundSchema;
+
 /** @internal */
 export const TemplateCreateDocumentFromTemplateTextAlign2$inboundSchema:
   z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateTextAlign2> = z
@@ -3471,6 +4655,8 @@ export const TemplateCreateDocumentFromTemplateFieldMetaName$inboundSchema:
     required: z.boolean().optional(),
     readOnly: z.boolean().optional(),
     fontSize: z.number().default(12),
+    overflow: TemplateCreateDocumentFromTemplateOverflow3$inboundSchema
+      .optional(),
     type: z.literal("name"),
     textAlign: TemplateCreateDocumentFromTemplateTextAlign2$inboundSchema
       .optional(),
@@ -3482,6 +4668,7 @@ export type TemplateCreateDocumentFromTemplateFieldMetaName$Outbound = {
   required?: boolean | undefined;
   readOnly?: boolean | undefined;
   fontSize: number;
+  overflow?: string | undefined;
   type: "name";
   textAlign?: string | undefined;
 };
@@ -3498,6 +4685,8 @@ export const TemplateCreateDocumentFromTemplateFieldMetaName$outboundSchema:
     required: z.boolean().optional(),
     readOnly: z.boolean().optional(),
     fontSize: z.number().default(12),
+    overflow: TemplateCreateDocumentFromTemplateOverflow3$outboundSchema
+      .optional(),
     type: z.literal("name"),
     textAlign: TemplateCreateDocumentFromTemplateTextAlign2$outboundSchema
       .optional(),
@@ -3529,6 +4718,15 @@ export function templateCreateDocumentFromTemplateFieldMetaNameFromJSON(
   );
 }
 
+/** @internal */
+export const TemplateCreateDocumentFromTemplateOverflow2$inboundSchema:
+  z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateOverflow2> = z
+    .nativeEnum(TemplateCreateDocumentFromTemplateOverflow2);
+/** @internal */
+export const TemplateCreateDocumentFromTemplateOverflow2$outboundSchema:
+  z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateOverflow2> =
+    TemplateCreateDocumentFromTemplateOverflow2$inboundSchema;
+
 /** @internal */
 export const TemplateCreateDocumentFromTemplateTextAlign1$inboundSchema:
   z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateTextAlign1> = z
@@ -3550,6 +4748,8 @@ export const TemplateCreateDocumentFromTemplateFieldMetaInitials$inboundSchema:
     required: z.boolean().optional(),
     readOnly: z.boolean().optional(),
     fontSize: z.number().default(12),
+    overflow: TemplateCreateDocumentFromTemplateOverflow2$inboundSchema
+      .optional(),
     type: z.literal("initials"),
     textAlign: TemplateCreateDocumentFromTemplateTextAlign1$inboundSchema
       .optional(),
@@ -3561,6 +4761,7 @@ export type TemplateCreateDocumentFromTemplateFieldMetaInitials$Outbound = {
   required?: boolean | undefined;
   readOnly?: boolean | undefined;
   fontSize: number;
+  overflow?: string | undefined;
   type: "initials";
   textAlign?: string | undefined;
 };
@@ -3577,6 +4778,8 @@ export const TemplateCreateDocumentFromTemplateFieldMetaInitials$outboundSchema:
     required: z.boolean().optional(),
     readOnly: z.boolean().optional(),
     fontSize: z.number().default(12),
+    overflow: TemplateCreateDocumentFromTemplateOverflow2$outboundSchema
+      .optional(),
     type: z.literal("initials"),
     textAlign: TemplateCreateDocumentFromTemplateTextAlign1$outboundSchema
       .optional(),
@@ -3608,6 +4811,15 @@ export function templateCreateDocumentFromTemplateFieldMetaInitialsFromJSON(
   );
 }
 
+/** @internal */
+export const TemplateCreateDocumentFromTemplateOverflow1$inboundSchema:
+  z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateOverflow1> = z
+    .nativeEnum(TemplateCreateDocumentFromTemplateOverflow1);
+/** @internal */
+export const TemplateCreateDocumentFromTemplateOverflow1$outboundSchema:
+  z.ZodNativeEnum<typeof TemplateCreateDocumentFromTemplateOverflow1> =
+    TemplateCreateDocumentFromTemplateOverflow1$inboundSchema;
+
 /** @internal */
 export const TemplateCreateDocumentFromTemplateFieldMetaSignature$inboundSchema:
   z.ZodType<
@@ -3620,6 +4832,9 @@ export const TemplateCreateDocumentFromTemplateFieldMetaSignature$inboundSchema:
     required: z.boolean().optional(),
     readOnly: z.boolean().optional(),
     fontSize: z.number().default(12),
+    overflow: TemplateCreateDocumentFromTemplateOverflow1$inboundSchema.default(
+      "auto",
+    ),
     type: z.literal("signature"),
   });
 /** @internal */
@@ -3629,6 +4844,7 @@ export type TemplateCreateDocumentFromTemplateFieldMetaSignature$Outbound = {
   required?: boolean | undefined;
   readOnly?: boolean | undefined;
   fontSize: number;
+  overflow: string;
   type: "signature";
 };
 
@@ -3644,6 +4860,8 @@ export const TemplateCreateDocumentFromTemplateFieldMetaSignature$outboundSchema
     required: z.boolean().optional(),
     readOnly: z.boolean().optional(),
     fontSize: z.number().default(12),
+    overflow: TemplateCreateDocumentFromTemplateOverflow1$outboundSchema
+      .default("auto"),
     type: z.literal("signature"),
   });