@documenso/sdk-typescript 0.7.0 → 0.8.0

package/src/models/operations/documentget.ts

@@ -100,8 +100,30 @@ export type DocumentGetEmailSettings = {
   documentCompleted?: boolean | undefined;
   documentDeleted?: boolean | undefined;
   ownerDocumentCompleted?: boolean | undefined;
+  ownerRecipientExpired?: boolean | undefined;
 };
 
+export type DocumentGetEnvelopeExpirationPeriod2 = {
+  disabled: boolean;
+};
+
+export const DocumentGetUnit = {
+  Day: "day",
+  Week: "week",
+  Month: "month",
+  Year: "year",
+} as const;
+export type DocumentGetUnit = ClosedEnum<typeof DocumentGetUnit>;
+
+export type DocumentGetEnvelopeExpirationPeriod1 = {
+  unit: DocumentGetUnit;
+  amount: number;
+};
+
+export type DocumentGetEnvelopeExpirationPeriodUnion =
+  | DocumentGetEnvelopeExpirationPeriod1
+  | DocumentGetEnvelopeExpirationPeriod2;
+
 export type DocumentGetDocumentMeta = {
   signingOrder: DocumentGetSigningOrder;
   distributionMethod: DocumentGetDistributionMethod;
@@ -119,6 +141,10 @@ export type DocumentGetDocumentMeta = {
   emailSettings: DocumentGetEmailSettings | null;
   emailId: string | null;
   emailReplyTo: string | null;
+  envelopeExpirationPeriod:
+    | DocumentGetEnvelopeExpirationPeriod1
+    | DocumentGetEnvelopeExpirationPeriod2
+    | null;
   password?: string | null | undefined;
   documentId?: number | undefined;
 };
@@ -218,6 +244,8 @@ export type DocumentGetRecipient = {
   token: string;
   documentDeletedAt: string | null;
   expired: string | null;
+  expiresAt: string | null;
+  expirationNotifiedAt: string | null;
   signedAt: string | null;
   authOptions: DocumentGetRecipientAuthOptions | null;
   signingOrder: number | null;
@@ -770,6 +798,7 @@ export const DocumentGetEmailSettings$inboundSchema: z.ZodType<
   documentCompleted: z.boolean().default(true),
   documentDeleted: z.boolean().default(true),
   ownerDocumentCompleted: z.boolean().default(true),
+  ownerRecipientExpired: z.boolean().default(true),
 });
 /** @internal */
 export type DocumentGetEmailSettings$Outbound = {
@@ -780,6 +809,7 @@ export type DocumentGetEmailSettings$Outbound = {
   documentCompleted: boolean;
   documentDeleted: boolean;
   ownerDocumentCompleted: boolean;
+  ownerRecipientExpired: boolean;
 };
 
 /** @internal */
@@ -795,6 +825,7 @@ export const DocumentGetEmailSettings$outboundSchema: z.ZodType<
   documentCompleted: z.boolean().default(true),
   documentDeleted: z.boolean().default(true),
   ownerDocumentCompleted: z.boolean().default(true),
+  ownerRecipientExpired: z.boolean().default(true),
 });
 
 export function documentGetEmailSettingsToJSON(
@@ -814,6 +845,152 @@ export function documentGetEmailSettingsFromJSON(
   );
 }
 
