@greensecurity/javascript-sdk 0.42.6-beta.0 → 0.42.12-beta.0

package/src/models/components/invitee.ts

@@ -5,8 +5,10 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export const InviteeStatus = {
@@ -14,7 +16,7 @@ export const InviteeStatus = {
   Accepted: "Accepted",
   Declined: "Declined",
 } as const;
-export type InviteeStatus = ClosedEnum<typeof InviteeStatus>;
+export type InviteeStatus = OpenEnum<typeof InviteeStatus>;
 
 export type Invitee = {
   id?: string | null | undefined;
@@ -25,18 +27,20 @@ export type Invitee = {
 };
 
 /** @internal */
-export const InviteeStatus$inboundSchema: z.ZodNativeEnum<
-  typeof InviteeStatus
-> = z.nativeEnum(InviteeStatus);
+export const InviteeStatus$inboundSchema: z.ZodType<
+  InviteeStatus,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(InviteeStatus);
 
 /** @internal */
 export const Invitee$inboundSchema: z.ZodType<Invitee, z.ZodTypeDef, unknown> =
   z.object({
-    id: z.nullable(z.string()).optional(),
-    name: z.string().optional(),
-    details: z.nullable(z.string()).optional(),
+    id: z.nullable(types.string()).optional(),
+    name: types.optional(types.string()),
+    details: z.nullable(types.string()).optional(),
     status: z.nullable(InviteeStatus$inboundSchema).optional(),
-    img_url: z.nullable(z.string()).optional(),
+    img_url: z.nullable(types.string()).optional(),
   }).transform((v) => {
     return remap$(v, {
       "img_url": "imgUrl",

package/src/models/components/invoice.ts

@@ -6,6 +6,7 @@ import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import { InvoiceItem, InvoiceItem$inboundSchema } from "./invoiceitem.js";
 import {
@@ -37,20 +38,20 @@ export type Invoice = {
 /** @internal */
 export const Invoice$inboundSchema: z.ZodType<Invoice, z.ZodTypeDef, unknown> =
   z.object({
-    id: z.number().int(),
-    invoice_number: z.nullable(z.string()).optional(),
-    tracking_number: z.nullable(z.string()).optional(),
-    date_processed: z.nullable(z.string()).optional(),
-    date_due: z.nullable(z.string()).optional(),
-    amount: z.nullable(z.number().int()).optional(),
-    status: z.nullable(z.string()).optional(),
-    financial_status: z.nullable(z.string()).optional(),
-    amount_not_paid: z.nullable(z.number().int()).optional(),
-    tax: z.nullable(z.number().int()).optional(),
-    convenience_fee: z.nullable(z.number()).optional(),
-    shipping: z.nullable(z.number().int()).optional(),
-    discount: z.number().int().optional(),
-    lines: z.nullable(z.array(z.nullable(InvoiceItem$inboundSchema)))
+    id: types.number(),
+    invoice_number: z.nullable(types.string()).optional(),
+    tracking_number: z.nullable(types.string()).optional(),
+    date_processed: z.nullable(types.string()).optional(),
+    date_due: z.nullable(types.string()).optional(),
+    amount: z.nullable(types.number()).optional(),
+    status: z.nullable(types.string()).optional(),
+    financial_status: z.nullable(types.string()).optional(),
+    amount_not_paid: z.nullable(types.number()).optional(),
+    tax: z.nullable(types.number()).optional(),
+    convenience_fee: z.nullable(types.number()).optional(),
+    shipping: z.nullable(types.number()).optional(),
+    discount: types.optional(types.number()),
+    lines: z.nullable(z.array(types.nullable(InvoiceItem$inboundSchema)))
       .optional(),
     transactions: z.nullable(z.array(InvoiceTransaction$inboundSchema))
       .optional(),

package/src/models/components/invoiceitem.ts

@@ -6,6 +6,8 @@ import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { smartUnion } from "../../types/smartUnion.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import { Product, Product$inboundSchema } from "./product.js";
 import {
@@ -44,7 +46,7 @@ export type InvoiceItem = {
 
 /** @internal */
 export const Variant$inboundSchema: z.ZodType<Variant, z.ZodTypeDef, unknown> =
-  z.union([ProductVariant$inboundSchema, z.number().int()]);
+  smartUnion([ProductVariant$inboundSchema, types.number()]);
 
 export function variantFromJSON(
   jsonString: string,
@@ -61,7 +63,7 @@ export const InvoiceItemProduct$inboundSchema: z.ZodType<
   InvoiceItemProduct,
   z.ZodTypeDef,
   unknown
-> = z.union([Product$inboundSchema, z.number().int()]);
+> = smartUnion([Product$inboundSchema, types.number()]);
 
 export function invoiceItemProductFromJSON(
   jsonString: string,
@@ -76,10 +78,10 @@ export function invoiceItemProductFromJSON(
 /** @internal */
 export const Details$inboundSchema: z.ZodType<Details, z.ZodTypeDef, unknown> =
   z.object({
-    total_days: z.nullable(z.number().int()).optional(),
-    unused_days: z.nullable(z.number().int()).optional(),
-    used_days: z.nullable(z.number().int()).optional(),
-    prorate: z.nullable(z.number()).optional(),
+    total_days: z.nullable(types.number()).optional(),
+    unused_days: z.nullable(types.number()).optional(),
+    used_days: z.nullable(types.number()).optional(),
+    prorate: z.nullable(types.number()).optional(),
   }).transform((v) => {
     return remap$(v, {
       "total_days": "totalDays",
@@ -104,18 +106,19 @@ export const InvoiceItem$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.number().int().optional(),
-  date_starts: z.nullable(z.string()).optional(),
-  date_ends: z.nullable(z.string()).optional(),
-  is_subscription: z.nullable(z.boolean()).optional(),
-  product_title: z.nullable(z.string()).optional(),
-  title: z.nullable(z.string()).optional(),
-  quantity: z.nullable(z.number()).optional(),
-  unit_price: z.nullable(z.number().int()).optional(),
-  subtotal: z.nullable(z.number().int()).optional(),
-  variant: z.nullable(z.union([ProductVariant$inboundSchema, z.number().int()]))
-    .optional(),
-  product: z.nullable(z.union([Product$inboundSchema, z.number().int()]))
+  id: types.optional(types.number()),
+  date_starts: z.nullable(types.string()).optional(),
+  date_ends: z.nullable(types.string()).optional(),
+  is_subscription: z.nullable(types.boolean()).optional(),
+  product_title: z.nullable(types.string()).optional(),
+  title: z.nullable(types.string()).optional(),
+  quantity: z.nullable(types.number()).optional(),
+  unit_price: z.nullable(types.number()).optional(),
+  subtotal: z.nullable(types.number()).optional(),
+  variant: z.nullable(
+    smartUnion([ProductVariant$inboundSchema, types.number()]),
+  ).optional(),
+  product: z.nullable(smartUnion([Product$inboundSchema, types.number()]))
     .optional(),
   details: z.nullable(z.lazy(() => Details$inboundSchema)).optional(),
 }).transform((v) => {

package/src/models/components/invoicetransaction.ts

@@ -6,6 +6,8 @@ import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { smartUnion } from "../../types/smartUnion.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
   PaymentProfile,
@@ -31,7 +33,7 @@ export const InvoiceTransactionPaymentProfile$inboundSchema: z.ZodType<
   InvoiceTransactionPaymentProfile,
   z.ZodTypeDef,
   unknown
-> = z.union([PaymentProfile$inboundSchema, z.number().int()]);
+> = smartUnion([PaymentProfile$inboundSchema, types.number()]);
 
 export function invoiceTransactionPaymentProfileFromJSON(
   jsonString: string,
@@ -49,14 +51,14 @@ export const InvoiceTransaction$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  date_processed: z.nullable(z.string()).optional(),
+  date_processed: z.nullable(types.string()).optional(),
   payment_profile: z.nullable(
-    z.union([PaymentProfile$inboundSchema, z.number().int()]),
+    smartUnion([PaymentProfile$inboundSchema, types.number()]),
   ).optional(),
-  amount: z.nullable(z.number().int()).optional(),
-  credit_id: z.nullable(z.number().int()).optional(),
-  transaction_id: z.nullable(z.string()).optional(),
-  success: z.nullable(z.boolean()).optional(),
+  amount: z.nullable(types.number()).optional(),
+  credit_id: z.nullable(types.number()).optional(),
+  transaction_id: z.nullable(types.string()).optional(),
+  success: z.nullable(types.boolean()).optional(),
 }).transform((v) => {
   return remap$(v, {
     "date_processed": "dateProcessed",

package/src/models/components/mfarequiredresponse.ts

@@ -5,8 +5,10 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { ClosedEnum, OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export const MfaRequiredResponseRequires = {
@@ -20,7 +22,7 @@ export const MfaMethod = {
   Text: "text",
   Email: "email",
 } as const;
-export type MfaMethod = ClosedEnum<typeof MfaMethod>;
+export type MfaMethod = OpenEnum<typeof MfaMethod>;
 
 /**
  * The response is sent when a login is successful, but requires more information such as a MFA.
@@ -49,8 +51,11 @@ export const MfaRequiredResponseRequires$inboundSchema: z.ZodNativeEnum<
 > = z.nativeEnum(MfaRequiredResponseRequires);
 
 /** @internal */
-export const MfaMethod$inboundSchema: z.ZodNativeEnum<typeof MfaMethod> = z
-  .nativeEnum(MfaMethod);
+export const MfaMethod$inboundSchema: z.ZodType<
+  MfaMethod,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(MfaMethod);
 
 /** @internal */
 export const MfaRequiredResponse$inboundSchema: z.ZodType<
@@ -59,10 +64,10 @@ export const MfaRequiredResponse$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   requires: MfaRequiredResponseRequires$inboundSchema,
-  success: z.boolean(),
-  error: z.string(),
-  mobile_phone: z.string().optional(),
-  mfa_method: MfaMethod$inboundSchema.optional(),
+  success: types.boolean(),
+  error: types.string(),
+  mobile_phone: types.optional(types.string()),
+  mfa_method: types.optional(MfaMethod$inboundSchema),
 }).transform((v) => {
   return remap$(v, {
     "mobile_phone": "mobilePhone",

package/src/models/components/pager.ts

@@ -6,6 +6,7 @@ import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
@@ -49,13 +50,13 @@ export type Pager = {
 /** @internal */
 export const Pager$inboundSchema: z.ZodType<Pager, z.ZodTypeDef, unknown> = z
   .object({
-    base_url: z.string(),
-    sort: z.string(),
-    desc: z.number().int(),
-    item_count: z.number().int(),
-    items_per_page: z.number().int(),
-    page: z.number().int(),
-    use_url_params: z.boolean(),
+    base_url: types.string(),
+    sort: types.string(),
+    desc: types.number(),
+    item_count: types.number(),
+    items_per_page: types.number(),
+    page: types.number(),
+    use_url_params: types.boolean(),
   }).transform((v) => {
     return remap$(v, {
       "base_url": "baseUrl",

package/src/models/components/passwordrequiredresponse.ts

@@ -6,6 +6,7 @@ import * as z from "zod/v3";
 import { safeParse } from "../../lib/schemas.js";
 import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export const Requires = {
@@ -36,8 +37,8 @@ export const PasswordRequiredResponse$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   requires: Requires$inboundSchema,
-  success: z.boolean(),
-  error: z.string(),
+  success: types.boolean(),
+  error: types.string(),
 });
 
 export function passwordRequiredResponseFromJSON(

package/src/models/components/paymentprofile.ts

@@ -6,6 +6,8 @@ import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { smartUnion } from "../../types/smartUnion.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type Two2 = {};
@@ -45,7 +47,7 @@ export const PaymentProfile2$inboundSchema: z.ZodType<
   PaymentProfile2,
   z.ZodTypeDef,
   unknown
-> = z.union([z.number().int(), z.lazy(() => Two2$inboundSchema)]);
+> = smartUnion([types.number(), z.lazy(() => Two2$inboundSchema)]);
 
 export function paymentProfile2FromJSON(
   jsonString: string,
@@ -63,12 +65,12 @@ export const PaymentProfile1$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.number().int().optional(),
-  is_valid: z.nullable(z.boolean()).optional(),
-  card_type: z.nullable(z.string()).optional(),
-  card_last4: z.nullable(z.string()).optional(),
-  is_dummy: z.nullable(z.boolean()).optional(),
-  profile_type: z.nullable(z.string()).optional(),
+  id: types.optional(types.number()),
+  is_valid: z.nullable(types.boolean()).optional(),
+  card_type: z.nullable(types.string()).optional(),
+  card_last4: z.nullable(types.string()).optional(),
+  is_dummy: z.nullable(types.boolean()).optional(),
+  profile_type: z.nullable(types.string()).optional(),
 }).transform((v) => {
   return remap$(v, {
     "is_valid": "isValid",
@@ -94,9 +96,9 @@ export const PaymentProfile$inboundSchema: z.ZodType<
   PaymentProfile,
   z.ZodTypeDef,
   unknown
-> = z.union([
+> = smartUnion([
   z.lazy(() => PaymentProfile1$inboundSchema),
-  z.union([z.number().int(), z.lazy(() => Two2$inboundSchema)]),
+  smartUnion([types.number(), z.lazy(() => Two2$inboundSchema)]),
 ]);
 
 export function paymentProfileFromJSON(

package/src/models/components/pendinginvitation.ts

@@ -6,6 +6,7 @@ import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
@@ -38,15 +39,15 @@ export type PendingInvitation = {
 /** @internal */
 export const Event$inboundSchema: z.ZodType<Event, z.ZodTypeDef, unknown> = z
   .object({
-    id: z.number().int().optional(),
-    user_id: z.number().int().optional(),
-    title: z.nullable(z.string()).optional(),
-    location: z.nullable(z.string()).optional(),
-    start: z.string().optional(),
-    end: z.string().optional(),
-    all_day: z.boolean().optional(),
-    standing_appt: z.boolean().optional(),
-    notes: z.nullable(z.string()).optional(),
+    id: types.optional(types.number()),
+    user_id: types.optional(types.number()),
+    title: z.nullable(types.string()).optional(),
+    location: z.nullable(types.string()).optional(),
+    start: types.optional(types.string()),
+    end: types.optional(types.string()),
+    all_day: types.optional(types.boolean()),
+    standing_appt: types.optional(types.boolean()),
+    notes: z.nullable(types.string()).optional(),
     event_creator_img_url: z.nullable(z.any()).optional(),
   }).transform((v) => {
     return remap$(v, {
@@ -73,11 +74,11 @@ export const PendingInvitation$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.number().int().optional(),
-  from: z.nullable(z.string()).optional(),
-  to: z.nullable(z.string()).optional(),
-  invitee_img_url: z.nullable(z.string()).optional(),
-  event: z.lazy(() => Event$inboundSchema).optional(),
+  id: types.optional(types.number()),
+  from: z.nullable(types.string()).optional(),
+  to: z.nullable(types.string()).optional(),
+  invitee_img_url: z.nullable(types.string()).optional(),
+  event: types.optional(z.lazy(() => Event$inboundSchema)),
 }).transform((v) => {
   return remap$(v, {
     "invitee_img_url": "inviteeImgUrl",

package/src/models/components/product.ts

@@ -5,6 +5,7 @@
 import * as z from "zod/v3";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
@@ -19,9 +20,9 @@ export type Product = {
 /** @internal */
 export const Product$inboundSchema: z.ZodType<Product, z.ZodTypeDef, unknown> =
   z.object({
-    id: z.number().int().optional(),
-    title: z.nullable(z.string()).optional(),
-    description: z.nullable(z.string()).optional(),
+    id: types.optional(types.number()),
+    title: z.nullable(types.string()).optional(),
+    description: z.nullable(types.string()).optional(),
   });
 
 export function productFromJSON(

package/src/models/components/productvariant.ts

@@ -5,6 +5,7 @@
 import * as z from "zod/v3";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
@@ -22,9 +23,9 @@ export const ProductVariant$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.number().int().optional(),
-  price: z.number().int().optional(),
-  title: z.nullable(z.string()).optional(),
+  id: types.optional(types.number()),
+  price: types.optional(types.number()),
+  title: z.nullable(types.string()).optional(),
 });
 
 export function productVariantFromJSON(

package/src/models/components/samlloginrequiredresponse.ts

@@ -7,6 +7,7 @@ import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
 import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export const SamlLoginRequiredResponseRequires = {
@@ -49,10 +50,10 @@ export const SamlLoginRequiredResponse$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   requires: SamlLoginRequiredResponseRequires$inboundSchema,
-  success: z.boolean(),
-  error: z.string(),
-  sso_instructions: z.string().optional(),
-  sso_url: z.string(),
+  success: types.boolean(),
+  error: types.string(),
+  sso_instructions: types.optional(types.string()),
+  sso_url: types.string(),
 }).transform((v) => {
   return remap$(v, {
     "sso_instructions": "ssoInstructions",

package/src/models/components/screeninganswer.ts

@@ -5,8 +5,10 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
   ScreeningQuestion,
@@ -25,7 +27,7 @@ export const AnswerType = {
 /**
  * The type of answer option.
  */
-export type AnswerType = ClosedEnum<typeof AnswerType>;
+export type AnswerType = OpenEnum<typeof AnswerType>;
 
 /**
  * Reduced list of attributes of ScreeningAnswer records
@@ -66,8 +68,11 @@ export type ScreeningAnswer = {
 };
 
 /** @internal */
-export const AnswerType$inboundSchema: z.ZodNativeEnum<typeof AnswerType> = z
-  .nativeEnum(AnswerType);
+export const AnswerType$inboundSchema: z.ZodType<
+  AnswerType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(AnswerType);
 
 /** @internal */
 export const ScreeningAnswer$inboundSchema: z.ZodType<
@@ -75,16 +80,16 @@ export const ScreeningAnswer$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.number().int(),
-  screening_question_id: z.nullable(z.number().int()).optional(),
-  answer: z.nullable(z.string()).optional(),
+  id: types.number(),
+  screening_question_id: z.nullable(types.number()).optional(),
+  answer: z.nullable(types.string()).optional(),
   answer_type: z.nullable(AnswerType$inboundSchema).optional(),
-  answer_title: z.nullable(z.string()).optional(),
-  allow_empty_answer: z.boolean(),
-  empty_answer_error_message: z.nullable(z.string()).optional(),
-  show_confirmation: z.boolean(),
-  confirmation_text: z.nullable(z.string()).optional(),
-  priority: z.nullable(z.number().int()).optional(),
+  answer_title: z.nullable(types.string()).optional(),
+  allow_empty_answer: types.boolean(),
+  empty_answer_error_message: z.nullable(types.string()).optional(),
+  show_confirmation: types.boolean(),
+  confirmation_text: z.nullable(types.string()).optional(),
+  priority: z.nullable(types.number()).optional(),
   screening_questions: z.nullable(
     z.array(z.lazy(() => ScreeningQuestion$inboundSchema)),
   ).optional(),

package/src/models/components/screeningquestion.ts

@@ -5,8 +5,10 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
   ScreeningAnswer,
@@ -27,7 +29,7 @@ export const PresetDisplayAs = {
 /**
  * The display format for the question.
  */
-export type PresetDisplayAs = ClosedEnum<typeof PresetDisplayAs>;
+export type PresetDisplayAs = OpenEnum<typeof PresetDisplayAs>;
 
 /**
  * Reduced list of attributes of ScreeningQuestion record
@@ -52,9 +54,11 @@ export type ScreeningQuestion = {
 };
 
 /** @internal */
-export const PresetDisplayAs$inboundSchema: z.ZodNativeEnum<
-  typeof PresetDisplayAs
-> = z.nativeEnum(PresetDisplayAs);
+export const PresetDisplayAs$inboundSchema: z.ZodType<
+  PresetDisplayAs,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(PresetDisplayAs);
 
 /** @internal */
 export const ScreeningQuestion$inboundSchema: z.ZodType<
@@ -62,14 +66,15 @@ export const ScreeningQuestion$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.number().int(),
-  screening_question_series_id: z.number().int(),
-  screening_answer_id: z.nullable(z.number().int()).optional(),
-  priority: z.nullable(z.number().int()).optional(),
-  question: z.nullable(z.string()).optional(),
+  id: types.number(),
+  screening_question_series_id: types.number(),
+  screening_answer_id: z.nullable(types.number()).optional(),
+  priority: z.nullable(types.number()).optional(),
+  question: z.nullable(types.string()).optional(),
   preset_display_as: z.nullable(PresetDisplayAs$inboundSchema).optional(),
-  screening_answers: z.array(z.lazy(() => ScreeningAnswer$inboundSchema))
-    .optional(),
+  screening_answers: types.optional(
+    z.array(z.lazy(() => ScreeningAnswer$inboundSchema)),
+  ),
 }).transform((v) => {
   return remap$(v, {
     "screening_question_series_id": "screeningQuestionSeriesId",

package/src/models/components/screeningresponse.ts

@@ -6,6 +6,7 @@ import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
@@ -31,17 +32,17 @@ export const ScreeningResponse$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.number().int().optional(),
-  vendor_id: z.nullable(z.number().int()).optional(),
-  vendor_scan_id: z.nullable(z.number().int()).optional(),
-  screening_question_id: z.nullable(z.number().int()).optional(),
-  screening_answer_id: z.nullable(z.number().int()).optional(),
-  date_answered: z.nullable(z.string()).optional(),
-  custom_answer: z.nullable(z.string()).optional(),
-  multiple_vendor_answer_ids: z.nullable(z.string()).optional(),
-  visitor_checkin_id: z.nullable(z.number().int()).optional(),
-  contact_id: z.nullable(z.number().int()).optional(),
-  visit_request_id: z.nullable(z.number().int()).optional(),
+  id: types.optional(types.number()),
+  vendor_id: z.nullable(types.number()).optional(),
+  vendor_scan_id: z.nullable(types.number()).optional(),
+  screening_question_id: z.nullable(types.number()).optional(),
+  screening_answer_id: z.nullable(types.number()).optional(),
+  date_answered: z.nullable(types.string()).optional(),
+  custom_answer: z.nullable(types.string()).optional(),
+  multiple_vendor_answer_ids: z.nullable(types.string()).optional(),
+  visitor_checkin_id: z.nullable(types.number()).optional(),
+  contact_id: z.nullable(types.number()).optional(),
+  visit_request_id: z.nullable(types.number()).optional(),
 }).transform((v) => {
   return remap$(v, {
     "vendor_id": "vendorId",