@documenso/sdk-typescript 0.7.0 → 0.8.1

package/src/models/operations/envelopeupdate.ts

@@ -35,6 +35,13 @@ export type EnvelopeUpdateGlobalActionAuthRequest = ClosedEnum<
   typeof EnvelopeUpdateGlobalActionAuthRequest
 >;
 
+export const TemplateTypeRequest = {
+  Public: "PUBLIC",
+  Private: "PRIVATE",
+  Organisation: "ORGANISATION",
+} as const;
+export type TemplateTypeRequest = ClosedEnum<typeof TemplateTypeRequest>;
+
 export type EnvelopeUpdateData = {
   title?: string | undefined;
   externalId?: string | null | undefined;
@@ -42,18 +49,22 @@ export type EnvelopeUpdateData = {
   globalAccessAuth?: Array<EnvelopeUpdateGlobalAccessAuthRequest> | undefined;
   globalActionAuth?: Array<EnvelopeUpdateGlobalActionAuthRequest> | undefined;
   folderId?: string | null | undefined;
+  templateType?: TemplateTypeRequest | undefined;
 };
 
 export const EnvelopeUpdateDateFormat = {
   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",
@@ -111,6 +122,80 @@ export type EnvelopeUpdateEmailSettings = {
   documentCompleted?: boolean | undefined;
   documentDeleted?: boolean | undefined;
   ownerDocumentCompleted?: boolean | undefined;
+  ownerRecipientExpired?: boolean | undefined;
+  ownerDocumentCreated?: boolean | undefined;
+};
+
+export type EnvelopeUpdateEnvelopeExpirationPeriod2 = {
+  disabled: true;
+};
+
+export const EnvelopeUpdateEnvelopeExpirationPeriodUnit = {
+  Day: "day",
+  Week: "week",
+  Month: "month",
+  Year: "year",
+} as const;
+export type EnvelopeUpdateEnvelopeExpirationPeriodUnit = ClosedEnum<
+  typeof EnvelopeUpdateEnvelopeExpirationPeriodUnit
+>;
+
+export type EnvelopeUpdateEnvelopeExpirationPeriod1 = {
+  unit: EnvelopeUpdateEnvelopeExpirationPeriodUnit;
+  amount: number;
+};
+
+export type EnvelopeUpdateEnvelopeExpirationPeriodUnion =
+  | EnvelopeUpdateEnvelopeExpirationPeriod1
+  | EnvelopeUpdateEnvelopeExpirationPeriod2;
+
+export type EnvelopeUpdateSendAfter2 = {
+  disabled: true;
+};
+
+export const EnvelopeUpdateSendAfterUnit = {
+  Day: "day",
+  Week: "week",
+  Month: "month",
+} as const;
+export type EnvelopeUpdateSendAfterUnit = ClosedEnum<
+  typeof EnvelopeUpdateSendAfterUnit
+>;
+
+export type EnvelopeUpdateSendAfter1 = {
+  unit: EnvelopeUpdateSendAfterUnit;
+  amount: number;
+};
+
+export type EnvelopeUpdateSendAfterUnion =
+  | EnvelopeUpdateSendAfter1
+  | EnvelopeUpdateSendAfter2;
+
+export type EnvelopeUpdateRepeatEvery2 = {
+  disabled: true;
+};
+
+export const EnvelopeUpdateRepeatEveryUnit = {
+  Day: "day",
+  Week: "week",
+  Month: "month",
+} as const;
+export type EnvelopeUpdateRepeatEveryUnit = ClosedEnum<
+  typeof EnvelopeUpdateRepeatEveryUnit
+>;
+
+export type EnvelopeUpdateRepeatEvery1 = {
+  unit: EnvelopeUpdateRepeatEveryUnit;
+  amount: number;
+};
+
+export type EnvelopeUpdateRepeatEveryUnion =
+  | EnvelopeUpdateRepeatEvery1
+  | EnvelopeUpdateRepeatEvery2;
+
+export type EnvelopeUpdateReminderSettings = {
+  sendAfter: EnvelopeUpdateSendAfter1 | EnvelopeUpdateSendAfter2;
+  repeatEvery: EnvelopeUpdateRepeatEvery1 | EnvelopeUpdateRepeatEvery2;
 };
 
 export type EnvelopeUpdateMeta = {
@@ -129,6 +214,12 @@ export type EnvelopeUpdateMeta = {
   emailId?: string | null | undefined;
   emailReplyTo?: string | null | undefined;
   emailSettings?: EnvelopeUpdateEmailSettings | null | undefined;
+  envelopeExpirationPeriod?:
+    | EnvelopeUpdateEnvelopeExpirationPeriod1
+    | EnvelopeUpdateEnvelopeExpirationPeriod2
+    | null
+    | undefined;
+  reminderSettings?: EnvelopeUpdateReminderSettings | null | undefined;
 };
 
 export type EnvelopeUpdateRequest = {
@@ -167,12 +258,13 @@ export type EnvelopeUpdateVisibilityResponse = ClosedEnum<
   typeof EnvelopeUpdateVisibilityResponse
 >;
 
-export const EnvelopeUpdateTemplateType = {
+export const EnvelopeUpdateTemplateTypeResponse = {
   Public: "PUBLIC",
   Private: "PRIVATE",
+  Organisation: "ORGANISATION",
 } as const;
-export type EnvelopeUpdateTemplateType = ClosedEnum<
-  typeof EnvelopeUpdateTemplateType
+export type EnvelopeUpdateTemplateTypeResponse = ClosedEnum<
+  typeof EnvelopeUpdateTemplateTypeResponse
 >;
 
 export const EnvelopeUpdateGlobalAccessAuthResponse = {
@@ -209,7 +301,7 @@ export type EnvelopeUpdateResponse = {
   status: EnvelopeUpdateStatus;
   source: EnvelopeUpdateSource;
   visibility: EnvelopeUpdateVisibilityResponse;
-  templateType: EnvelopeUpdateTemplateType;
+  templateType: EnvelopeUpdateTemplateTypeResponse;
   id: string;
   secondaryId: string;
   externalId: string | null;
@@ -256,6 +348,15 @@ export const EnvelopeUpdateGlobalActionAuthRequest$outboundSchema:
   z.ZodNativeEnum<typeof EnvelopeUpdateGlobalActionAuthRequest> =
     EnvelopeUpdateGlobalActionAuthRequest$inboundSchema;
 
+/** @internal */
+export const TemplateTypeRequest$inboundSchema: z.ZodNativeEnum<
+  typeof TemplateTypeRequest
+> = z.nativeEnum(TemplateTypeRequest);
+/** @internal */
+export const TemplateTypeRequest$outboundSchema: z.ZodNativeEnum<
+  typeof TemplateTypeRequest
+> = TemplateTypeRequest$inboundSchema;
+
 /** @internal */
 export const EnvelopeUpdateData$inboundSchema: z.ZodType<
   EnvelopeUpdateData,
@@ -270,6 +371,7 @@ export const EnvelopeUpdateData$inboundSchema: z.ZodType<
   globalActionAuth: z.array(EnvelopeUpdateGlobalActionAuthRequest$inboundSchema)
     .optional(),
   folderId: z.nullable(z.string()).optional(),
+  templateType: TemplateTypeRequest$inboundSchema.optional(),
 });
 /** @internal */
 export type EnvelopeUpdateData$Outbound = {
@@ -279,6 +381,7 @@ export type EnvelopeUpdateData$Outbound = {
   globalAccessAuth?: Array<string> | undefined;
   globalActionAuth?: Array<string> | undefined;
   folderId?: string | null | undefined;
+  templateType?: string | undefined;
 };
 
 /** @internal */
@@ -297,6 +400,7 @@ export const EnvelopeUpdateData$outboundSchema: z.ZodType<
     EnvelopeUpdateGlobalActionAuthRequest$outboundSchema,
   ).optional(),
   folderId: z.nullable(z.string()).optional(),
+  templateType: TemplateTypeRequest$outboundSchema.optional(),
 });
 
 export function envelopeUpdateDataToJSON(
@@ -365,6 +469,8 @@ export const EnvelopeUpdateEmailSettings$inboundSchema: z.ZodType<
   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 EnvelopeUpdateEmailSettings$Outbound = {
@@ -375,6 +481,8 @@ export type EnvelopeUpdateEmailSettings$Outbound = {
   documentCompleted: boolean;
   documentDeleted: boolean;
   ownerDocumentCompleted: boolean;
+  ownerRecipientExpired: boolean;
+  ownerDocumentCreated: boolean;
 };
 
 /** @internal */
@@ -390,6 +498,8 @@ export const EnvelopeUpdateEmailSettings$outboundSchema: z.ZodType<
   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 envelopeUpdateEmailSettingsToJSON(
@@ -411,6 +521,492 @@ export function envelopeUpdateEmailSettingsFromJSON(
   );
 }
 
+/** @internal */
+export const EnvelopeUpdateEnvelopeExpirationPeriod2$inboundSchema: z.ZodType<
+  EnvelopeUpdateEnvelopeExpirationPeriod2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  disabled: z.literal(true),
+});
+/** @internal */
+export type EnvelopeUpdateEnvelopeExpirationPeriod2$Outbound = {
+  disabled: true;
+};
+
+/** @internal */
+export const EnvelopeUpdateEnvelopeExpirationPeriod2$outboundSchema: z.ZodType<
+  EnvelopeUpdateEnvelopeExpirationPeriod2$Outbound,
+  z.ZodTypeDef,
+  EnvelopeUpdateEnvelopeExpirationPeriod2
+> = z.object({
+  disabled: z.literal(true),
+});
+
+export function envelopeUpdateEnvelopeExpirationPeriod2ToJSON(
+  envelopeUpdateEnvelopeExpirationPeriod2:
+    EnvelopeUpdateEnvelopeExpirationPeriod2,
+): string {
+  return JSON.stringify(
+    EnvelopeUpdateEnvelopeExpirationPeriod2$outboundSchema.parse(
+      envelopeUpdateEnvelopeExpirationPeriod2,
+    ),
+  );
+}
+export function envelopeUpdateEnvelopeExpirationPeriod2FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  EnvelopeUpdateEnvelopeExpirationPeriod2,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      EnvelopeUpdateEnvelopeExpirationPeriod2$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'EnvelopeUpdateEnvelopeExpirationPeriod2' from JSON`,
+  );
+}
+
+/** @internal */
+export const EnvelopeUpdateEnvelopeExpirationPeriodUnit$inboundSchema:
+  z.ZodNativeEnum<typeof EnvelopeUpdateEnvelopeExpirationPeriodUnit> = z
+    .nativeEnum(EnvelopeUpdateEnvelopeExpirationPeriodUnit);
+/** @internal */
+export const EnvelopeUpdateEnvelopeExpirationPeriodUnit$outboundSchema:
+  z.ZodNativeEnum<typeof EnvelopeUpdateEnvelopeExpirationPeriodUnit> =
+    EnvelopeUpdateEnvelopeExpirationPeriodUnit$inboundSchema;
+
+/** @internal */
+export const EnvelopeUpdateEnvelopeExpirationPeriod1$inboundSchema: z.ZodType<
+  EnvelopeUpdateEnvelopeExpirationPeriod1,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  unit: EnvelopeUpdateEnvelopeExpirationPeriodUnit$inboundSchema,
+  amount: z.number().int(),
+});
+/** @internal */
+export type EnvelopeUpdateEnvelopeExpirationPeriod1$Outbound = {
+  unit: string;
+  amount: number;
+};
+
+/** @internal */
+export const EnvelopeUpdateEnvelopeExpirationPeriod1$outboundSchema: z.ZodType<
+  EnvelopeUpdateEnvelopeExpirationPeriod1$Outbound,
+  z.ZodTypeDef,
+  EnvelopeUpdateEnvelopeExpirationPeriod1
+> = z.object({
+  unit: EnvelopeUpdateEnvelopeExpirationPeriodUnit$outboundSchema,
+  amount: z.number().int(),
+});
+
+export function envelopeUpdateEnvelopeExpirationPeriod1ToJSON(
+  envelopeUpdateEnvelopeExpirationPeriod1:
+    EnvelopeUpdateEnvelopeExpirationPeriod1,
+): string {
+  return JSON.stringify(
+    EnvelopeUpdateEnvelopeExpirationPeriod1$outboundSchema.parse(
+      envelopeUpdateEnvelopeExpirationPeriod1,
+    ),
+  );
+}
+export function envelopeUpdateEnvelopeExpirationPeriod1FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  EnvelopeUpdateEnvelopeExpirationPeriod1,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      EnvelopeUpdateEnvelopeExpirationPeriod1$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'EnvelopeUpdateEnvelopeExpirationPeriod1' from JSON`,
+  );
+}
+
+/** @internal */
+export const EnvelopeUpdateEnvelopeExpirationPeriodUnion$inboundSchema:
+  z.ZodType<
+    EnvelopeUpdateEnvelopeExpirationPeriodUnion,
+    z.ZodTypeDef,
+    unknown
+  > = z.union([
+    z.lazy(() => EnvelopeUpdateEnvelopeExpirationPeriod1$inboundSchema),
+    z.lazy(() => EnvelopeUpdateEnvelopeExpirationPeriod2$inboundSchema),
+  ]);
+/** @internal */
+export type EnvelopeUpdateEnvelopeExpirationPeriodUnion$Outbound =
+  | EnvelopeUpdateEnvelopeExpirationPeriod1$Outbound
+  | EnvelopeUpdateEnvelopeExpirationPeriod2$Outbound;
+
+/** @internal */
+export const EnvelopeUpdateEnvelopeExpirationPeriodUnion$outboundSchema:
+  z.ZodType<
+    EnvelopeUpdateEnvelopeExpirationPeriodUnion$Outbound,
+    z.ZodTypeDef,
+    EnvelopeUpdateEnvelopeExpirationPeriodUnion
+  > = z.union([
+    z.lazy(() => EnvelopeUpdateEnvelopeExpirationPeriod1$outboundSchema),
+    z.lazy(() => EnvelopeUpdateEnvelopeExpirationPeriod2$outboundSchema),
+  ]);
+
+export function envelopeUpdateEnvelopeExpirationPeriodUnionToJSON(
+  envelopeUpdateEnvelopeExpirationPeriodUnion:
+    EnvelopeUpdateEnvelopeExpirationPeriodUnion,
+): string {
+  return JSON.stringify(
+    EnvelopeUpdateEnvelopeExpirationPeriodUnion$outboundSchema.parse(
+      envelopeUpdateEnvelopeExpirationPeriodUnion,
+    ),
+  );
+}
+export function envelopeUpdateEnvelopeExpirationPeriodUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  EnvelopeUpdateEnvelopeExpirationPeriodUnion,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      EnvelopeUpdateEnvelopeExpirationPeriodUnion$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'EnvelopeUpdateEnvelopeExpirationPeriodUnion' from JSON`,
+  );
+}
+
+/** @internal */
+export const EnvelopeUpdateSendAfter2$inboundSchema: z.ZodType<
+  EnvelopeUpdateSendAfter2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  disabled: z.literal(true),
+});
+/** @internal */
+export type EnvelopeUpdateSendAfter2$Outbound = {
+  disabled: true;
+};
+
+/** @internal */
+export const EnvelopeUpdateSendAfter2$outboundSchema: z.ZodType<
+  EnvelopeUpdateSendAfter2$Outbound,
+  z.ZodTypeDef,
+  EnvelopeUpdateSendAfter2
+> = z.object({
+  disabled: z.literal(true),
+});
+
+export function envelopeUpdateSendAfter2ToJSON(
+  envelopeUpdateSendAfter2: EnvelopeUpdateSendAfter2,
+): string {
+  return JSON.stringify(
+    EnvelopeUpdateSendAfter2$outboundSchema.parse(envelopeUpdateSendAfter2),
+  );
+}
+export function envelopeUpdateSendAfter2FromJSON(
+  jsonString: string,
+): SafeParseResult<EnvelopeUpdateSendAfter2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EnvelopeUpdateSendAfter2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EnvelopeUpdateSendAfter2' from JSON`,
+  );
+}
+
+/** @internal */
+export const EnvelopeUpdateSendAfterUnit$inboundSchema: z.ZodNativeEnum<
+  typeof EnvelopeUpdateSendAfterUnit
+> = z.nativeEnum(EnvelopeUpdateSendAfterUnit);
+/** @internal */
+export const EnvelopeUpdateSendAfterUnit$outboundSchema: z.ZodNativeEnum<
+  typeof EnvelopeUpdateSendAfterUnit
+> = EnvelopeUpdateSendAfterUnit$inboundSchema;
+
+/** @internal */
+export const EnvelopeUpdateSendAfter1$inboundSchema: z.ZodType<
+  EnvelopeUpdateSendAfter1,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  unit: EnvelopeUpdateSendAfterUnit$inboundSchema,
+  amount: z.number().int(),
+});
+/** @internal */
+export type EnvelopeUpdateSendAfter1$Outbound = {
+  unit: string;
+  amount: number;
+};
+
+/** @internal */
+export const EnvelopeUpdateSendAfter1$outboundSchema: z.ZodType<
+  EnvelopeUpdateSendAfter1$Outbound,
+  z.ZodTypeDef,
+  EnvelopeUpdateSendAfter1
+> = z.object({
+  unit: EnvelopeUpdateSendAfterUnit$outboundSchema,
+  amount: z.number().int(),
+});
+
+export function envelopeUpdateSendAfter1ToJSON(
+  envelopeUpdateSendAfter1: EnvelopeUpdateSendAfter1,
+): string {
+  return JSON.stringify(
+    EnvelopeUpdateSendAfter1$outboundSchema.parse(envelopeUpdateSendAfter1),
+  );
+}
+export function envelopeUpdateSendAfter1FromJSON(
+  jsonString: string,
+): SafeParseResult<EnvelopeUpdateSendAfter1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EnvelopeUpdateSendAfter1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EnvelopeUpdateSendAfter1' from JSON`,
+  );
+}
+
+/** @internal */
+export const EnvelopeUpdateSendAfterUnion$inboundSchema: z.ZodType<
+  EnvelopeUpdateSendAfterUnion,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => EnvelopeUpdateSendAfter1$inboundSchema),
+  z.lazy(() => EnvelopeUpdateSendAfter2$inboundSchema),
+]);
+/** @internal */
+export type EnvelopeUpdateSendAfterUnion$Outbound =
+  | EnvelopeUpdateSendAfter1$Outbound
+  | EnvelopeUpdateSendAfter2$Outbound;
+
+/** @internal */
+export const EnvelopeUpdateSendAfterUnion$outboundSchema: z.ZodType<
+  EnvelopeUpdateSendAfterUnion$Outbound,
+  z.ZodTypeDef,
+  EnvelopeUpdateSendAfterUnion
+> = z.union([
+  z.lazy(() => EnvelopeUpdateSendAfter1$outboundSchema),
+  z.lazy(() => EnvelopeUpdateSendAfter2$outboundSchema),
+]);
+
+export function envelopeUpdateSendAfterUnionToJSON(
+  envelopeUpdateSendAfterUnion: EnvelopeUpdateSendAfterUnion,
+): string {
+  return JSON.stringify(
+    EnvelopeUpdateSendAfterUnion$outboundSchema.parse(
+      envelopeUpdateSendAfterUnion,
+    ),
+  );
+}
+export function envelopeUpdateSendAfterUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<EnvelopeUpdateSendAfterUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EnvelopeUpdateSendAfterUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EnvelopeUpdateSendAfterUnion' from JSON`,
+  );
+}
+
+/** @internal */
+export const EnvelopeUpdateRepeatEvery2$inboundSchema: z.ZodType<
+  EnvelopeUpdateRepeatEvery2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  disabled: z.literal(true),
+});
+/** @internal */
+export type EnvelopeUpdateRepeatEvery2$Outbound = {
+  disabled: true;
+};
+
+/** @internal */
+export const EnvelopeUpdateRepeatEvery2$outboundSchema: z.ZodType<
+  EnvelopeUpdateRepeatEvery2$Outbound,
+  z.ZodTypeDef,
+  EnvelopeUpdateRepeatEvery2
+> = z.object({
+  disabled: z.literal(true),
+});
+
+export function envelopeUpdateRepeatEvery2ToJSON(
+  envelopeUpdateRepeatEvery2: EnvelopeUpdateRepeatEvery2,
+): string {
+  return JSON.stringify(
+    EnvelopeUpdateRepeatEvery2$outboundSchema.parse(envelopeUpdateRepeatEvery2),
+  );
+}
+export function envelopeUpdateRepeatEvery2FromJSON(
+  jsonString: string,
+): SafeParseResult<EnvelopeUpdateRepeatEvery2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EnvelopeUpdateRepeatEvery2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EnvelopeUpdateRepeatEvery2' from JSON`,
+  );
+}
+
+/** @internal */
+export const EnvelopeUpdateRepeatEveryUnit$inboundSchema: z.ZodNativeEnum<
+  typeof EnvelopeUpdateRepeatEveryUnit
+> = z.nativeEnum(EnvelopeUpdateRepeatEveryUnit);
+/** @internal */
+export const EnvelopeUpdateRepeatEveryUnit$outboundSchema: z.ZodNativeEnum<
+  typeof EnvelopeUpdateRepeatEveryUnit
+> = EnvelopeUpdateRepeatEveryUnit$inboundSchema;
+
+/** @internal */
+export const EnvelopeUpdateRepeatEvery1$inboundSchema: z.ZodType<
+  EnvelopeUpdateRepeatEvery1,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  unit: EnvelopeUpdateRepeatEveryUnit$inboundSchema,
+  amount: z.number().int(),
+});
+/** @internal */
+export type EnvelopeUpdateRepeatEvery1$Outbound = {
+  unit: string;
+  amount: number;
+};
+
+/** @internal */
+export const EnvelopeUpdateRepeatEvery1$outboundSchema: z.ZodType<
+  EnvelopeUpdateRepeatEvery1$Outbound,
+  z.ZodTypeDef,
+  EnvelopeUpdateRepeatEvery1
+> = z.object({
+  unit: EnvelopeUpdateRepeatEveryUnit$outboundSchema,
+  amount: z.number().int(),
+});
+
+export function envelopeUpdateRepeatEvery1ToJSON(
+  envelopeUpdateRepeatEvery1: EnvelopeUpdateRepeatEvery1,
+): string {
+  return JSON.stringify(
+    EnvelopeUpdateRepeatEvery1$outboundSchema.parse(envelopeUpdateRepeatEvery1),
+  );
+}
+export function envelopeUpdateRepeatEvery1FromJSON(
+  jsonString: string,
+): SafeParseResult<EnvelopeUpdateRepeatEvery1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EnvelopeUpdateRepeatEvery1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EnvelopeUpdateRepeatEvery1' from JSON`,
+  );
+}
+
+/** @internal */
+export const EnvelopeUpdateRepeatEveryUnion$inboundSchema: z.ZodType<
+  EnvelopeUpdateRepeatEveryUnion,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => EnvelopeUpdateRepeatEvery1$inboundSchema),
+  z.lazy(() => EnvelopeUpdateRepeatEvery2$inboundSchema),
+]);
+/** @internal */
+export type EnvelopeUpdateRepeatEveryUnion$Outbound =
+  | EnvelopeUpdateRepeatEvery1$Outbound
+  | EnvelopeUpdateRepeatEvery2$Outbound;
+
+/** @internal */
+export const EnvelopeUpdateRepeatEveryUnion$outboundSchema: z.ZodType<
+  EnvelopeUpdateRepeatEveryUnion$Outbound,
+  z.ZodTypeDef,
+  EnvelopeUpdateRepeatEveryUnion
+> = z.union([
+  z.lazy(() => EnvelopeUpdateRepeatEvery1$outboundSchema),
+  z.lazy(() => EnvelopeUpdateRepeatEvery2$outboundSchema),
+]);
+
+export function envelopeUpdateRepeatEveryUnionToJSON(
+  envelopeUpdateRepeatEveryUnion: EnvelopeUpdateRepeatEveryUnion,
+): string {
+  return JSON.stringify(
+    EnvelopeUpdateRepeatEveryUnion$outboundSchema.parse(
+      envelopeUpdateRepeatEveryUnion,
+    ),
+  );
+}
+export function envelopeUpdateRepeatEveryUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<EnvelopeUpdateRepeatEveryUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EnvelopeUpdateRepeatEveryUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EnvelopeUpdateRepeatEveryUnion' from JSON`,
+  );
+}
+
+/** @internal */
+export const EnvelopeUpdateReminderSettings$inboundSchema: z.ZodType<
+  EnvelopeUpdateReminderSettings,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  sendAfter: z.union([
+    z.lazy(() => EnvelopeUpdateSendAfter1$inboundSchema),
+    z.lazy(() => EnvelopeUpdateSendAfter2$inboundSchema),
+  ]),
+  repeatEvery: z.union([
+    z.lazy(() => EnvelopeUpdateRepeatEvery1$inboundSchema),
+    z.lazy(() => EnvelopeUpdateRepeatEvery2$inboundSchema),
+  ]),
+});
+/** @internal */
+export type EnvelopeUpdateReminderSettings$Outbound = {
+  sendAfter:
+    | EnvelopeUpdateSendAfter1$Outbound
+    | EnvelopeUpdateSendAfter2$Outbound;
+  repeatEvery:
+    | EnvelopeUpdateRepeatEvery1$Outbound
+    | EnvelopeUpdateRepeatEvery2$Outbound;
+};
+
+/** @internal */
+export const EnvelopeUpdateReminderSettings$outboundSchema: z.ZodType<
+  EnvelopeUpdateReminderSettings$Outbound,
+  z.ZodTypeDef,
+  EnvelopeUpdateReminderSettings
+> = z.object({
+  sendAfter: z.union([
+    z.lazy(() => EnvelopeUpdateSendAfter1$outboundSchema),
+    z.lazy(() => EnvelopeUpdateSendAfter2$outboundSchema),
+  ]),
+  repeatEvery: z.union([
+    z.lazy(() => EnvelopeUpdateRepeatEvery1$outboundSchema),
+    z.lazy(() => EnvelopeUpdateRepeatEvery2$outboundSchema),
+  ]),
+});
+
+export function envelopeUpdateReminderSettingsToJSON(
+  envelopeUpdateReminderSettings: EnvelopeUpdateReminderSettings,
+): string {
+  return JSON.stringify(
+    EnvelopeUpdateReminderSettings$outboundSchema.parse(
+      envelopeUpdateReminderSettings,
+    ),
+  );
+}
+export function envelopeUpdateReminderSettingsFromJSON(
+  jsonString: string,
+): SafeParseResult<EnvelopeUpdateReminderSettings, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EnvelopeUpdateReminderSettings$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EnvelopeUpdateReminderSettings' from JSON`,
+  );
+}
+
 /** @internal */
 export const EnvelopeUpdateMeta$inboundSchema: z.ZodType<
   EnvelopeUpdateMeta,