+/** @internal */
+export const DocumentGetEnvelopeExpirationPeriod2$inboundSchema: z.ZodType<
+  DocumentGetEnvelopeExpirationPeriod2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  disabled: z.boolean(),
+});
+/** @internal */
+export type DocumentGetEnvelopeExpirationPeriod2$Outbound = {
+  disabled: boolean;
+};
+
+/** @internal */
+export const DocumentGetEnvelopeExpirationPeriod2$outboundSchema: z.ZodType<
+  DocumentGetEnvelopeExpirationPeriod2$Outbound,
+  z.ZodTypeDef,
+  DocumentGetEnvelopeExpirationPeriod2
+> = z.object({
+  disabled: z.boolean(),
+});
+
+export function documentGetEnvelopeExpirationPeriod2ToJSON(
+  documentGetEnvelopeExpirationPeriod2: DocumentGetEnvelopeExpirationPeriod2,
+): string {
+  return JSON.stringify(
+    DocumentGetEnvelopeExpirationPeriod2$outboundSchema.parse(
+      documentGetEnvelopeExpirationPeriod2,
+    ),
+  );
+}
+export function documentGetEnvelopeExpirationPeriod2FromJSON(
+  jsonString: string,
+): SafeParseResult<DocumentGetEnvelopeExpirationPeriod2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DocumentGetEnvelopeExpirationPeriod2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DocumentGetEnvelopeExpirationPeriod2' from JSON`,
+  );
+}
+
+/** @internal */
+export const DocumentGetUnit$inboundSchema: z.ZodNativeEnum<
+  typeof DocumentGetUnit
+> = z.nativeEnum(DocumentGetUnit);
+/** @internal */
+export const DocumentGetUnit$outboundSchema: z.ZodNativeEnum<
+  typeof DocumentGetUnit
+> = DocumentGetUnit$inboundSchema;
+
+/** @internal */
+export const DocumentGetEnvelopeExpirationPeriod1$inboundSchema: z.ZodType<
+  DocumentGetEnvelopeExpirationPeriod1,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  unit: DocumentGetUnit$inboundSchema,
+  amount: z.number().int(),
+});
+/** @internal */
+export type DocumentGetEnvelopeExpirationPeriod1$Outbound = {
+  unit: string;
+  amount: number;
+};
+
+/** @internal */
+export const DocumentGetEnvelopeExpirationPeriod1$outboundSchema: z.ZodType<
+  DocumentGetEnvelopeExpirationPeriod1$Outbound,
+  z.ZodTypeDef,
+  DocumentGetEnvelopeExpirationPeriod1
+> = z.object({
+  unit: DocumentGetUnit$outboundSchema,
+  amount: z.number().int(),
+});
+
+export function documentGetEnvelopeExpirationPeriod1ToJSON(
+  documentGetEnvelopeExpirationPeriod1: DocumentGetEnvelopeExpirationPeriod1,
+): string {
+  return JSON.stringify(
+    DocumentGetEnvelopeExpirationPeriod1$outboundSchema.parse(
+      documentGetEnvelopeExpirationPeriod1,
+    ),
+  );
+}
+export function documentGetEnvelopeExpirationPeriod1FromJSON(
+  jsonString: string,
+): SafeParseResult<DocumentGetEnvelopeExpirationPeriod1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DocumentGetEnvelopeExpirationPeriod1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DocumentGetEnvelopeExpirationPeriod1' from JSON`,
+  );
+}
+
+/** @internal */
+export const DocumentGetEnvelopeExpirationPeriodUnion$inboundSchema: z.ZodType<
+  DocumentGetEnvelopeExpirationPeriodUnion,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => DocumentGetEnvelopeExpirationPeriod1$inboundSchema),
+  z.lazy(() => DocumentGetEnvelopeExpirationPeriod2$inboundSchema),
+]);
+/** @internal */
+export type DocumentGetEnvelopeExpirationPeriodUnion$Outbound =
+  | DocumentGetEnvelopeExpirationPeriod1$Outbound
+  | DocumentGetEnvelopeExpirationPeriod2$Outbound;
+
+/** @internal */
+export const DocumentGetEnvelopeExpirationPeriodUnion$outboundSchema: z.ZodType<
+  DocumentGetEnvelopeExpirationPeriodUnion$Outbound,
+  z.ZodTypeDef,
+  DocumentGetEnvelopeExpirationPeriodUnion
+> = z.union([
+  z.lazy(() => DocumentGetEnvelopeExpirationPeriod1$outboundSchema),
+  z.lazy(() => DocumentGetEnvelopeExpirationPeriod2$outboundSchema),
+]);
+
+export function documentGetEnvelopeExpirationPeriodUnionToJSON(
+  documentGetEnvelopeExpirationPeriodUnion:
+    DocumentGetEnvelopeExpirationPeriodUnion,
+): string {
+  return JSON.stringify(
+    DocumentGetEnvelopeExpirationPeriodUnion$outboundSchema.parse(
+      documentGetEnvelopeExpirationPeriodUnion,
+    ),
+  );
+}
+export function documentGetEnvelopeExpirationPeriodUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  DocumentGetEnvelopeExpirationPeriodUnion,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DocumentGetEnvelopeExpirationPeriodUnion$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'DocumentGetEnvelopeExpirationPeriodUnion' from JSON`,
+  );
+}
+
 /** @internal */
 export const DocumentGetDocumentMeta$inboundSchema: z.ZodType<
   DocumentGetDocumentMeta,
@@ -838,6 +1015,12 @@ export const DocumentGetDocumentMeta$inboundSchema: z.ZodType<
   ),
   emailId: z.nullable(z.string()),
   emailReplyTo: z.nullable(z.string()),
+  envelopeExpirationPeriod: z.nullable(
+    z.union([
+      z.lazy(() => DocumentGetEnvelopeExpirationPeriod1$inboundSchema),
+      z.lazy(() => DocumentGetEnvelopeExpirationPeriod2$inboundSchema),
+    ]),
+  ),
   password: z.nullable(z.string()).default(null),
   documentId: z.number().default(-1),
 });
@@ -859,6 +1042,10 @@ export type DocumentGetDocumentMeta$Outbound = {
   emailSettings: DocumentGetEmailSettings$Outbound | null;
   emailId: string | null;
   emailReplyTo: string | null;
+  envelopeExpirationPeriod:
+    | DocumentGetEnvelopeExpirationPeriod1$Outbound
+    | DocumentGetEnvelopeExpirationPeriod2$Outbound
+    | null;
   password: string | null;
   documentId: number;
 };
@@ -887,6 +1074,12 @@ export const DocumentGetDocumentMeta$outboundSchema: z.ZodType<
   ),
   emailId: z.nullable(z.string()),
   emailReplyTo: z.nullable(z.string()),
+  envelopeExpirationPeriod: z.nullable(
+    z.union([
+      z.lazy(() => DocumentGetEnvelopeExpirationPeriod1$outboundSchema),
+      z.lazy(() => DocumentGetEnvelopeExpirationPeriod2$outboundSchema),
+    ]),
+  ),
   password: z.nullable(z.string()).default(null),
   documentId: z.number().default(-1),
 });
@@ -1149,6 +1342,8 @@ export const DocumentGetRecipient$inboundSchema: z.ZodType<
   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(() => DocumentGetRecipientAuthOptions$inboundSchema),
@@ -1171,6 +1366,8 @@ export type DocumentGetRecipient$Outbound = {
   token: string;
   documentDeletedAt: string | null;
   expired: string | null;
+  expiresAt: string | null;
+  expirationNotifiedAt: string | null;
   signedAt: string | null;
   authOptions: DocumentGetRecipientAuthOptions$Outbound | null;
   signingOrder: number | null;
@@ -1196,6 +1393,8 @@ export const DocumentGetRecipient$outboundSchema: z.ZodType<
   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(() => DocumentGetRecipientAuthOptions$outboundSchema),

package/src/models/operations/documentgetmany.ts

@@ -137,6 +137,8 @@ export type DocumentGetManyRecipient = {
   token: string;
   documentDeletedAt: string | null;
   expired: string | null;
+  expiresAt: string | null;
+  expirationNotifiedAt: string | null;
   signedAt: string | null;
   authOptions: DocumentGetManyRecipientAuthOptions | null;
   signingOrder: number | null;
@@ -503,6 +505,8 @@ export const DocumentGetManyRecipient$inboundSchema: z.ZodType<
   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(() => DocumentGetManyRecipientAuthOptions$inboundSchema),
@@ -525,6 +529,8 @@ export type DocumentGetManyRecipient$Outbound = {
   token: string;
   documentDeletedAt: string | null;
   expired: string | null;
+  expiresAt: string | null;
+  expirationNotifiedAt: string | null;
   signedAt: string | null;
   authOptions: DocumentGetManyRecipientAuthOptions$Outbound | null;
   signingOrder: number | null;
@@ -550,6 +556,8 @@ export const DocumentGetManyRecipient$outboundSchema: z.ZodType<
   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(() => DocumentGetManyRecipientAuthOptions$outboundSchema),

package/src/models/operations/documentupdate.ts

@@ -112,8 +112,30 @@ export type DocumentUpdateEmailSettings = {
   documentCompleted?: boolean | undefined;
   documentDeleted?: boolean | undefined;
   ownerDocumentCompleted?: boolean | undefined;
+  ownerRecipientExpired?: boolean | undefined;
 };
 
+export type DocumentUpdateEnvelopeExpirationPeriod2 = {
+  disabled: boolean;
+};
+
+export const DocumentUpdateUnit = {
+  Day: "day",
+  Week: "week",
+  Month: "month",
+  Year: "year",
+} as const;
+export type DocumentUpdateUnit = ClosedEnum<typeof DocumentUpdateUnit>;
+
+export type DocumentUpdateEnvelopeExpirationPeriod1 = {
+  unit: DocumentUpdateUnit;
+  amount: number;
+};
+
+export type DocumentUpdateEnvelopeExpirationPeriodUnion =
+  | DocumentUpdateEnvelopeExpirationPeriod1
+  | DocumentUpdateEnvelopeExpirationPeriod2;
+
 export type DocumentUpdateMeta = {
   subject?: string | undefined;
   message?: string | undefined;
@@ -130,6 +152,11 @@ export type DocumentUpdateMeta = {
   emailId?: string | null | undefined;
   emailReplyTo?: string | null | undefined;
   emailSettings?: DocumentUpdateEmailSettings | null | undefined;
+  envelopeExpirationPeriod?:
+    | DocumentUpdateEnvelopeExpirationPeriod1
+    | DocumentUpdateEnvelopeExpirationPeriod2
+    | null
+    | undefined;
 };
 
 export type DocumentUpdateRequest = {
@@ -354,6 +381,7 @@ export const DocumentUpdateEmailSettings$inboundSchema: z.ZodType<
   documentCompleted: z.boolean().default(true),
   documentDeleted: z.boolean().default(true),
   ownerDocumentCompleted: z.boolean().default(true),
+  ownerRecipientExpired: z.boolean().default(true),
 });
 /** @internal */
 export type DocumentUpdateEmailSettings$Outbound = {
@@ -364,6 +392,7 @@ export type DocumentUpdateEmailSettings$Outbound = {
   documentCompleted: boolean;
   documentDeleted: boolean;
   ownerDocumentCompleted: boolean;
+  ownerRecipientExpired: boolean;
 };
 
 /** @internal */
@@ -379,6 +408,7 @@ export const DocumentUpdateEmailSettings$outboundSchema: z.ZodType<
   documentCompleted: z.boolean().default(true),
   documentDeleted: z.boolean().default(true),
   ownerDocumentCompleted: z.boolean().default(true),
+  ownerRecipientExpired: z.boolean().default(true),
 });
 
 export function documentUpdateEmailSettingsToJSON(
@@ -400,6 +430,166 @@ export function documentUpdateEmailSettingsFromJSON(
   );
 }
 
+/** @internal */
+export const DocumentUpdateEnvelopeExpirationPeriod2$inboundSchema: z.ZodType<
+  DocumentUpdateEnvelopeExpirationPeriod2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  disabled: z.boolean(),
+});
+/** @internal */
+export type DocumentUpdateEnvelopeExpirationPeriod2$Outbound = {
+  disabled: boolean;
+};
+
+/** @internal */
+export const DocumentUpdateEnvelopeExpirationPeriod2$outboundSchema: z.ZodType<
+  DocumentUpdateEnvelopeExpirationPeriod2$Outbound,
+  z.ZodTypeDef,
+  DocumentUpdateEnvelopeExpirationPeriod2
+> = z.object({
+  disabled: z.boolean(),
+});
+
+export function documentUpdateEnvelopeExpirationPeriod2ToJSON(
+  documentUpdateEnvelopeExpirationPeriod2:
+    DocumentUpdateEnvelopeExpirationPeriod2,
+): string {
+  return JSON.stringify(
+    DocumentUpdateEnvelopeExpirationPeriod2$outboundSchema.parse(
+      documentUpdateEnvelopeExpirationPeriod2,
+    ),
+  );
+}
+export function documentUpdateEnvelopeExpirationPeriod2FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  DocumentUpdateEnvelopeExpirationPeriod2,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DocumentUpdateEnvelopeExpirationPeriod2$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'DocumentUpdateEnvelopeExpirationPeriod2' from JSON`,
+  );
+}
+
+/** @internal */
+export const DocumentUpdateUnit$inboundSchema: z.ZodNativeEnum<
+  typeof DocumentUpdateUnit
+> = z.nativeEnum(DocumentUpdateUnit);
+/** @internal */
+export const DocumentUpdateUnit$outboundSchema: z.ZodNativeEnum<
+  typeof DocumentUpdateUnit
+> = DocumentUpdateUnit$inboundSchema;
+
+/** @internal */
+export const DocumentUpdateEnvelopeExpirationPeriod1$inboundSchema: z.ZodType<
+  DocumentUpdateEnvelopeExpirationPeriod1,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  unit: DocumentUpdateUnit$inboundSchema,
+  amount: z.number().int(),
+});
+/** @internal */
+export type DocumentUpdateEnvelopeExpirationPeriod1$Outbound = {
+  unit: string;
+  amount: number;
+};
+
+/** @internal */
+export const DocumentUpdateEnvelopeExpirationPeriod1$outboundSchema: z.ZodType<
+  DocumentUpdateEnvelopeExpirationPeriod1$Outbound,
+  z.ZodTypeDef,
+  DocumentUpdateEnvelopeExpirationPeriod1
+> = z.object({
+  unit: DocumentUpdateUnit$outboundSchema,
+  amount: z.number().int(),
+});
+
+export function documentUpdateEnvelopeExpirationPeriod1ToJSON(
+  documentUpdateEnvelopeExpirationPeriod1:
+    DocumentUpdateEnvelopeExpirationPeriod1,
+): string {
+  return JSON.stringify(
+    DocumentUpdateEnvelopeExpirationPeriod1$outboundSchema.parse(
+      documentUpdateEnvelopeExpirationPeriod1,
+    ),
+  );
+}
+export function documentUpdateEnvelopeExpirationPeriod1FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  DocumentUpdateEnvelopeExpirationPeriod1,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DocumentUpdateEnvelopeExpirationPeriod1$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'DocumentUpdateEnvelopeExpirationPeriod1' from JSON`,
+  );
+}
+
+/** @internal */
+export const DocumentUpdateEnvelopeExpirationPeriodUnion$inboundSchema:
+  z.ZodType<
+    DocumentUpdateEnvelopeExpirationPeriodUnion,
+    z.ZodTypeDef,
+    unknown
+  > = z.union([
+    z.lazy(() => DocumentUpdateEnvelopeExpirationPeriod1$inboundSchema),
+    z.lazy(() => DocumentUpdateEnvelopeExpirationPeriod2$inboundSchema),
+  ]);
+/** @internal */
+export type DocumentUpdateEnvelopeExpirationPeriodUnion$Outbound =
+  | DocumentUpdateEnvelopeExpirationPeriod1$Outbound
+  | DocumentUpdateEnvelopeExpirationPeriod2$Outbound;
+
+/** @internal */
+export const DocumentUpdateEnvelopeExpirationPeriodUnion$outboundSchema:
+  z.ZodType<
+    DocumentUpdateEnvelopeExpirationPeriodUnion$Outbound,
+    z.ZodTypeDef,
+    DocumentUpdateEnvelopeExpirationPeriodUnion
+  > = z.union([
+    z.lazy(() => DocumentUpdateEnvelopeExpirationPeriod1$outboundSchema),
+    z.lazy(() => DocumentUpdateEnvelopeExpirationPeriod2$outboundSchema),
+  ]);
+
+export function documentUpdateEnvelopeExpirationPeriodUnionToJSON(
+  documentUpdateEnvelopeExpirationPeriodUnion:
+    DocumentUpdateEnvelopeExpirationPeriodUnion,
+): string {
+  return JSON.stringify(
+    DocumentUpdateEnvelopeExpirationPeriodUnion$outboundSchema.parse(
+      documentUpdateEnvelopeExpirationPeriodUnion,
+    ),
+  );
+}
+export function documentUpdateEnvelopeExpirationPeriodUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  DocumentUpdateEnvelopeExpirationPeriodUnion,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DocumentUpdateEnvelopeExpirationPeriodUnion$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'DocumentUpdateEnvelopeExpirationPeriodUnion' from JSON`,
+  );
+}
+
 /** @internal */
 export const DocumentUpdateMeta$inboundSchema: z.ZodType<
   DocumentUpdateMeta,
