@unified-api/typescript-sdk 2.72.4 → 2.73.0

package/src/sdk/models/shared/scimaddress.ts

@@ -4,7 +4,11 @@
 
 import * as z from "zod";
 import { safeParse } from "../../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
@@ -13,7 +17,7 @@ export const ScimAddressType = {
   Home: "home",
   Other: "other",
 } as const;
-export type ScimAddressType = ClosedEnum<typeof ScimAddressType>;
+export type ScimAddressType = OpenEnum<typeof ScimAddressType>;
 
 export type ScimAddress = {
   country?: string | undefined;
@@ -26,14 +30,25 @@ export type ScimAddress = {
 };
 
 /** @internal */
-export const ScimAddressType$inboundSchema: z.ZodNativeEnum<
-  typeof ScimAddressType
-> = z.nativeEnum(ScimAddressType);
+export const ScimAddressType$inboundSchema: z.ZodType<
+  ScimAddressType,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ScimAddressType),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ScimAddressType$outboundSchema: z.ZodNativeEnum<
-  typeof ScimAddressType
-> = ScimAddressType$inboundSchema;
+export const ScimAddressType$outboundSchema: z.ZodType<
+  ScimAddressType,
+  z.ZodTypeDef,
+  ScimAddressType
+> = z.union([
+  z.nativeEnum(ScimAddressType),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/sdk/models/shared/scimemail.ts

@@ -4,7 +4,11 @@
 
 import * as z from "zod";
 import { safeParse } from "../../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
@@ -13,7 +17,7 @@ export const ScimEmailType = {
   Home: "home",
   Other: "other",
 } as const;
-export type ScimEmailType = ClosedEnum<typeof ScimEmailType>;
+export type ScimEmailType = OpenEnum<typeof ScimEmailType>;
 
 export type ScimEmail = {
   display?: string | undefined;
@@ -23,14 +27,25 @@ export type ScimEmail = {
 };
 
 /** @internal */
-export const ScimEmailType$inboundSchema: z.ZodNativeEnum<
-  typeof ScimEmailType
-> = z.nativeEnum(ScimEmailType);
+export const ScimEmailType$inboundSchema: z.ZodType<
+  ScimEmailType,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ScimEmailType),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ScimEmailType$outboundSchema: z.ZodNativeEnum<
-  typeof ScimEmailType
-> = ScimEmailType$inboundSchema;
+export const ScimEmailType$outboundSchema: z.ZodType<
+  ScimEmailType,
+  z.ZodTypeDef,
+  ScimEmailType
+> = z.union([
+  z.nativeEnum(ScimEmailType),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/sdk/models/shared/scimgroupmember.ts

@@ -5,7 +5,11 @@
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
 import { safeParse } from "../../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
@@ -13,13 +17,13 @@ export const Operation = {
   Add: "add",
   Delete: "delete",
 } as const;
-export type Operation = ClosedEnum<typeof Operation>;
+export type Operation = OpenEnum<typeof Operation>;
 
 export const ScimGroupMemberType = {
   User: "User",
   Group: "Group",
 } as const;
-export type ScimGroupMemberType = ClosedEnum<typeof ScimGroupMemberType>;
+export type ScimGroupMemberType = OpenEnum<typeof ScimGroupMemberType>;
 
 export type ScimGroupMember = {
   dollarRef?: string | undefined;
@@ -30,12 +34,25 @@ export type ScimGroupMember = {
 };
 
 /** @internal */
-export const Operation$inboundSchema: z.ZodNativeEnum<typeof Operation> = z
-  .nativeEnum(Operation);
+export const Operation$inboundSchema: z.ZodType<
+  Operation,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(Operation),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const Operation$outboundSchema: z.ZodNativeEnum<typeof Operation> =
-  Operation$inboundSchema;
+export const Operation$outboundSchema: z.ZodType<
+  Operation,
+  z.ZodTypeDef,
+  Operation
+> = z.union([
+  z.nativeEnum(Operation),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal
@@ -49,14 +66,25 @@ export namespace Operation$ {
 }
 
 /** @internal */
-export const ScimGroupMemberType$inboundSchema: z.ZodNativeEnum<
-  typeof ScimGroupMemberType
-> = z.nativeEnum(ScimGroupMemberType);
+export const ScimGroupMemberType$inboundSchema: z.ZodType<
+  ScimGroupMemberType,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ScimGroupMemberType),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ScimGroupMemberType$outboundSchema: z.ZodNativeEnum<
-  typeof ScimGroupMemberType
-> = ScimGroupMemberType$inboundSchema;
+export const ScimGroupMemberType$outboundSchema: z.ZodType<
+  ScimGroupMemberType,
+  z.ZodTypeDef,
+  ScimGroupMemberType
+> = z.union([
+  z.nativeEnum(ScimGroupMemberType),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/sdk/models/shared/scimims.ts

@@ -4,7 +4,11 @@
 
 import * as z from "zod";
 import { safeParse } from "../../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
@@ -18,7 +22,7 @@ export const ScimImsType = {
   Qq: "qq",
   Yahoo: "yahoo",
 } as const;
-export type ScimImsType = ClosedEnum<typeof ScimImsType>;
+export type ScimImsType = OpenEnum<typeof ScimImsType>;
 
 export type ScimIms = {
   display?: string | undefined;
@@ -28,12 +32,25 @@ export type ScimIms = {
 };
 
 /** @internal */
-export const ScimImsType$inboundSchema: z.ZodNativeEnum<typeof ScimImsType> = z
-  .nativeEnum(ScimImsType);
+export const ScimImsType$inboundSchema: z.ZodType<
+  ScimImsType,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ScimImsType),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ScimImsType$outboundSchema: z.ZodNativeEnum<typeof ScimImsType> =
-  ScimImsType$inboundSchema;
+export const ScimImsType$outboundSchema: z.ZodType<
+  ScimImsType,
+  z.ZodTypeDef,
+  ScimImsType
+> = z.union([
+  z.nativeEnum(ScimImsType),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/sdk/models/shared/scimmanager.ts

@@ -5,7 +5,11 @@
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
 import { safeParse } from "../../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
@@ -13,7 +17,7 @@ export const ScimManagerType = {
   Direct: "direct",
   Indirect: "indirect",
 } as const;
-export type ScimManagerType = ClosedEnum<typeof ScimManagerType>;
+export type ScimManagerType = OpenEnum<typeof ScimManagerType>;
 
 /**
  * "id" attribute of another User.
@@ -27,14 +31,25 @@ export type ScimManager = {
 };
 
 /** @internal */
-export const ScimManagerType$inboundSchema: z.ZodNativeEnum<
-  typeof ScimManagerType
-> = z.nativeEnum(ScimManagerType);
+export const ScimManagerType$inboundSchema: z.ZodType<
+  ScimManagerType,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ScimManagerType),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ScimManagerType$outboundSchema: z.ZodNativeEnum<
-  typeof ScimManagerType
-> = ScimManagerType$inboundSchema;
+export const ScimManagerType$outboundSchema: z.ZodType<
+  ScimManagerType,
+  z.ZodTypeDef,
+  ScimManagerType
+> = z.union([
+  z.nativeEnum(ScimManagerType),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/sdk/models/shared/scimphonenumber.ts

@@ -4,7 +4,11 @@
 
 import * as z from "zod";
 import { safeParse } from "../../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
@@ -16,7 +20,7 @@ export const ScimPhoneNumberType = {
   Fax: "fax",
   Pager: "pager",
 } as const;
-export type ScimPhoneNumberType = ClosedEnum<typeof ScimPhoneNumberType>;
+export type ScimPhoneNumberType = OpenEnum<typeof ScimPhoneNumberType>;
 
 export type ScimPhoneNumber = {
   display?: string | undefined;
@@ -26,14 +30,25 @@ export type ScimPhoneNumber = {
 };
 
 /** @internal */
-export const ScimPhoneNumberType$inboundSchema: z.ZodNativeEnum<
-  typeof ScimPhoneNumberType
-> = z.nativeEnum(ScimPhoneNumberType);
+export const ScimPhoneNumberType$inboundSchema: z.ZodType<
+  ScimPhoneNumberType,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ScimPhoneNumberType),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ScimPhoneNumberType$outboundSchema: z.ZodNativeEnum<
-  typeof ScimPhoneNumberType
-> = ScimPhoneNumberType$inboundSchema;
+export const ScimPhoneNumberType$outboundSchema: z.ZodType<
+  ScimPhoneNumberType,
+  z.ZodTypeDef,
+  ScimPhoneNumberType
+> = z.union([
+  z.nativeEnum(ScimPhoneNumberType),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/sdk/models/shared/scimphoto.ts

@@ -4,7 +4,11 @@
 
 import * as z from "zod";
 import { safeParse } from "../../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
@@ -12,7 +16,7 @@ export const ScimPhotoType = {
   Photo: "photo",
   Thumbnail: "thumbnail",
 } as const;
-export type ScimPhotoType = ClosedEnum<typeof ScimPhotoType>;
+export type ScimPhotoType = OpenEnum<typeof ScimPhotoType>;
 
 export type ScimPhoto = {
   display?: string | undefined;
@@ -22,14 +26,25 @@ export type ScimPhoto = {
 };
 
 /** @internal */
-export const ScimPhotoType$inboundSchema: z.ZodNativeEnum<
-  typeof ScimPhotoType
-> = z.nativeEnum(ScimPhotoType);
+export const ScimPhotoType$inboundSchema: z.ZodType<
+  ScimPhotoType,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ScimPhotoType),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ScimPhotoType$outboundSchema: z.ZodNativeEnum<
-  typeof ScimPhotoType
-> = ScimPhotoType$inboundSchema;
+export const ScimPhotoType$outboundSchema: z.ZodType<
+  ScimPhotoType,
+  z.ZodTypeDef,
+  ScimPhotoType
+> = z.union([
+  z.nativeEnum(ScimPhotoType),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/sdk/models/shared/scimusergroups.ts

@@ -5,7 +5,11 @@
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
 import { safeParse } from "../../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
@@ -13,7 +17,7 @@ export const ScimUserGroupsType = {
   Direct: "direct",
   Indirect: "indirect",
 } as const;
-export type ScimUserGroupsType = ClosedEnum<typeof ScimUserGroupsType>;
+export type ScimUserGroupsType = OpenEnum<typeof ScimUserGroupsType>;
 
 export type ScimUserGroups = {
   dollarRef?: string | undefined;
@@ -23,14 +27,25 @@ export type ScimUserGroups = {
 };
 
 /** @internal */
-export const ScimUserGroupsType$inboundSchema: z.ZodNativeEnum<
-  typeof ScimUserGroupsType
-> = z.nativeEnum(ScimUserGroupsType);
+export const ScimUserGroupsType$inboundSchema: z.ZodType<
+  ScimUserGroupsType,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ScimUserGroupsType),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ScimUserGroupsType$outboundSchema: z.ZodNativeEnum<
-  typeof ScimUserGroupsType
-> = ScimUserGroupsType$inboundSchema;
+export const ScimUserGroupsType$outboundSchema: z.ZodType<
+  ScimUserGroupsType,
+  z.ZodTypeDef,
+  ScimUserGroupsType
+> = z.union([
+  z.nativeEnum(ScimUserGroupsType),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/sdk/models/shared/storagefile.ts

@@ -5,7 +5,11 @@
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
 import { safeParse } from "../../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
@@ -19,7 +23,7 @@ export const StorageFileType = {
   File: "FILE",
   Folder: "FOLDER",
 } as const;
-export type StorageFileType = ClosedEnum<typeof StorageFileType>;
+export type StorageFileType = OpenEnum<typeof StorageFileType>;
 
 export type StorageFile = {
   createdAt?: Date | undefined;
@@ -42,14 +46,25 @@ export type StorageFile = {
 };
 
 /** @internal */
-export const StorageFileType$inboundSchema: z.ZodNativeEnum<
-  typeof StorageFileType
-> = z.nativeEnum(StorageFileType);
+export const StorageFileType$inboundSchema: z.ZodType<
+  StorageFileType,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(StorageFileType),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const StorageFileType$outboundSchema: z.ZodNativeEnum<
-  typeof StorageFileType
-> = StorageFileType$inboundSchema;
+export const StorageFileType$outboundSchema: z.ZodType<
+  StorageFileType,
+  z.ZodTypeDef,
+  StorageFileType
+> = z.union([
+  z.nativeEnum(StorageFileType),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/sdk/models/shared/taskproject.ts

@@ -12,6 +12,7 @@ export type TaskProject = {
   createdAt?: Date | undefined;
   description?: string | undefined;
   groupIds?: Array<string> | undefined;
+  hasChildren?: boolean | undefined;
   hasTasks?: boolean | undefined;
   id?: string | undefined;
   name?: string | undefined;
@@ -31,6 +32,7 @@ export const TaskProject$inboundSchema: z.ZodType<
     .optional(),
   description: z.string().optional(),
   group_ids: z.array(z.string()).optional(),
+  has_children: z.boolean().optional(),
   has_tasks: z.boolean().optional(),
   id: z.string().optional(),
   name: z.string().optional(),
@@ -43,6 +45,7 @@ export const TaskProject$inboundSchema: z.ZodType<
   return remap$(v, {
     "created_at": "createdAt",
     "group_ids": "groupIds",
+    "has_children": "hasChildren",
     "has_tasks": "hasTasks",
     "parent_id": "parentId",
     "updated_at": "updatedAt",
@@ -55,6 +58,7 @@ export type TaskProject$Outbound = {
   created_at?: string | undefined;
   description?: string | undefined;
   group_ids?: Array<string> | undefined;
+  has_children?: boolean | undefined;
   has_tasks?: boolean | undefined;
   id?: string | undefined;
   name?: string | undefined;
@@ -73,6 +77,7 @@ export const TaskProject$outboundSchema: z.ZodType<
   createdAt: z.date().transform(v => v.toISOString()).optional(),
   description: z.string().optional(),
   groupIds: z.array(z.string()).optional(),
+  hasChildren: z.boolean().optional(),
   hasTasks: z.boolean().optional(),
   id: z.string().optional(),
   name: z.string().optional(),
@@ -84,6 +89,7 @@ export const TaskProject$outboundSchema: z.ZodType<
   return remap$(v, {
     createdAt: "created_at",
     groupIds: "group_ids",
+    hasChildren: "has_children",
     hasTasks: "has_tasks",
     parentId: "parent_id",
     updatedAt: "updated_at",

package/src/sdk/models/shared/tasktask.ts

@@ -5,7 +5,11 @@
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
 import { safeParse } from "../../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
@@ -14,7 +18,7 @@ export const TaskTaskStatus = {
   InProgress: "IN_PROGRESS",
   Completed: "COMPLETED",
 } as const;
-export type TaskTaskStatus = ClosedEnum<typeof TaskTaskStatus>;
+export type TaskTaskStatus = OpenEnum<typeof TaskTaskStatus>;
 
 export type TaskTask = {
   assignedUserIds?: Array<string> | undefined;
@@ -42,14 +46,25 @@ export type TaskTask = {
 };
 
 /** @internal */
-export const TaskTaskStatus$inboundSchema: z.ZodNativeEnum<
-  typeof TaskTaskStatus
-> = z.nativeEnum(TaskTaskStatus);
+export const TaskTaskStatus$inboundSchema: z.ZodType<
+  TaskTaskStatus,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(TaskTaskStatus),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const TaskTaskStatus$outboundSchema: z.ZodNativeEnum<
-  typeof TaskTaskStatus
-> = TaskTaskStatus$inboundSchema;
+export const TaskTaskStatus$outboundSchema: z.ZodType<
+  TaskTaskStatus,
+  z.ZodTypeDef,
+  TaskTaskStatus
+> = z.union([
+  z.nativeEnum(TaskTaskStatus),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/sdk/models/shared/ticketingemail.ts

@@ -4,7 +4,11 @@
 
 import * as z from "zod";
 import { safeParse } from "../../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
@@ -13,7 +17,7 @@ export const TicketingEmailType = {
   Home: "HOME",
   Other: "OTHER",
 } as const;
-export type TicketingEmailType = ClosedEnum<typeof TicketingEmailType>;
+export type TicketingEmailType = OpenEnum<typeof TicketingEmailType>;
 
 export type TicketingEmail = {
   email: string;
@@ -21,14 +25,25 @@ export type TicketingEmail = {
 };
 
 /** @internal */
-export const TicketingEmailType$inboundSchema: z.ZodNativeEnum<
-  typeof TicketingEmailType
-> = z.nativeEnum(TicketingEmailType);
+export const TicketingEmailType$inboundSchema: z.ZodType<
+  TicketingEmailType,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(TicketingEmailType),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const TicketingEmailType$outboundSchema: z.ZodNativeEnum<
-  typeof TicketingEmailType
-> = TicketingEmailType$inboundSchema;
+export const TicketingEmailType$outboundSchema: z.ZodType<
+  TicketingEmailType,
+  z.ZodTypeDef,
+  TicketingEmailType
+> = z.union([
+  z.nativeEnum(TicketingEmailType),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal