@polar-sh/sdk 0.43.1 → 0.45.0

package/src/models/components/discountfixedrepeatdurationcreate.ts

@@ -10,6 +10,10 @@ import {
   DiscountDuration$outboundSchema,
 } from "./discountduration.js";
 import { DiscountType, DiscountType$outboundSchema } from "./discounttype.js";
+import {
+  PresentmentCurrency,
+  PresentmentCurrency$outboundSchema,
+} from "./presentmentcurrency.js";
 
 export type DiscountFixedRepeatDurationCreateMetadata =
   | string
@@ -39,10 +43,7 @@ export type DiscountFixedRepeatDurationCreate = {
    * Fixed amount to discount from the invoice total.
    */
   amount: number;
-  /**
-   * The currency. Currently, only `usd` is supported.
-   */
-  currency?: string | undefined;
+  currency?: PresentmentCurrency | undefined;
   /**
    * Key-value object allowing you to store additional information.
    *
@@ -117,7 +118,7 @@ export type DiscountFixedRepeatDurationCreate$Outbound = {
   duration_in_months: number;
   type: string;
   amount: number;
-  currency: string;
+  currency?: string | undefined;
   metadata?: { [k: string]: string | number | number | boolean } | undefined;
   name: string;
   code?: string | null | undefined;
@@ -138,7 +139,7 @@ export const DiscountFixedRepeatDurationCreate$outboundSchema: z.ZodMiniType<
     durationInMonths: z.int(),
     type: DiscountType$outboundSchema,
     amount: z.int(),
-    currency: z._default(z.string(), "usd"),
+    currency: z.optional(PresentmentCurrency$outboundSchema),
     metadata: z.optional(
       z.record(
         z.string(),

package/src/models/components/discounttype.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 DiscountType = {
   Fixed: "fixed",
   Percentage: "percentage",
 } as const;
-export type DiscountType = ClosedEnum<typeof DiscountType>;
+export type DiscountType = OpenEnum<typeof DiscountType>;
 
 /** @internal */
-export const DiscountType$inboundSchema: z.ZodMiniEnum<typeof DiscountType> = z
-  .enum(DiscountType);
+export const DiscountType$inboundSchema: z.ZodMiniType<DiscountType, unknown> =
+  openEnums.inboundSchema(DiscountType);
 /** @internal */
-export const DiscountType$outboundSchema: z.ZodMiniEnum<typeof DiscountType> =
-  DiscountType$inboundSchema;
+export const DiscountType$outboundSchema: z.ZodMiniType<string, DiscountType> =
+  openEnums.outboundSchema(DiscountType);

package/src/models/components/discountupdate.ts

@@ -10,6 +10,10 @@ import {
   DiscountDuration$outboundSchema,
 } from "./discountduration.js";
 import { DiscountType, DiscountType$outboundSchema } from "./discounttype.js";
+import {
+  PresentmentCurrency,
+  PresentmentCurrency$outboundSchema,
+} from "./presentmentcurrency.js";
 
 export type DiscountUpdateMetadata = string | number | number | boolean;
 
@@ -54,7 +58,7 @@ export type DiscountUpdate = {
   durationInMonths?: number | null | undefined;
   type?: DiscountType | null | undefined;
   amount?: number | null | undefined;
-  currency?: string | null | undefined;
+  currency?: PresentmentCurrency | null | undefined;
   basisPoints?: number | null | undefined;
   products?: Array<string> | null | undefined;
 };
@@ -122,7 +126,7 @@ export const DiscountUpdate$outboundSchema: z.ZodMiniType<
     durationInMonths: z.optional(z.nullable(z.int())),
     type: z.optional(z.nullable(DiscountType$outboundSchema)),
     amount: z.optional(z.nullable(z.int())),
-    currency: z.optional(z.nullable(z.string())),
+    currency: z.optional(z.nullable(PresentmentCurrency$outboundSchema)),
     basisPoints: z.optional(z.nullable(z.int())),
     products: z.optional(z.nullable(z.array(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/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/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/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/listresourcecustomerportalmember.ts

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  CustomerPortalMember,
+  CustomerPortalMember$inboundSchema,
+} from "./customerportalmember.js";
+import { Pagination, Pagination$inboundSchema } from "./pagination.js";
+
+export type ListResourceCustomerPortalMember = {
+  items: Array<CustomerPortalMember>;
+  pagination: Pagination;
+};
+
+/** @internal */
+export const ListResourceCustomerPortalMember$inboundSchema: z.ZodMiniType<
+  ListResourceCustomerPortalMember,
+  unknown
+> = z.object({
+  items: z.array(CustomerPortalMember$inboundSchema),
+  pagination: Pagination$inboundSchema,
+});
+
+export function listResourceCustomerPortalMemberFromJSON(
+  jsonString: string,
+): SafeParseResult<ListResourceCustomerPortalMember, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListResourceCustomerPortalMember$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListResourceCustomerPortalMember' from JSON`,
+  );
+}

package/src/models/components/memberrole.ts

@@ -3,18 +3,19 @@
  */
 
 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 MemberRole = {
   Owner: "owner",
   BillingManager: "billing_manager",
   Member: "member",
 } as const;
-export type MemberRole = ClosedEnum<typeof MemberRole>;
+export type MemberRole = OpenEnum<typeof MemberRole>;
 
 /** @internal */
-export const MemberRole$inboundSchema: z.ZodMiniEnum<typeof MemberRole> = z
-  .enum(MemberRole);
+export const MemberRole$inboundSchema: z.ZodMiniType<MemberRole, unknown> =
+  openEnums.inboundSchema(MemberRole);
 /** @internal */
-export const MemberRole$outboundSchema: z.ZodMiniEnum<typeof MemberRole> =
-  MemberRole$inboundSchema;
+export const MemberRole$outboundSchema: z.ZodMiniType<string, MemberRole> =
+  openEnums.outboundSchema(MemberRole);

package/src/models/components/metrictype.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 MetricType = {
   Scalar: "scalar",
@@ -11,8 +12,8 @@ export const MetricType = {
   CurrencySubCent: "currency_sub_cent",
   Percentage: "percentage",
 } as const;
-export type MetricType = ClosedEnum<typeof MetricType>;
+export type MetricType = OpenEnum<typeof MetricType>;
 
 /** @internal */
-export const MetricType$inboundSchema: z.ZodMiniEnum<typeof MetricType> = z
-  .enum(MetricType);
+export const MetricType$inboundSchema: z.ZodMiniType<MetricType, unknown> =
+  openEnums.inboundSchema(MetricType);

package/src/models/components/order.ts

@@ -181,10 +181,6 @@ export type Order = {
    */
   platformFeeCurrency: string | null;
   customer: OrderCustomer;
-  /**
-   * @deprecated field: This will be removed in a future release, please migrate away from it as soon as possible.
-   */
-  userId: string;
   product: OrderProduct | null;
   discount:
     | DiscountFixedRepeatDurationBase
@@ -339,7 +335,6 @@ export const Order$inboundSchema: z.ZodMiniType<Order, unknown> = z.pipe(
     platform_fee_amount: z.int(),
     platform_fee_currency: z.nullable(z.string()),
     customer: OrderCustomer$inboundSchema,
-    user_id: z.string(),
     product: z.nullable(OrderProduct$inboundSchema),
     discount: z.nullable(
       smartUnion([
@@ -379,7 +374,6 @@ export const Order$inboundSchema: z.ZodMiniType<Order, unknown> = z.pipe(
       "custom_field_data": "customFieldData",
       "platform_fee_amount": "platformFeeAmount",
       "platform_fee_currency": "platformFeeCurrency",
-      "user_id": "userId",
     });
   }),
 );
@@ -418,7 +412,6 @@ export type Order$Outbound = {
   platform_fee_amount: number;
   platform_fee_currency: string | null;
   customer: OrderCustomer$Outbound;
-  user_id: string;
   product: OrderProduct$Outbound | null;
   discount:
     | DiscountFixedRepeatDurationBase$Outbound
@@ -480,7 +473,6 @@ export const Order$outboundSchema: z.ZodMiniType<Order$Outbound, Order> = z
       platformFeeAmount: z.int(),
       platformFeeCurrency: z.nullable(z.string()),
       customer: OrderCustomer$outboundSchema,
-      userId: z.string(),
       product: z.nullable(OrderProduct$outboundSchema),
       discount: z.nullable(
         smartUnion([
@@ -520,7 +512,6 @@ export const Order$outboundSchema: z.ZodMiniType<Order$Outbound, Order> = z
         customFieldData: "custom_field_data",
         platformFeeAmount: "platform_fee_amount",
         platformFeeCurrency: "platform_fee_currency",
-        userId: "user_id",
       });
     }),
   );

package/src/models/components/orderbillingreason.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 OrderBillingReason = {
   Purchase: "purchase",
@@ -11,13 +12,15 @@ export const OrderBillingReason = {
   SubscriptionCycle: "subscription_cycle",
   SubscriptionUpdate: "subscription_update",
 } as const;
-export type OrderBillingReason = ClosedEnum<typeof OrderBillingReason>;
+export type OrderBillingReason = OpenEnum<typeof OrderBillingReason>;
 
 /** @internal */
-export const OrderBillingReason$inboundSchema: z.ZodMiniEnum<
-  typeof OrderBillingReason
-> = z.enum(OrderBillingReason);
+export const OrderBillingReason$inboundSchema: z.ZodMiniType<
+  OrderBillingReason,
+  unknown
+> = openEnums.inboundSchema(OrderBillingReason);
 /** @internal */
-export const OrderBillingReason$outboundSchema: z.ZodMiniEnum<
-  typeof OrderBillingReason
-> = OrderBillingReason$inboundSchema;
+export const OrderBillingReason$outboundSchema: z.ZodMiniType<
+  string,
+  OrderBillingReason
+> = openEnums.outboundSchema(OrderBillingReason);

package/src/models/components/orderstatus.ts

@@ -3,19 +3,21 @@
  */
 
 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 OrderStatus = {
   Pending: "pending",
   Paid: "paid",
   Refunded: "refunded",
   PartiallyRefunded: "partially_refunded",
+  Void: "void",
 } as const;
-export type OrderStatus = ClosedEnum<typeof OrderStatus>;
+export type OrderStatus = OpenEnum<typeof OrderStatus>;
 
 /** @internal */
-export const OrderStatus$inboundSchema: z.ZodMiniEnum<typeof OrderStatus> = z
-  .enum(OrderStatus);
+export const OrderStatus$inboundSchema: z.ZodMiniType<OrderStatus, unknown> =
+  openEnums.inboundSchema(OrderStatus);
 /** @internal */
-export const OrderStatus$outboundSchema: z.ZodMiniEnum<typeof OrderStatus> =
-  OrderStatus$inboundSchema;
+export const OrderStatus$outboundSchema: z.ZodMiniType<string, OrderStatus> =
+  openEnums.outboundSchema(OrderStatus);

package/src/models/components/organizationcustomeremailsettings.ts

@@ -13,6 +13,7 @@ export type OrganizationCustomerEmailSettings = {
   subscriptionCancellation: boolean;
   subscriptionConfirmation: boolean;
   subscriptionCycled: boolean;
+  subscriptionCycledAfterTrial: boolean;
   subscriptionPastDue: boolean;
   subscriptionRevoked: boolean;
   subscriptionUncanceled: boolean;
@@ -29,6 +30,7 @@ export const OrganizationCustomerEmailSettings$inboundSchema: z.ZodMiniType<
     subscription_cancellation: z.boolean(),
     subscription_confirmation: z.boolean(),
     subscription_cycled: z.boolean(),
+    subscription_cycled_after_trial: z.boolean(),
     subscription_past_due: z.boolean(),
     subscription_revoked: z.boolean(),
     subscription_uncanceled: z.boolean(),
@@ -40,6 +42,7 @@ export const OrganizationCustomerEmailSettings$inboundSchema: z.ZodMiniType<
       "subscription_cancellation": "subscriptionCancellation",
       "subscription_confirmation": "subscriptionConfirmation",
       "subscription_cycled": "subscriptionCycled",
+      "subscription_cycled_after_trial": "subscriptionCycledAfterTrial",
       "subscription_past_due": "subscriptionPastDue",
       "subscription_revoked": "subscriptionRevoked",
       "subscription_uncanceled": "subscriptionUncanceled",
@@ -53,6 +56,7 @@ export type OrganizationCustomerEmailSettings$Outbound = {
   subscription_cancellation: boolean;
   subscription_confirmation: boolean;
   subscription_cycled: boolean;
+  subscription_cycled_after_trial: boolean;
   subscription_past_due: boolean;
   subscription_revoked: boolean;
   subscription_uncanceled: boolean;
@@ -69,6 +73,7 @@ export const OrganizationCustomerEmailSettings$outboundSchema: z.ZodMiniType<
     subscriptionCancellation: z.boolean(),
     subscriptionConfirmation: z.boolean(),
     subscriptionCycled: z.boolean(),
+    subscriptionCycledAfterTrial: z.boolean(),
     subscriptionPastDue: z.boolean(),
     subscriptionRevoked: z.boolean(),
     subscriptionUncanceled: z.boolean(),
@@ -80,6 +85,7 @@ export const OrganizationCustomerEmailSettings$outboundSchema: z.ZodMiniType<
       subscriptionCancellation: "subscription_cancellation",
       subscriptionConfirmation: "subscription_confirmation",
       subscriptionCycled: "subscription_cycled",
+      subscriptionCycledAfterTrial: "subscription_cycled_after_trial",
       subscriptionPastDue: "subscription_past_due",
       subscriptionRevoked: "subscription_revoked",
       subscriptionUncanceled: "subscription_uncanceled",

package/src/models/components/organizationsocialplatforms.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 OrganizationSocialPlatforms = {
   X: "x",
@@ -15,15 +16,17 @@ export const OrganizationSocialPlatforms = {
   Linkedin: "linkedin",
   Other: "other",
 } as const;
-export type OrganizationSocialPlatforms = ClosedEnum<
+export type OrganizationSocialPlatforms = OpenEnum<
   typeof OrganizationSocialPlatforms
 >;
 
 /** @internal */
-export const OrganizationSocialPlatforms$inboundSchema: z.ZodMiniEnum<
-  typeof OrganizationSocialPlatforms
-> = z.enum(OrganizationSocialPlatforms);
+export const OrganizationSocialPlatforms$inboundSchema: z.ZodMiniType<
+  OrganizationSocialPlatforms,
+  unknown
+> = openEnums.inboundSchema(OrganizationSocialPlatforms);
 /** @internal */
-export const OrganizationSocialPlatforms$outboundSchema: z.ZodMiniEnum<
-  typeof OrganizationSocialPlatforms
-> = OrganizationSocialPlatforms$inboundSchema;
+export const OrganizationSocialPlatforms$outboundSchema: z.ZodMiniType<
+  string,
+  OrganizationSocialPlatforms
+> = openEnums.outboundSchema(OrganizationSocialPlatforms);

package/src/models/components/organizationstatus.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 OrganizationStatus = {
   Created: "created",
@@ -13,13 +14,15 @@ export const OrganizationStatus = {
   Denied: "denied",
   Active: "active",
 } as const;
-export type OrganizationStatus = ClosedEnum<typeof OrganizationStatus>;
+export type OrganizationStatus = OpenEnum<typeof OrganizationStatus>;
 
 /** @internal */
-export const OrganizationStatus$inboundSchema: z.ZodMiniEnum<
-  typeof OrganizationStatus
-> = z.enum(OrganizationStatus);
+export const OrganizationStatus$inboundSchema: z.ZodMiniType<
+  OrganizationStatus,
+  unknown
+> = openEnums.inboundSchema(OrganizationStatus);
 /** @internal */
-export const OrganizationStatus$outboundSchema: z.ZodMiniEnum<
-  typeof OrganizationStatus
-> = OrganizationStatus$inboundSchema;
+export const OrganizationStatus$outboundSchema: z.ZodMiniType<
+  string,
+  OrganizationStatus
+> = openEnums.outboundSchema(OrganizationStatus);

package/src/models/components/paymentstatus.ts

@@ -3,18 +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 PaymentStatus = {
   Pending: "pending",
   Succeeded: "succeeded",
   Failed: "failed",
 } as const;
-export type PaymentStatus = ClosedEnum<typeof PaymentStatus>;
+export type PaymentStatus = OpenEnum<typeof PaymentStatus>;
 
 /** @internal */
-export const PaymentStatus$inboundSchema: z.ZodMiniEnum<typeof PaymentStatus> =
-  z.enum(PaymentStatus);
+export const PaymentStatus$inboundSchema: z.ZodMiniType<
+  PaymentStatus,
+  unknown
+> = openEnums.inboundSchema(PaymentStatus);
 /** @internal */
-export const PaymentStatus$outboundSchema: z.ZodMiniEnum<typeof PaymentStatus> =
-  PaymentStatus$inboundSchema;
+export const PaymentStatus$outboundSchema: z.ZodMiniType<
+  string,
+  PaymentStatus
+> = openEnums.outboundSchema(PaymentStatus);