@@ -434,6 +1030,15 @@ export const EnvelopeUpdateMeta$inboundSchema: z.ZodType<
   emailSettings: z.nullable(
     z.lazy(() => EnvelopeUpdateEmailSettings$inboundSchema),
   ).optional(),
+  envelopeExpirationPeriod: z.nullable(
+    z.union([
+      z.lazy(() => EnvelopeUpdateEnvelopeExpirationPeriod1$inboundSchema),
+      z.lazy(() => EnvelopeUpdateEnvelopeExpirationPeriod2$inboundSchema),
+    ]),
+  ).optional(),
+  reminderSettings: z.nullable(
+    z.lazy(() => EnvelopeUpdateReminderSettings$inboundSchema),
+  ).optional(),
 });
 /** @internal */
 export type EnvelopeUpdateMeta$Outbound = {
@@ -452,6 +1057,12 @@ export type EnvelopeUpdateMeta$Outbound = {
   emailId?: string | null | undefined;
   emailReplyTo?: string | null | undefined;
   emailSettings?: EnvelopeUpdateEmailSettings$Outbound | null | undefined;
+  envelopeExpirationPeriod?:
+    | EnvelopeUpdateEnvelopeExpirationPeriod1$Outbound
+    | EnvelopeUpdateEnvelopeExpirationPeriod2$Outbound
+    | null
+    | undefined;
+  reminderSettings?: EnvelopeUpdateReminderSettings$Outbound | null | undefined;
 };
 
 /** @internal */
@@ -478,6 +1089,15 @@ export const EnvelopeUpdateMeta$outboundSchema: z.ZodType<
   emailSettings: z.nullable(
     z.lazy(() => EnvelopeUpdateEmailSettings$outboundSchema),
   ).optional(),
+  envelopeExpirationPeriod: z.nullable(
+    z.union([
+      z.lazy(() => EnvelopeUpdateEnvelopeExpirationPeriod1$outboundSchema),
+      z.lazy(() => EnvelopeUpdateEnvelopeExpirationPeriod2$outboundSchema),
+    ]),
+  ).optional(),
+  reminderSettings: z.nullable(
+    z.lazy(() => EnvelopeUpdateReminderSettings$outboundSchema),
+  ).optional(),
 });
 
 export function envelopeUpdateMetaToJSON(
@@ -579,13 +1199,13 @@ export const EnvelopeUpdateVisibilityResponse$outboundSchema: z.ZodNativeEnum<
 > = EnvelopeUpdateVisibilityResponse$inboundSchema;
 
 /** @internal */
-export const EnvelopeUpdateTemplateType$inboundSchema: z.ZodNativeEnum<
-  typeof EnvelopeUpdateTemplateType
-> = z.nativeEnum(EnvelopeUpdateTemplateType);
+export const EnvelopeUpdateTemplateTypeResponse$inboundSchema: z.ZodNativeEnum<
+  typeof EnvelopeUpdateTemplateTypeResponse
+> = z.nativeEnum(EnvelopeUpdateTemplateTypeResponse);
 /** @internal */
-export const EnvelopeUpdateTemplateType$outboundSchema: z.ZodNativeEnum<
-  typeof EnvelopeUpdateTemplateType
-> = EnvelopeUpdateTemplateType$inboundSchema;
+export const EnvelopeUpdateTemplateTypeResponse$outboundSchema: z.ZodNativeEnum<
+  typeof EnvelopeUpdateTemplateTypeResponse
+> = EnvelopeUpdateTemplateTypeResponse$inboundSchema;
 
 /** @internal */
 export const EnvelopeUpdateGlobalAccessAuthResponse$inboundSchema:
@@ -701,7 +1321,7 @@ export const EnvelopeUpdateResponse$inboundSchema: z.ZodType<
   status: EnvelopeUpdateStatus$inboundSchema,
   source: EnvelopeUpdateSource$inboundSchema,
   visibility: EnvelopeUpdateVisibilityResponse$inboundSchema,
-  templateType: EnvelopeUpdateTemplateType$inboundSchema,
+  templateType: EnvelopeUpdateTemplateTypeResponse$inboundSchema,
   id: z.string(),
   secondaryId: z.string(),
   externalId: z.nullable(z.string()),
@@ -758,7 +1378,7 @@ export const EnvelopeUpdateResponse$outboundSchema: z.ZodType<
   status: EnvelopeUpdateStatus$outboundSchema,
   source: EnvelopeUpdateSource$outboundSchema,
   visibility: EnvelopeUpdateVisibilityResponse$outboundSchema,
-  templateType: EnvelopeUpdateTemplateType$outboundSchema,
+  templateType: EnvelopeUpdateTemplateTypeResponse$outboundSchema,
   id: z.string(),
   secondaryId: z.string(),
   externalId: z.nullable(z.string()),