@polar-sh/sdk 0.43.0 → 0.44.0

package/src/models/components/productvisibility.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 ProductVisibility = {
   Draft: "draft",
   Private: "private",
   Public: "public",
 } as const;
-export type ProductVisibility = ClosedEnum<typeof ProductVisibility>;
+export type ProductVisibility = OpenEnum<typeof ProductVisibility>;
 
 /** @internal */
-export const ProductVisibility$inboundSchema: z.ZodMiniEnum<
-  typeof ProductVisibility
-> = z.enum(ProductVisibility);
+export const ProductVisibility$inboundSchema: z.ZodMiniType<
+  ProductVisibility,
+  unknown
+> = openEnums.inboundSchema(ProductVisibility);
 /** @internal */
-export const ProductVisibility$outboundSchema: z.ZodMiniEnum<
-  typeof ProductVisibility
-> = ProductVisibility$inboundSchema;
+export const ProductVisibility$outboundSchema: z.ZodMiniType<
+  string,
+  ProductVisibility
+> = openEnums.outboundSchema(ProductVisibility);

package/src/models/components/propertyaggregation.ts

@@ -4,7 +4,8 @@
 
 import * as z from "zod/v4-mini";
 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";
 
@@ -14,7 +15,7 @@ export const Func = {
   Min: "min",
   Avg: "avg",
 } as const;