@@ -423,6 +613,12 @@ export const DocumentUpdateMeta$inboundSchema: z.ZodType<
   emailSettings: z.nullable(
     z.lazy(() => DocumentUpdateEmailSettings$inboundSchema),
   ).optional(),
+  envelopeExpirationPeriod: z.nullable(
+    z.union([
+      z.lazy(() => DocumentUpdateEnvelopeExpirationPeriod1$inboundSchema),
+      z.lazy(() => DocumentUpdateEnvelopeExpirationPeriod2$inboundSchema),
+    ]),
+  ).optional(),
 });
 /** @internal */
 export type DocumentUpdateMeta$Outbound = {
@@ -441,6 +637,11 @@ export type DocumentUpdateMeta$Outbound = {
   emailId?: string | null | undefined;
   emailReplyTo?: string | null | undefined;
   emailSettings?: DocumentUpdateEmailSettings$Outbound | null | undefined;
+  envelopeExpirationPeriod?:
+    | DocumentUpdateEnvelopeExpirationPeriod1$Outbound
+    | DocumentUpdateEnvelopeExpirationPeriod2$Outbound
+    | null
+    | undefined;
 };
 
 /** @internal */
@@ -467,6 +668,12 @@ export const DocumentUpdateMeta$outboundSchema: z.ZodType<
   emailSettings: z.nullable(
     z.lazy(() => DocumentUpdateEmailSettings$outboundSchema),
   ).optional(),
+  envelopeExpirationPeriod: z.nullable(
+    z.union([
+      z.lazy(() => DocumentUpdateEnvelopeExpirationPeriod1$outboundSchema),
+      z.lazy(() => DocumentUpdateEnvelopeExpirationPeriod2$outboundSchema),
+    ]),
+  ).optional(),
 });
 
 export function documentUpdateMetaToJSON(