@polar-sh/sdk 0.42.2 → 0.42.4

package/src/models/components/discountupdate.ts

@@ -4,6 +4,7 @@
 
 import * as z from "zod/v4-mini";
 import { remap as remap$ } from "../../lib/primitives.js";
+import { smartUnion } from "../../types/smartUnion.js";
 import {
   DiscountDuration,
   DiscountDuration$outboundSchema,
@@ -69,7 +70,7 @@ export type DiscountUpdateMetadata$Outbound =
 export const DiscountUpdateMetadata$outboundSchema: z.ZodMiniType<
   DiscountUpdateMetadata$Outbound,
   DiscountUpdateMetadata
-> = z.union([z.string(), z.int(), z.number(), z.boolean()]);
+> = smartUnion([z.string(), z.int(), z.number(), z.boolean()]);
 
 export function discountUpdateMetadataToJSON(
   discountUpdateMetadata: DiscountUpdateMetadata,
@@ -105,7 +106,7 @@ export const DiscountUpdate$outboundSchema: z.ZodMiniType<
     metadata: z.optional(
       z.record(
         z.string(),
-        z.union([z.string(), z.int(), z.number(), z.boolean()]),
+        smartUnion([z.string(), z.int(), z.number(), z.boolean()]),
       ),
     ),
     name: z.optional(z.nullable(z.string())),

package/src/models/components/disputestatus.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v4-mini";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export const DisputeStatus = {
   Prevented: "prevented",
@@ -13,11 +14,15 @@ export const DisputeStatus = {
   Lost: "lost",
   Won: "won",
 } as const;
-export type DisputeStatus = ClosedEnum<typeof DisputeStatus>;
+export type DisputeStatus = OpenEnum<typeof DisputeStatus>;
 
 /** @internal */
-export const DisputeStatus$inboundSchema: z.ZodMiniEnum<typeof DisputeStatus> =
-  z.enum(DisputeStatus);
+export const DisputeStatus$inboundSchema: z.ZodMiniType<
+  DisputeStatus,
+  unknown
+> = openEnums.inboundSchema(DisputeStatus);
 /** @internal */
-export const DisputeStatus$outboundSchema: z.ZodMiniEnum<typeof DisputeStatus> =
-  DisputeStatus$inboundSchema;
+export const DisputeStatus$outboundSchema: z.ZodMiniType<
+  string,
+  DisputeStatus
+> = openEnums.outboundSchema(DisputeStatus);

package/src/models/components/event.ts

@@ -5,6 +5,7 @@
 import * as z from "zod/v4-mini";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import { smartUnion } from "../../types/smartUnion.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import { SystemEvent, SystemEvent$inboundSchema } from "./systemevent.js";
 import { UserEvent, UserEvent$inboundSchema } from "./userevent.js";
@@ -12,7 +13,7 @@ import { UserEvent, UserEvent$inboundSchema } from "./userevent.js";
 export type Event = UserEvent | SystemEvent;
 
 /** @internal */
-export const Event$inboundSchema: z.ZodMiniType<Event, unknown> = z.union([
+export const Event$inboundSchema: z.ZodMiniType<Event, unknown> = smartUnion([
   UserEvent$inboundSchema,
   SystemEvent$inboundSchema,
 ]);

package/src/models/components/eventmetadatainput.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod/v4-mini";
+import { smartUnion } from "../../types/smartUnion.js";
 import {
   CostMetadataInput,
   CostMetadataInput$Outbound,
@@ -35,7 +36,7 @@ export type EventMetadataInput$Outbound =
 export const EventMetadataInput$outboundSchema: z.ZodMiniType<
   EventMetadataInput$Outbound,
   EventMetadataInput
-> = z.union([
+> = smartUnion([
   LLMMetadata$outboundSchema,
   CostMetadataInput$outboundSchema,
   z.string(),

package/src/models/components/eventmetadataoutput.ts

@@ -5,6 +5,7 @@
 import * as z from "zod/v4-mini";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import { smartUnion } from "../../types/smartUnion.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
   CostMetadataOutput,
@@ -24,7 +25,7 @@ export type EventMetadataOutput =
 export const EventMetadataOutput$inboundSchema: z.ZodMiniType<
   EventMetadataOutput,
   unknown
-> = z.union([
+> = smartUnion([
   LLMMetadata$inboundSchema,
   CostMetadataOutput$inboundSchema,
   z.string(),

package/src/models/components/eventsingest.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod/v4-mini";
+import { smartUnion } from "../../types/smartUnion.js";
 import {
   EventCreateCustomer,
   EventCreateCustomer$Outbound,
@@ -29,8 +30,8 @@ export type Events$Outbound =
   | EventCreateExternalCustomer$Outbound;
 
 /** @internal */
-export const Events$outboundSchema: z.ZodMiniType<Events$Outbound, Events> = z
-  .union([
+export const Events$outboundSchema: z.ZodMiniType<Events$Outbound, Events> =
+  smartUnion([
     EventCreateCustomer$outboundSchema,
     EventCreateExternalCustomer$outboundSchema,
   ]);
@@ -52,7 +53,7 @@ export const EventsIngest$outboundSchema: z.ZodMiniType<
   EventsIngest
 > = z.object({
   events: z.array(
-    z.union([
+    smartUnion([
       EventCreateCustomer$outboundSchema,
       EventCreateExternalCustomer$outboundSchema,
     ]),

package/src/models/components/eventsource.ts

@@ -3,17 +3,18 @@
  */
 
 import * as z from "zod/v4-mini";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export const EventSource = {
   System: "system",
   User: "user",
 } as const;
-export type EventSource = ClosedEnum<typeof EventSource>;
+export type EventSource = OpenEnum<typeof EventSource>;
 
 /** @internal */
-export const EventSource$inboundSchema: z.ZodMiniEnum<typeof EventSource> = z
-  .enum(EventSource);
+export const EventSource$inboundSchema: z.ZodMiniType<EventSource, unknown> =
+  openEnums.inboundSchema(EventSource);
 /** @internal */
-export const EventSource$outboundSchema: z.ZodMiniEnum<typeof EventSource> =
-  EventSource$inboundSchema;
+export const EventSource$outboundSchema: z.ZodMiniType<string, EventSource> =
+  openEnums.outboundSchema(EventSource);

package/src/models/components/fileservicetypes.ts

@@ -3,16 +3,18 @@
  */
 
 import * as z from "zod/v4-mini";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export const FileServiceTypes = {
   Downloadable: "downloadable",
   ProductMedia: "product_media",
   OrganizationAvatar: "organization_avatar",
 } as const;
-export type FileServiceTypes = ClosedEnum<typeof FileServiceTypes>;
+export type FileServiceTypes = OpenEnum<typeof FileServiceTypes>;
 
 /** @internal */
-export const FileServiceTypes$inboundSchema: z.ZodMiniEnum<
-  typeof FileServiceTypes
-> = z.enum(FileServiceTypes);
+export const FileServiceTypes$inboundSchema: z.ZodMiniType<
+  FileServiceTypes,
+  unknown
+> = openEnums.inboundSchema(FileServiceTypes);

package/src/models/components/filter.ts

@@ -5,6 +5,7 @@
 import * as z from "zod/v4-mini";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import { smartUnion } from "../../types/smartUnion.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
   FilterClause,
@@ -29,7 +30,10 @@ export type Clauses = FilterClause | Filter;
 export const Filter$inboundSchema: z.ZodMiniType<Filter, unknown> = z.object({
   conjunction: FilterConjunction$inboundSchema,
   clauses: z.array(
-    z.union([FilterClause$inboundSchema, z.lazy(() => Filter$inboundSchema)]),
+    smartUnion([
+      FilterClause$inboundSchema,
+      z.lazy(() => Filter$inboundSchema),
+    ]),
   ),
 });
 /** @internal */
@@ -43,7 +47,7 @@ export const Filter$outboundSchema: z.ZodMiniType<Filter$Outbound, Filter> = z
   .object({
     conjunction: FilterConjunction$outboundSchema,
     clauses: z.array(
-      z.union([
+      smartUnion([
         FilterClause$outboundSchema,
         z.lazy(() => Filter$outboundSchema),
       ]),
@@ -64,16 +68,17 @@ export function filterFromJSON(
 }
 
 /** @internal */
-export const Clauses$inboundSchema: z.ZodMiniType<Clauses, unknown> = z.union([
-  FilterClause$inboundSchema,
-  z.lazy(() => Filter$inboundSchema),
-]);
+export const Clauses$inboundSchema: z.ZodMiniType<Clauses, unknown> =
+  smartUnion([FilterClause$inboundSchema, z.lazy(() => Filter$inboundSchema)]);
 /** @internal */
 export type Clauses$Outbound = FilterClause$Outbound | Filter$Outbound;
 
 /** @internal */
 export const Clauses$outboundSchema: z.ZodMiniType<Clauses$Outbound, Clauses> =
-  z.union([FilterClause$outboundSchema, z.lazy(() => Filter$outboundSchema)]);
+  smartUnion([
+    FilterClause$outboundSchema,
+    z.lazy(() => Filter$outboundSchema),
+  ]);
 
 export function clausesToJSON(clauses: Clauses): string {
   return JSON.stringify(Clauses$outboundSchema.parse(clauses));

package/src/models/components/filterclause.ts

@@ -5,6 +5,7 @@
 import * as z from "zod/v4-mini";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import { smartUnion } from "../../types/smartUnion.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
   FilterOperator,
@@ -21,7 +22,7 @@ export type FilterClause = {
 };
 
 /** @internal */
-export const Value$inboundSchema: z.ZodMiniType<Value, unknown> = z.union([
+export const Value$inboundSchema: z.ZodMiniType<Value, unknown> = smartUnion([
   z.string(),
   z.int(),
   z.boolean(),
@@ -30,8 +31,8 @@ export const Value$inboundSchema: z.ZodMiniType<Value, unknown> = z.union([
 export type Value$Outbound = string | number | boolean;
 
 /** @internal */
-export const Value$outboundSchema: z.ZodMiniType<Value$Outbound, Value> = z
-  .union([z.string(), z.int(), z.boolean()]);
+export const Value$outboundSchema: z.ZodMiniType<Value$Outbound, Value> =
+  smartUnion([z.string(), z.int(), z.boolean()]);
 
 export function valueToJSON(value: Value): string {
   return JSON.stringify(Value$outboundSchema.parse(value));
@@ -51,7 +52,7 @@ export const FilterClause$inboundSchema: z.ZodMiniType<FilterClause, unknown> =
   z.object({
     property: z.string(),
     operator: FilterOperator$inboundSchema,
-    value: z.union([z.string(), z.int(), z.boolean()]),
+    value: smartUnion([z.string(), z.int(), z.boolean()]),
   });
 /** @internal */
 export type FilterClause$Outbound = {
@@ -67,7 +68,7 @@ export const FilterClause$outboundSchema: z.ZodMiniType<
 > = z.object({
   property: z.string(),
   operator: FilterOperator$outboundSchema,
-  value: z.union([z.string(), z.int(), z.boolean()]),
+  value: smartUnion([z.string(), z.int(), z.boolean()]),
 });
 
 export function filterClauseToJSON(filterClause: FilterClause): string {

package/src/models/components/filterconjunction.ts

@@ -3,19 +3,22 @@
  */
 
 import * as z from "zod/v4-mini";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export const FilterConjunction = {
   And: "and",
   Or: "or",
 } as const;
-export type FilterConjunction = ClosedEnum<typeof FilterConjunction>;
+export type FilterConjunction = OpenEnum<typeof FilterConjunction>;
 
 /** @internal */
-export const FilterConjunction$inboundSchema: z.ZodMiniEnum<
-  typeof FilterConjunction
-> = z.enum(FilterConjunction);
+export const FilterConjunction$inboundSchema: z.ZodMiniType<
+  FilterConjunction,
+  unknown
+> = openEnums.inboundSchema(FilterConjunction);
 /** @internal */
-export const FilterConjunction$outboundSchema: z.ZodMiniEnum<
-  typeof FilterConjunction
-> = FilterConjunction$inboundSchema;
+export const FilterConjunction$outboundSchema: z.ZodMiniType<
+  string,
+  FilterConjunction
+> = openEnums.outboundSchema(FilterConjunction);

package/src/models/components/filteroperator.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v4-mini";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export const FilterOperator = {
   Eq: "eq",
@@ -15,13 +16,15 @@ export const FilterOperator = {
   Like: "like",
   NotLike: "not_like",
 } as const;
-export type FilterOperator = ClosedEnum<typeof FilterOperator>;
+export type FilterOperator = OpenEnum<typeof FilterOperator>;
 
 /** @internal */
-export const FilterOperator$inboundSchema: z.ZodMiniEnum<
-  typeof FilterOperator
-> = z.enum(FilterOperator);
+export const FilterOperator$inboundSchema: z.ZodMiniType<
+  FilterOperator,
+  unknown
+> = openEnums.inboundSchema(FilterOperator);
 /** @internal */
-export const FilterOperator$outboundSchema: z.ZodMiniEnum<
-  typeof FilterOperator
-> = FilterOperator$inboundSchema;
+export const FilterOperator$outboundSchema: z.ZodMiniType<
+  string,
+  FilterOperator
+> = openEnums.outboundSchema(FilterOperator);

package/src/models/components/introspecttokenresponse.ts

@@ -5,7 +5,8 @@
 import * as z from "zod/v4-mini";
 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 { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import { SubType, SubType$inboundSchema } from "./subtype.js";
@@ -14,7 +15,7 @@ export const TokenType = {
   AccessToken: "access_token",
   RefreshToken: "refresh_token",
 } as const;
-export type TokenType = ClosedEnum<typeof TokenType>;
+export type TokenType = OpenEnum<typeof TokenType>;
 
 export type IntrospectTokenResponse = {
   active: boolean;
@@ -30,9 +31,8 @@ export type IntrospectTokenResponse = {
 };
 
 /** @internal */
-export const TokenType$inboundSchema: z.ZodMiniEnum<typeof TokenType> = z.enum(
-  TokenType,
-);
+export const TokenType$inboundSchema: z.ZodMiniType<TokenType, unknown> =
+  openEnums.inboundSchema(TokenType);
 
 /** @internal */
 export const IntrospectTokenResponse$inboundSchema: z.ZodMiniType<

package/src/models/components/legacyrecurringproductprice.ts

@@ -4,6 +4,8 @@
 
 import * as z from "zod/v4-mini";
 import { safeParse } from "../../lib/schemas.js";
+import * as discriminatedUnionTypes from "../../types/discriminatedUnion.js";
+import { discriminatedUnion } from "../../types/discriminatedUnion.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
@@ -28,17 +30,18 @@ import {
 export type LegacyRecurringProductPrice =
   | LegacyRecurringProductPriceCustom
   | LegacyRecurringProductPriceFixed
-  | LegacyRecurringProductPriceFree;
+  | LegacyRecurringProductPriceFree
+  | discriminatedUnionTypes.Unknown<"amountType">;
 
 /** @internal */
 export const LegacyRecurringProductPrice$inboundSchema: z.ZodMiniType<
   LegacyRecurringProductPrice,
   unknown
-> = z.union([
-  LegacyRecurringProductPriceCustom$inboundSchema,
-  LegacyRecurringProductPriceFixed$inboundSchema,
-  LegacyRecurringProductPriceFree$inboundSchema,
-]);
+> = discriminatedUnion("amount_type", {
+  custom: LegacyRecurringProductPriceCustom$inboundSchema,
+  fixed: LegacyRecurringProductPriceFixed$inboundSchema,
+  free: LegacyRecurringProductPriceFree$inboundSchema,
+}, { outputPropertyName: "amountType" });
 /** @internal */
 export type LegacyRecurringProductPrice$Outbound =
   | LegacyRecurringProductPriceCustom$Outbound

package/src/models/components/legacyrecurringproductpricecustom.ts

@@ -58,9 +58,9 @@ export type LegacyRecurringProductPriceCustom = {
    */
   priceCurrency: string;
   /**
-   * The minimum amount the customer can pay.
+   * The minimum amount the customer can pay. If 0, the price is 'free or pay what you want'. Defaults to 50 cents.
    */
-  minimumAmount: number | null;
+  minimumAmount: number;
   /**
    * The maximum amount the customer can pay.
    */
@@ -93,7 +93,7 @@ export const LegacyRecurringProductPriceCustom$inboundSchema: z.ZodMiniType<
     type: z.literal("recurring"),
     recurring_interval: SubscriptionRecurringInterval$inboundSchema,
     price_currency: z.string(),
-    minimum_amount: z.nullable(z.int()),
+    minimum_amount: z.int(),
     maximum_amount: z.nullable(z.int()),
     preset_amount: z.nullable(z.int()),
     legacy: z.literal(true),
@@ -125,7 +125,7 @@ export type LegacyRecurringProductPriceCustom$Outbound = {
   type: "recurring";
   recurring_interval: string;
   price_currency: string;
-  minimum_amount: number | null;
+  minimum_amount: number;
   maximum_amount: number | null;
   preset_amount: number | null;
   legacy: true;
@@ -147,7 +147,7 @@ export const LegacyRecurringProductPriceCustom$outboundSchema: z.ZodMiniType<
     type: z.literal("recurring"),
     recurringInterval: SubscriptionRecurringInterval$outboundSchema,
     priceCurrency: z.string(),
-    minimumAmount: z.nullable(z.int()),
+    minimumAmount: z.int(),
     maximumAmount: z.nullable(z.int()),
     presetAmount: z.nullable(z.int()),
     legacy: z.literal(true),

package/src/models/components/licensekeyactivate.ts

@@ -4,6 +4,7 @@
 
 import * as z from "zod/v4-mini";
 import { remap as remap$ } from "../../lib/primitives.js";
+import { smartUnion } from "../../types/smartUnion.js";
 
 export type LicenseKeyActivateConditions = string | number | number | boolean;
 
@@ -58,7 +59,7 @@ export type LicenseKeyActivateConditions$Outbound =
 export const LicenseKeyActivateConditions$outboundSchema: z.ZodMiniType<
   LicenseKeyActivateConditions$Outbound,
   LicenseKeyActivateConditions
-> = z.union([z.string(), z.int(), z.number(), z.boolean()]);
+> = smartUnion([z.string(), z.int(), z.number(), z.boolean()]);
 
 export function licenseKeyActivateConditionsToJSON(
   licenseKeyActivateConditions: LicenseKeyActivateConditions,
@@ -81,7 +82,7 @@ export type LicenseKeyActivateMeta$Outbound =
 export const LicenseKeyActivateMeta$outboundSchema: z.ZodMiniType<
   LicenseKeyActivateMeta$Outbound,
   LicenseKeyActivateMeta
-> = z.union([z.string(), z.int(), z.number(), z.boolean()]);
+> = smartUnion([z.string(), z.int(), z.number(), z.boolean()]);
 
 export function licenseKeyActivateMetaToJSON(
   licenseKeyActivateMeta: LicenseKeyActivateMeta,
@@ -112,13 +113,13 @@ export const LicenseKeyActivate$outboundSchema: z.ZodMiniType<
     conditions: z.optional(
       z.record(
         z.string(),
-        z.union([z.string(), z.int(), z.number(), z.boolean()]),
+        smartUnion([z.string(), z.int(), z.number(), z.boolean()]),
       ),
     ),
     meta: z.optional(
       z.record(
         z.string(),
-        z.union([z.string(), z.int(), z.number(), z.boolean()]),
+        smartUnion([z.string(), z.int(), z.number(), z.boolean()]),
       ),
     ),
   }),

package/src/models/components/licensekeyactivationbase.ts

@@ -6,6 +6,7 @@ import * as z from "zod/v4-mini";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import { smartUnion } from "../../types/smartUnion.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type Meta = string | number | number | boolean;
@@ -20,7 +21,7 @@ export type LicenseKeyActivationBase = {
 };
 
 /** @internal */
-export const Meta$inboundSchema: z.ZodMiniType<Meta, unknown> = z.union([
+export const Meta$inboundSchema: z.ZodMiniType<Meta, unknown> = smartUnion([
   z.string(),
   z.int(),
   z.number(),
@@ -48,7 +49,7 @@ export const LicenseKeyActivationBase$inboundSchema: z.ZodMiniType<
     label: z.string(),
     meta: z.record(
       z.string(),
-      z.union([z.string(), z.int(), z.number(), z.boolean()]),
+      smartUnion([z.string(), z.int(), z.number(), z.boolean()]),
     ),
     created_at: z.pipe(
       z.iso.datetime({ offset: true }),

package/src/models/components/licensekeyactivationread.ts

@@ -6,6 +6,7 @@ import * as z from "zod/v4-mini";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import { smartUnion } from "../../types/smartUnion.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
   LicenseKeyRead,
@@ -28,7 +29,7 @@ export type LicenseKeyActivationRead = {
 export const LicenseKeyActivationReadMeta$inboundSchema: z.ZodMiniType<
   LicenseKeyActivationReadMeta,
   unknown
-> = z.union([z.string(), z.int(), z.number(), z.boolean()]);
+> = smartUnion([z.string(), z.int(), z.number(), z.boolean()]);
 
 export function licenseKeyActivationReadMetaFromJSON(
   jsonString: string,
@@ -51,7 +52,7 @@ export const LicenseKeyActivationRead$inboundSchema: z.ZodMiniType<
     label: z.string(),
     meta: z.record(
       z.string(),
-      z.union([z.string(), z.int(), z.number(), z.boolean()]),
+      smartUnion([z.string(), z.int(), z.number(), z.boolean()]),
     ),
     created_at: z.pipe(
       z.iso.datetime({ offset: true }),

package/src/models/components/licensekeycustomer.ts

@@ -6,6 +6,7 @@ import * as z from "zod/v4-mini";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import { smartUnion } from "../../types/smartUnion.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import { Address, Address$inboundSchema } from "./address.js";
 import {
@@ -63,7 +64,7 @@ export type LicenseKeyCustomer = {
 export const LicenseKeyCustomerTaxId$inboundSchema: z.ZodMiniType<
   LicenseKeyCustomerTaxId,
   unknown
-> = z.union([z.string(), TaxIDFormat$inboundSchema]);
+> = smartUnion([z.string(), TaxIDFormat$inboundSchema]);
 
 export function licenseKeyCustomerTaxIdFromJSON(
   jsonString: string,
@@ -96,7 +97,7 @@ export const LicenseKeyCustomer$inboundSchema: z.ZodMiniType<
     name: z.nullable(z.string()),
     billing_address: z.nullable(Address$inboundSchema),
     tax_id: z.nullable(
-      z.array(z.nullable(z.union([z.string(), TaxIDFormat$inboundSchema]))),
+      z.array(z.nullable(smartUnion([z.string(), TaxIDFormat$inboundSchema]))),
     ),
     organization_id: z.string(),
     deleted_at: z.nullable(

package/src/models/components/licensekeystatus.ts

@@ -3,20 +3,23 @@
  */
 
 import * as z from "zod/v4-mini";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export const LicenseKeyStatus = {
   Granted: "granted",
   Revoked: "revoked",
   Disabled: "disabled",
 } as const;
-export type LicenseKeyStatus = ClosedEnum<typeof LicenseKeyStatus>;
+export type LicenseKeyStatus = OpenEnum<typeof LicenseKeyStatus>;
 
 /** @internal */
-export const LicenseKeyStatus$inboundSchema: z.ZodMiniEnum<
-  typeof LicenseKeyStatus
-> = z.enum(LicenseKeyStatus);
+export const LicenseKeyStatus$inboundSchema: z.ZodMiniType<
+  LicenseKeyStatus,
+  unknown
+> = openEnums.inboundSchema(LicenseKeyStatus);
 /** @internal */
-export const LicenseKeyStatus$outboundSchema: z.ZodMiniEnum<
-  typeof LicenseKeyStatus
-> = LicenseKeyStatus$inboundSchema;
+export const LicenseKeyStatus$outboundSchema: z.ZodMiniType<
+  string,
+  LicenseKeyStatus
+> = openEnums.outboundSchema(LicenseKeyStatus);

package/src/models/components/licensekeyvalidate.ts

@@ -4,6 +4,7 @@
 
 import * as z from "zod/v4-mini";
 import { remap as remap$ } from "../../lib/primitives.js";
+import { smartUnion } from "../../types/smartUnion.js";
 
 export type Conditions = string | number | number | boolean;
 
@@ -39,7 +40,7 @@ export type Conditions$Outbound = string | number | number | boolean;
 export const Conditions$outboundSchema: z.ZodMiniType<
   Conditions$Outbound,
   Conditions
-> = z.union([z.string(), z.int(), z.number(), z.boolean()]);
+> = smartUnion([z.string(), z.int(), z.number(), z.boolean()]);
 
 export function conditionsToJSON(conditions: Conditions): string {
   return JSON.stringify(Conditions$outboundSchema.parse(conditions));
@@ -71,7 +72,7 @@ export const LicenseKeyValidate$outboundSchema: z.ZodMiniType<
     conditions: z.optional(
       z.record(
         z.string(),
-        z.union([z.string(), z.int(), z.number(), z.boolean()]),
+        smartUnion([z.string(), z.int(), z.number(), z.boolean()]),
       ),
     ),
   }),