-export type Func = ClosedEnum<typeof Func>;
+export type Func = OpenEnum<typeof Func>;
 
 export type PropertyAggregation = {
   func: Func;
@@ -22,10 +23,11 @@ export type PropertyAggregation = {
 };
 
 /** @internal */
-export const Func$inboundSchema: z.ZodMiniEnum<typeof Func> = z.enum(Func);
+export const Func$inboundSchema: z.ZodMiniType<Func, unknown> = openEnums
+  .inboundSchema(Func);
 /** @internal */
-export const Func$outboundSchema: z.ZodMiniEnum<typeof Func> =
-  Func$inboundSchema;
+export const Func$outboundSchema: z.ZodMiniType<string, Func> = openEnums
+  .outboundSchema(Func);
 
 /** @internal */
 export const PropertyAggregation$inboundSchema: z.ZodMiniType<

package/src/models/components/refundreason.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 RefundReason = {
   Duplicate: "duplicate",
@@ -14,11 +15,11 @@ export const RefundReason = {
   DisputePrevention: "dispute_prevention",
   Other: "other",
 } as const;
-export type RefundReason = ClosedEnum<typeof RefundReason>;
+export type RefundReason = OpenEnum<typeof RefundReason>;
 
 /** @internal */
-export const RefundReason$inboundSchema: z.ZodMiniEnum<typeof RefundReason> = z
-  .enum(RefundReason);
+export const RefundReason$inboundSchema: z.ZodMiniType<RefundReason, unknown> =
+  openEnums.inboundSchema(RefundReason);
 /** @internal */
-export const RefundReason$outboundSchema: z.ZodMiniEnum<typeof RefundReason> =
-  RefundReason$inboundSchema;
+export const RefundReason$outboundSchema: z.ZodMiniType<string, RefundReason> =
+  openEnums.outboundSchema(RefundReason);

package/src/models/components/refundstatus.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 RefundStatus = {
   Pending: "pending",
@@ -11,11 +12,11 @@ export const RefundStatus = {
   Failed: "failed",
   Canceled: "canceled",
 } as const;
-export type RefundStatus = ClosedEnum<typeof RefundStatus>;
+export type RefundStatus = OpenEnum<typeof RefundStatus>;
 
 /** @internal */
-export const RefundStatus$inboundSchema: z.ZodMiniEnum<typeof RefundStatus> = z
-  .enum(RefundStatus);
+export const RefundStatus$inboundSchema: z.ZodMiniType<RefundStatus, unknown> =
+  openEnums.inboundSchema(RefundStatus);
 /** @internal */
-export const RefundStatus$outboundSchema: z.ZodMiniEnum<typeof RefundStatus> =
-  RefundStatus$inboundSchema;
+export const RefundStatus$outboundSchema: z.ZodMiniType<string, RefundStatus> =
+  openEnums.outboundSchema(RefundStatus);

package/src/models/components/scope.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 Scope = {
   Openid: "openid",
@@ -70,7 +71,8 @@ export const Scope = {
   OrganizationAccessTokensRead: "organization_access_tokens:read",
   OrganizationAccessTokensWrite: "organization_access_tokens:write",
 } as const;
-export type Scope = ClosedEnum<typeof Scope>;
+export type Scope = OpenEnum<typeof Scope>;
 
 /** @internal */
-export const Scope$inboundSchema: z.ZodMiniEnum<typeof Scope> = z.enum(Scope);
+export const Scope$inboundSchema: z.ZodMiniType<Scope, unknown> = openEnums
+  .inboundSchema(Scope);

package/src/models/components/seatstatus.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 SeatStatus = {
   Pending: "pending",
   Claimed: "claimed",
   Revoked: "revoked",
 } as const;
-export type SeatStatus = ClosedEnum<typeof SeatStatus>;
+export type SeatStatus = OpenEnum<typeof SeatStatus>;
 
 /** @internal */
-export const SeatStatus$inboundSchema: z.ZodMiniEnum<typeof SeatStatus> = z
-  .enum(SeatStatus);
+export const SeatStatus$inboundSchema: z.ZodMiniType<SeatStatus, unknown> =
+  openEnums.inboundSchema(SeatStatus);
 /** @internal */
-export const SeatStatus$outboundSchema: z.ZodMiniEnum<typeof SeatStatus> =
-  SeatStatus$inboundSchema;
+export const SeatStatus$outboundSchema: z.ZodMiniType<string, SeatStatus> =
+  openEnums.outboundSchema(SeatStatus);

package/src/models/components/subscriptionprorationbehavior.ts

@@ -3,21 +3,24 @@
  */
 
 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 SubscriptionProrationBehavior = {
   Invoice: "invoice",
   Prorate: "prorate",
 } as const;
-export type SubscriptionProrationBehavior = ClosedEnum<
+export type SubscriptionProrationBehavior = OpenEnum<
   typeof SubscriptionProrationBehavior
 >;
 
 /** @internal */
-export const SubscriptionProrationBehavior$inboundSchema: z.ZodMiniEnum<
-  typeof SubscriptionProrationBehavior
-> = z.enum(SubscriptionProrationBehavior);
+export const SubscriptionProrationBehavior$inboundSchema: z.ZodMiniType<
+  SubscriptionProrationBehavior,
+  unknown
+> = openEnums.inboundSchema(SubscriptionProrationBehavior);
 /** @internal */
-export const SubscriptionProrationBehavior$outboundSchema: z.ZodMiniEnum<
-  typeof SubscriptionProrationBehavior
-> = SubscriptionProrationBehavior$inboundSchema;
+export const SubscriptionProrationBehavior$outboundSchema: z.ZodMiniType<
+  string,
+  SubscriptionProrationBehavior
+> = openEnums.outboundSchema(SubscriptionProrationBehavior);

package/src/models/components/subscriptionrecurringinterval.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 SubscriptionRecurringInterval = {
   Day: "day",
@@ -11,15 +12,17 @@ export const SubscriptionRecurringInterval = {
   Month: "month",
   Year: "year",
 } as const;
-export type SubscriptionRecurringInterval = ClosedEnum<
+export type SubscriptionRecurringInterval = OpenEnum<
   typeof SubscriptionRecurringInterval
 >;
 
 /** @internal */
-export const SubscriptionRecurringInterval$inboundSchema: z.ZodMiniEnum<
-  typeof SubscriptionRecurringInterval
-> = z.enum(SubscriptionRecurringInterval);
+export const SubscriptionRecurringInterval$inboundSchema: z.ZodMiniType<
+  SubscriptionRecurringInterval,
+  unknown
+> = openEnums.inboundSchema(SubscriptionRecurringInterval);
 /** @internal */
-export const SubscriptionRecurringInterval$outboundSchema: z.ZodMiniEnum<
-  typeof SubscriptionRecurringInterval
-> = SubscriptionRecurringInterval$inboundSchema;
+export const SubscriptionRecurringInterval$outboundSchema: z.ZodMiniType<
+  string,
+  SubscriptionRecurringInterval
+> = openEnums.outboundSchema(SubscriptionRecurringInterval);

package/src/models/components/subscriptionstatus.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 SubscriptionStatus = {
   Incomplete: "incomplete",
@@ -14,13 +15,15 @@ export const SubscriptionStatus = {
   Canceled: "canceled",
   Unpaid: "unpaid",
 } as const;
-export type SubscriptionStatus = ClosedEnum<typeof SubscriptionStatus>;
+export type SubscriptionStatus = OpenEnum<typeof SubscriptionStatus>;
 
 /** @internal */
-export const SubscriptionStatus$inboundSchema: z.ZodMiniEnum<
-  typeof SubscriptionStatus
-> = z.enum(SubscriptionStatus);
+export const SubscriptionStatus$inboundSchema: z.ZodMiniType<
+  SubscriptionStatus,
+  unknown
+> = openEnums.inboundSchema(SubscriptionStatus);
 /** @internal */
-export const SubscriptionStatus$outboundSchema: z.ZodMiniEnum<
-  typeof SubscriptionStatus
-> = SubscriptionStatus$inboundSchema;
+export const SubscriptionStatus$outboundSchema: z.ZodMiniType<
+  string,
+  SubscriptionStatus
+> = openEnums.outboundSchema(SubscriptionStatus);

package/src/models/components/subtype.ts

@@ -3,18 +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 SubType = {
   User: "user",
   Organization: "organization",
 } as const;
-export type SubType = ClosedEnum<typeof SubType>;
+export type SubType = OpenEnum<typeof SubType>;
 
 /** @internal */
-export const SubType$inboundSchema: z.ZodMiniEnum<typeof SubType> = z.enum(
-  SubType,
-);
+export const SubType$inboundSchema: z.ZodMiniType<SubType, unknown> = openEnums
+  .inboundSchema(SubType);
 /** @internal */
-export const SubType$outboundSchema: z.ZodMiniEnum<typeof SubType> =
-  SubType$inboundSchema;
+export const SubType$outboundSchema: z.ZodMiniType<string, SubType> = openEnums
+  .outboundSchema(SubType);

package/src/models/components/taxidformat.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";
 
 /**
  * List of supported tax ID formats.
@@ -95,11 +96,11 @@ export const TaxIDFormat = {
  *
  * Ref: https://docs.stripe.com/billing/customer/tax-ids#supported-tax-id
  */
-export type TaxIDFormat = ClosedEnum<typeof TaxIDFormat>;
+export type TaxIDFormat = OpenEnum<typeof TaxIDFormat>;
 
 /** @internal */
-export const TaxIDFormat$inboundSchema: z.ZodMiniEnum<typeof TaxIDFormat> = z
-  .enum(TaxIDFormat);
+export const TaxIDFormat$inboundSchema: z.ZodMiniType<TaxIDFormat, unknown> =
+  openEnums.inboundSchema(TaxIDFormat);
 /** @internal */
-export const TaxIDFormat$outboundSchema: z.ZodMiniEnum<typeof TaxIDFormat> =
-  TaxIDFormat$inboundSchema;
+export const TaxIDFormat$outboundSchema: z.ZodMiniType<string, TaxIDFormat> =
+  openEnums.outboundSchema(TaxIDFormat);

package/src/models/components/trialinterval.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 TrialInterval = {
   Day: "day",
@@ -11,11 +12,15 @@ export const TrialInterval = {
   Month: "month",
   Year: "year",
 } as const;
-export type TrialInterval = ClosedEnum<typeof TrialInterval>;
+export type TrialInterval = OpenEnum<typeof TrialInterval>;
 
 /** @internal */
-export const TrialInterval$inboundSchema: z.ZodMiniEnum<typeof TrialInterval> =
-  z.enum(TrialInterval);
+export const TrialInterval$inboundSchema: z.ZodMiniType<
+  TrialInterval,
+  unknown
+> = openEnums.inboundSchema(TrialInterval);
 /** @internal */
-export const TrialInterval$outboundSchema: z.ZodMiniEnum<typeof TrialInterval> =
-  TrialInterval$inboundSchema;
+export const TrialInterval$outboundSchema: z.ZodMiniType<
+  string,
+  TrialInterval
+> = openEnums.outboundSchema(TrialInterval);

package/src/models/components/validationerror.ts

@@ -10,10 +10,14 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type Loc = string | number;
 
+export type Context = {};
+
 export type ValidationError = {
   loc: Array<string | number>;
   msg: string;
   type: string;
+  input?: any | undefined;
+  ctx?: Context | undefined;
 };
 
 /** @internal */
@@ -43,6 +47,30 @@ export function locFromJSON(
   );
 }
 
+/** @internal */
+export const Context$inboundSchema: z.ZodMiniType<Context, unknown> = z.object(
+  {},
+);
+/** @internal */
+export type Context$Outbound = {};
+
+/** @internal */
+export const Context$outboundSchema: z.ZodMiniType<Context$Outbound, Context> =
+  z.object({});
+
+export function contextToJSON(context: Context): string {
+  return JSON.stringify(Context$outboundSchema.parse(context));
+}
+export function contextFromJSON(
+  jsonString: string,
+): SafeParseResult<Context, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Context$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Context' from JSON`,
+  );
+}
+
 /** @internal */
 export const ValidationError$inboundSchema: z.ZodMiniType<
   ValidationError,
@@ -51,12 +79,16 @@ export const ValidationError$inboundSchema: z.ZodMiniType<
   loc: z.array(smartUnion([z.string(), z.int()])),
   msg: z.string(),
   type: z.string(),
+  input: z.optional(z.any()),
+  ctx: z.optional(z.lazy(() => Context$inboundSchema)),
 });
 /** @internal */
 export type ValidationError$Outbound = {
   loc: Array<string | number>;
   msg: string;
   type: string;
+  input?: any | undefined;
+  ctx?: Context$Outbound | undefined;
 };
 
 /** @internal */
@@ -67,6 +99,8 @@ export const ValidationError$outboundSchema: z.ZodMiniType<
   loc: z.array(smartUnion([z.string(), z.int()])),
   msg: z.string(),
   type: z.string(),
+  input: z.optional(z.any()),
+  ctx: z.optional(z.lazy(() => Context$outboundSchema)),
 });
 
 export function validationErrorToJSON(

package/src/models/components/webhookeventtype.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 WebhookEventType = {
   CheckoutCreated: "checkout.created",
@@ -42,13 +43,15 @@ export const WebhookEventType = {
   BenefitGrantRevoked: "benefit_grant.revoked",
   OrganizationUpdated: "organization.updated",
 } as const;
-export type WebhookEventType = ClosedEnum<typeof WebhookEventType>;
+export type WebhookEventType = OpenEnum<typeof WebhookEventType>;
 
 /** @internal */
-export const WebhookEventType$inboundSchema: z.ZodMiniEnum<
-  typeof WebhookEventType
-> = z.enum(WebhookEventType);
+export const WebhookEventType$inboundSchema: z.ZodMiniType<
+  WebhookEventType,
+  unknown
+> = openEnums.inboundSchema(WebhookEventType);
 /** @internal */
-export const WebhookEventType$outboundSchema: z.ZodMiniEnum<
-  typeof WebhookEventType
-> = WebhookEventType$inboundSchema;
+export const WebhookEventType$outboundSchema: z.ZodMiniType<
+  string,
+  WebhookEventType
+> = openEnums.outboundSchema(WebhookEventType);

package/src/models/components/webhookformat.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 WebhookFormat = {
   Raw: "raw",
   Discord: "discord",
   Slack: "slack",
 } as const;
-export type WebhookFormat = ClosedEnum<typeof WebhookFormat>;
+export type WebhookFormat = OpenEnum<typeof WebhookFormat>;
 
 /** @internal */
-export const WebhookFormat$inboundSchema: z.ZodMiniEnum<typeof WebhookFormat> =
-  z.enum(WebhookFormat);
+export const WebhookFormat$inboundSchema: z.ZodMiniType<
+  WebhookFormat,
+  unknown
+> = openEnums.inboundSchema(WebhookFormat);
 /** @internal */
-export const WebhookFormat$outboundSchema: z.ZodMiniEnum<typeof WebhookFormat> =
-  WebhookFormat$inboundSchema;
+export const WebhookFormat$outboundSchema: z.ZodMiniType<
+  string,
+  WebhookFormat
+> = openEnums.outboundSchema(WebhookFormat);

package/src/models/operations/customerportalmemberslistmembers.ts

@@ -0,0 +1,84 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+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 {
+  ListResourceCustomerPortalMember,
+  ListResourceCustomerPortalMember$inboundSchema,
+} from "../components/listresourcecustomerportalmember.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type CustomerPortalMembersListMembersRequest = {
+  /**
+   * Page number, defaults to 1.
+   */
+  page?: number | undefined;
+  /**
+   * Size of a page, defaults to 10. Maximum is 100.
+   */
+  limit?: number | undefined;
+};
+
+export type CustomerPortalMembersListMembersResponse = {
+  result: ListResourceCustomerPortalMember;
+};
+
+/** @internal */
+export type CustomerPortalMembersListMembersRequest$Outbound = {
+  page: number;
+  limit: number;
+};
+
+/** @internal */
+export const CustomerPortalMembersListMembersRequest$outboundSchema:
+  z.ZodMiniType<
+    CustomerPortalMembersListMembersRequest$Outbound,
+    CustomerPortalMembersListMembersRequest
+  > = z.object({
+    page: z._default(z.int(), 1),
+    limit: z._default(z.int(), 10),
+  });
+
+export function customerPortalMembersListMembersRequestToJSON(
+  customerPortalMembersListMembersRequest:
+    CustomerPortalMembersListMembersRequest,
+): string {
+  return JSON.stringify(
+    CustomerPortalMembersListMembersRequest$outboundSchema.parse(
+      customerPortalMembersListMembersRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const CustomerPortalMembersListMembersResponse$inboundSchema:
+  z.ZodMiniType<CustomerPortalMembersListMembersResponse, unknown> = z.pipe(
+    z.object({
+      Result: ListResourceCustomerPortalMember$inboundSchema,
+    }),
+    z.transform((v) => {
+      return remap$(v, {
+        "Result": "result",
+      });
+    }),
+  );
+
+export function customerPortalMembersListMembersResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  CustomerPortalMembersListMembersResponse,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CustomerPortalMembersListMembersResponse$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'CustomerPortalMembersListMembersResponse' from JSON`,
+  );
+}