@paygentic/sdk 0.3.1-beta.0 → 0.4.0-beta.2

package/src/models/plan.ts

@@ -3,16 +3,11 @@
  */
 
 import * as z from "zod";
+import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import {
-  PaymentOptions,
-  PaymentOptions$inboundSchema,
-  PaymentOptions$Outbound,
-  PaymentOptions$outboundSchema,
-} from "./paymentoptions.js";
 import {
   SchemasPrice,
   SchemasPrice$inboundSchema,
@@ -25,6 +20,11 @@ export const PlanObject = {
 } as const;
 export type PlanObject = ClosedEnum<typeof PlanObject>;
 
+export type PlanPaymentTerm = {
+  instant?: boolean | undefined;
+  inArrears?: boolean | undefined;
+};
+
 export type Plan = {
   /**
    * Unique identifier for a plan
@@ -32,10 +32,7 @@ export type Plan = {
   id?: string | undefined;
   object?: PlanObject | undefined;
   name?: string | undefined;
-  /**
-   * Payment options for the plan, pre/post paid, pay as you go, outOfBand payments.
-   */
-  paymentOptions?: PaymentOptions | undefined;
+  paymentTerm?: PlanPaymentTerm | undefined;
   invoiceDisplayName?: string | undefined;
   description?: string | undefined;
   billingInterval?: string | undefined;
@@ -78,13 +75,76 @@ export namespace PlanObject$ {
   export const outboundSchema = PlanObject$outboundSchema;
 }
 
+/** @internal */
+export const PlanPaymentTerm$inboundSchema: z.ZodType<
+  PlanPaymentTerm,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  instant: z.boolean().optional(),
+  in_arrears: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "in_arrears": "inArrears",
+  });
+});
+
+/** @internal */
+export type PlanPaymentTerm$Outbound = {
+  instant?: boolean | undefined;
+  in_arrears?: boolean | undefined;
+};
+
+/** @internal */
+export const PlanPaymentTerm$outboundSchema: z.ZodType<
+  PlanPaymentTerm$Outbound,
+  z.ZodTypeDef,
+  PlanPaymentTerm
+> = z.object({
+  instant: z.boolean().optional(),
+  inArrears: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    inArrears: "in_arrears",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace PlanPaymentTerm$ {
+  /** @deprecated use `PlanPaymentTerm$inboundSchema` instead. */
+  export const inboundSchema = PlanPaymentTerm$inboundSchema;
+  /** @deprecated use `PlanPaymentTerm$outboundSchema` instead. */
+  export const outboundSchema = PlanPaymentTerm$outboundSchema;
+  /** @deprecated use `PlanPaymentTerm$Outbound` instead. */
+  export type Outbound = PlanPaymentTerm$Outbound;
+}
+
+export function planPaymentTermToJSON(
+  planPaymentTerm: PlanPaymentTerm,
+): string {
+  return JSON.stringify(PlanPaymentTerm$outboundSchema.parse(planPaymentTerm));
+}
+
+export function planPaymentTermFromJSON(
+  jsonString: string,
+): SafeParseResult<PlanPaymentTerm, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PlanPaymentTerm$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PlanPaymentTerm' from JSON`,
+  );
+}
+
 /** @internal */
 export const Plan$inboundSchema: z.ZodType<Plan, z.ZodTypeDef, unknown> = z
   .object({
     id: z.string().optional(),
     object: PlanObject$inboundSchema.optional(),
     name: z.string().optional(),
-    paymentOptions: PaymentOptions$inboundSchema.optional(),
+    paymentTerm: z.lazy(() => PlanPaymentTerm$inboundSchema).optional(),
     invoiceDisplayName: z.string().optional(),
     description: z.string().optional(),
     billingInterval: z.string().optional(),
@@ -107,7 +167,7 @@ export type Plan$Outbound = {
   id?: string | undefined;
   object?: string | undefined;
   name?: string | undefined;
-  paymentOptions?: PaymentOptions$Outbound | undefined;
+  paymentTerm?: PlanPaymentTerm$Outbound | undefined;
   invoiceDisplayName?: string | undefined;
   description?: string | undefined;
   billingInterval?: string | undefined;
@@ -128,7 +188,7 @@ export const Plan$outboundSchema: z.ZodType<Plan$Outbound, z.ZodTypeDef, Plan> =
     id: z.string().optional(),
     object: PlanObject$outboundSchema.optional(),
     name: z.string().optional(),
-    paymentOptions: PaymentOptions$outboundSchema.optional(),
+    paymentTerm: z.lazy(() => PlanPaymentTerm$outboundSchema).optional(),
     invoiceDisplayName: z.string().optional(),
     description: z.string().optional(),
     billingInterval: z.string().optional(),

package/src/models/price.ts

@@ -21,6 +21,12 @@ export const PriceModel = {
 } as const;
 export type PriceModel = ClosedEnum<typeof PriceModel>;
 
+export const PricePaymentTerm = {
+  Instant: "instant",
+  InArrears: "in_arrears",
+} as const;
+export type PricePaymentTerm = ClosedEnum<typeof PricePaymentTerm>;
+
 export type Properties4 = {
   percentage: string;
   minCharge: string;
@@ -55,11 +61,12 @@ export type Price = {
    */
   billableMetricId?: string | undefined;
   model?: PriceModel | undefined;
+  paymentTerm?: PricePaymentTerm | undefined;
   invoiceDisplayName?: string | undefined;
   /**
-   * The tax rate for the price. This is a percentage string, e.g. '10%'
+   * The tax rate for the price as a percentage (e.g., 10 for 10%)
    */
-  taxRate?: string | undefined;
+  taxRate?: number | undefined;
   properties?:
     | Properties4
     | Properties2
@@ -109,6 +116,27 @@ export namespace PriceModel$ {
   export const outboundSchema = PriceModel$outboundSchema;
 }
 
+/** @internal */
+export const PricePaymentTerm$inboundSchema: z.ZodNativeEnum<
+  typeof PricePaymentTerm
+> = z.nativeEnum(PricePaymentTerm);
+
+/** @internal */
+export const PricePaymentTerm$outboundSchema: z.ZodNativeEnum<
+  typeof PricePaymentTerm
+> = PricePaymentTerm$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace PricePaymentTerm$ {
+  /** @deprecated use `PricePaymentTerm$inboundSchema` instead. */
+  export const inboundSchema = PricePaymentTerm$inboundSchema;
+  /** @deprecated use `PricePaymentTerm$outboundSchema` instead. */
+  export const outboundSchema = PricePaymentTerm$outboundSchema;
+}
+
 /** @internal */
 export const Properties4$inboundSchema: z.ZodType<
   Properties4,
@@ -388,8 +416,9 @@ export const Price$inboundSchema: z.ZodType<Price, z.ZodTypeDef, unknown> = z
     object: PriceObject$inboundSchema.default("price"),
     billableMetricId: z.string().optional(),
     model: PriceModel$inboundSchema.optional(),
+    paymentTerm: PricePaymentTerm$inboundSchema.optional(),
     invoiceDisplayName: z.string().optional(),
-    taxRate: z.string().optional(),
+    taxRate: z.number().optional(),
     properties: z.union([
       z.lazy(() => Properties4$inboundSchema),
       z.lazy(() => Properties2$inboundSchema),
@@ -410,8 +439,9 @@ export type Price$Outbound = {
   object: string;
   billableMetricId?: string | undefined;
   model?: string | undefined;
+  paymentTerm?: string | undefined;
   invoiceDisplayName?: string | undefined;
-  taxRate?: string | undefined;
+  taxRate?: number | undefined;
   properties?:
     | Properties4$Outbound
     | Properties2$Outbound
@@ -433,8 +463,9 @@ export const Price$outboundSchema: z.ZodType<
   object: PriceObject$outboundSchema.default("price"),
   billableMetricId: z.string().optional(),
   model: PriceModel$outboundSchema.optional(),
+  paymentTerm: PricePaymentTerm$outboundSchema.optional(),
   invoiceDisplayName: z.string().optional(),
-  taxRate: z.string().optional(),
+  taxRate: z.number().optional(),
   properties: z.union([
     z.lazy(() => Properties4$outboundSchema),
     z.lazy(() => Properties2$outboundSchema),

package/src/models/pricepropertiesunion.ts

@@ -3,7 +3,11 @@
  */
 
 import * as z from "zod";
-import { safeParse } from "../lib/schemas.js";
+import { remap as remap$ } from "../lib/primitives.js";
+import {
+  collectExtraKeys as collectExtraKeys$,
+  safeParse,
+} from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
@@ -39,6 +43,7 @@ export type ParametersT = {
    * Gradient for dynamic pricing calculations
    */
   gradient?: string | undefined;
+  additionalProperties?: { [k: string]: any };
 };
 
 export type PriceProperties3 = {
@@ -138,12 +143,16 @@ export const ParametersT$inboundSchema: z.ZodType<
   ParametersT,
   z.ZodTypeDef,
   unknown
-> = z.object({
-  function: z.string().optional(),
-  min: z.string().optional(),
-  max: z.string().optional(),
-  gradient: z.string().optional(),
-});
+> = collectExtraKeys$(
+  z.object({
+    function: z.string().optional(),
+    min: z.string().optional(),
+    max: z.string().optional(),
+    gradient: z.string().optional(),
+  }).catchall(z.any()),
+  "additionalProperties",
+  true,
+);
 
 /** @internal */
 export type ParametersT$Outbound = {
@@ -151,6 +160,7 @@ export type ParametersT$Outbound = {
   min?: string | undefined;
   max?: string | undefined;
   gradient?: string | undefined;
+  [additionalProperties: string]: unknown;
 };
 
 /** @internal */
@@ -163,6 +173,14 @@ export const ParametersT$outboundSchema: z.ZodType<
   min: z.string().optional(),
   max: z.string().optional(),
   gradient: z.string().optional(),
+  additionalProperties: z.record(z.any()),
+}).transform((v) => {
+  return {
+    ...v.additionalProperties,
+    ...remap$(v, {
+      additionalProperties: null,
+    }),
+  };
 });
 
 /**

package/src/models/schemasprice.ts

@@ -21,6 +21,14 @@ export const SchemasPriceModel = {
 } as const;
 export type SchemasPriceModel = ClosedEnum<typeof SchemasPriceModel>;
 
+export const SchemasPricePaymentTerm = {
+  Instant: "instant",
+  InArrears: "in_arrears",
+} as const;
+export type SchemasPricePaymentTerm = ClosedEnum<
+  typeof SchemasPricePaymentTerm
+>;
+
 export type SchemasPrice = {
   /**
    * Unique identifier for a price
@@ -29,6 +37,7 @@ export type SchemasPrice = {
   object?: SchemasPriceObject | undefined;
   billableMetricId?: string | undefined;
   model?: SchemasPriceModel | undefined;
+  paymentTerm?: SchemasPricePaymentTerm | undefined;
   invoiceDisplayName?: string | undefined;
   properties?: { [k: string]: any } | undefined;
   description?: string | undefined;
@@ -80,6 +89,27 @@ export namespace SchemasPriceModel$ {
   export const outboundSchema = SchemasPriceModel$outboundSchema;
 }
 
+/** @internal */
+export const SchemasPricePaymentTerm$inboundSchema: z.ZodNativeEnum<
+  typeof SchemasPricePaymentTerm
+> = z.nativeEnum(SchemasPricePaymentTerm);
+
+/** @internal */
+export const SchemasPricePaymentTerm$outboundSchema: z.ZodNativeEnum<
+  typeof SchemasPricePaymentTerm
+> = SchemasPricePaymentTerm$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace SchemasPricePaymentTerm$ {
+  /** @deprecated use `SchemasPricePaymentTerm$inboundSchema` instead. */
+  export const inboundSchema = SchemasPricePaymentTerm$inboundSchema;
+  /** @deprecated use `SchemasPricePaymentTerm$outboundSchema` instead. */
+  export const outboundSchema = SchemasPricePaymentTerm$outboundSchema;
+}
+
 /** @internal */
 export const SchemasPrice$inboundSchema: z.ZodType<
   SchemasPrice,
@@ -90,6 +120,7 @@ export const SchemasPrice$inboundSchema: z.ZodType<
   object: SchemasPriceObject$inboundSchema.default("price"),
   billableMetricId: z.string().optional(),
   model: SchemasPriceModel$inboundSchema.optional(),
+  paymentTerm: SchemasPricePaymentTerm$inboundSchema.optional(),
   invoiceDisplayName: z.string().optional(),
   properties: z.record(z.any()).optional(),
   description: z.string().optional(),
@@ -107,6 +138,7 @@ export type SchemasPrice$Outbound = {
   object: string;
   billableMetricId?: string | undefined;
   model?: string | undefined;
+  paymentTerm?: string | undefined;
   invoiceDisplayName?: string | undefined;
   properties?: { [k: string]: any } | undefined;
   description?: string | undefined;
@@ -126,6 +158,7 @@ export const SchemasPrice$outboundSchema: z.ZodType<
   object: SchemasPriceObject$outboundSchema.default("price"),
   billableMetricId: z.string().optional(),
   model: SchemasPriceModel$outboundSchema.optional(),
+  paymentTerm: SchemasPricePaymentTerm$outboundSchema.optional(),
   invoiceDisplayName: z.string().optional(),
   properties: z.record(z.any()).optional(),
   description: z.string().optional(),

package/src/models/subscription.ts

@@ -14,11 +14,77 @@ export const SubscriptionObject = {
 export type SubscriptionObject = ClosedEnum<typeof SubscriptionObject>;
 
 export const SubscriptionStatus = {
+  PendingPayment: "pending_payment",
   Active: "active",
   Terminated: "terminated",
 } as const;
 export type SubscriptionStatus = ClosedEnum<typeof SubscriptionStatus>;
 
+export type Item = {
+  billableMetricId?: string | undefined;
+  billableMetricName?: string | undefined;
+  quantity?: number | undefined;
+  /**
+   * Unit price in nanodollars
+   */
+  unitPrice?: string | undefined;
+  /**
+   * Total cost in nanodollars
+   */
+  totalCost?: string | undefined;
+};
+
+/**
+ * Payment status
+ */
+export const StatusPending = {
+  Pending: "pending",
+} as const;
+/**
+ * Payment status
+ */
+export type StatusPending = ClosedEnum<typeof StatusPending>;
+
+/**
+ * Breakdown of payment amount
+ */
+export type Breakdown = {
+  /**
+   * Upfront flat-fee charges in decimal dollars
+   */
+  upfrontCharges: string;
+  /**
+   * Wallet prefund amount in decimal dollars
+   */
+  walletPrefund: string;
+};
+
+/**
+ * Payment session details when upfront payment is required
+ */
+export type Payment = {
+  /**
+   * Payment session ID
+   */
+  paymentSessionId: string;
+  /**
+   * URL to redirect customer for payment
+   */
+  checkoutUrl: string;
+  /**
+   * Total amount in decimal dollars
+   */
+  amount: string;
+  /**
+   * Payment status
+   */
+  status: StatusPending;
+  /**
+   * Breakdown of payment amount
+   */
+  breakdown: Breakdown;
+};
+
 export type Subscription = {
   id?: string | undefined;
   object?: SubscriptionObject | undefined;
@@ -43,6 +109,18 @@ export type Subscription = {
    * Reason for termination
    */
   terminationReason?: string | undefined;
+  /**
+   * Array of upfront subscription items with quantities and costs
+   */
+  items?: Array<Item> | undefined;
+  /**
+   * Minimum wallet balance in nanodollars
+   */
+  prefundAmount?: string | undefined;
+  /**
+   * Payment session details when upfront payment is required
+   */
+  payment?: Payment | undefined;
 };
 
 /** @internal */
@@ -87,6 +165,195 @@ export namespace SubscriptionStatus$ {
   export const outboundSchema = SubscriptionStatus$outboundSchema;
 }
 
+/** @internal */
+export const Item$inboundSchema: z.ZodType<Item, z.ZodTypeDef, unknown> = z
+  .object({
+    billableMetricId: z.string().optional(),
+    billableMetricName: z.string().optional(),
+    quantity: z.number().optional(),
+    unitPrice: z.string().optional(),
+    totalCost: z.string().optional(),
+  });
+
+/** @internal */
+export type Item$Outbound = {
+  billableMetricId?: string | undefined;
+  billableMetricName?: string | undefined;
+  quantity?: number | undefined;
+  unitPrice?: string | undefined;
+  totalCost?: string | undefined;
+};
+
+/** @internal */
+export const Item$outboundSchema: z.ZodType<Item$Outbound, z.ZodTypeDef, Item> =
+  z.object({
+    billableMetricId: z.string().optional(),
+    billableMetricName: z.string().optional(),
+    quantity: z.number().optional(),
+    unitPrice: z.string().optional(),
+    totalCost: z.string().optional(),
+  });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Item$ {
+  /** @deprecated use `Item$inboundSchema` instead. */
+  export const inboundSchema = Item$inboundSchema;
+  /** @deprecated use `Item$outboundSchema` instead. */
+  export const outboundSchema = Item$outboundSchema;
+  /** @deprecated use `Item$Outbound` instead. */
+  export type Outbound = Item$Outbound;
+}
+
+export function itemToJSON(item: Item): string {
+  return JSON.stringify(Item$outboundSchema.parse(item));
+}
+
+export function itemFromJSON(
+  jsonString: string,
+): SafeParseResult<Item, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Item$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Item' from JSON`,
+  );
+}
+
+/** @internal */
+export const StatusPending$inboundSchema: z.ZodNativeEnum<
+  typeof StatusPending
+> = z.nativeEnum(StatusPending);
+
+/** @internal */
+export const StatusPending$outboundSchema: z.ZodNativeEnum<
+  typeof StatusPending
+> = StatusPending$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace StatusPending$ {
+  /** @deprecated use `StatusPending$inboundSchema` instead. */
+  export const inboundSchema = StatusPending$inboundSchema;
+  /** @deprecated use `StatusPending$outboundSchema` instead. */
+  export const outboundSchema = StatusPending$outboundSchema;
+}
+
+/** @internal */
+export const Breakdown$inboundSchema: z.ZodType<
+  Breakdown,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  upfrontCharges: z.string(),
+  walletPrefund: z.string(),
+});
+
+/** @internal */
+export type Breakdown$Outbound = {
+  upfrontCharges: string;
+  walletPrefund: string;
+};
+
+/** @internal */
+export const Breakdown$outboundSchema: z.ZodType<
+  Breakdown$Outbound,
+  z.ZodTypeDef,
+  Breakdown
+> = z.object({
+  upfrontCharges: z.string(),
+  walletPrefund: z.string(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Breakdown$ {
+  /** @deprecated use `Breakdown$inboundSchema` instead. */
+  export const inboundSchema = Breakdown$inboundSchema;
+  /** @deprecated use `Breakdown$outboundSchema` instead. */
+  export const outboundSchema = Breakdown$outboundSchema;
+  /** @deprecated use `Breakdown$Outbound` instead. */
+  export type Outbound = Breakdown$Outbound;
+}
+
+export function breakdownToJSON(breakdown: Breakdown): string {
+  return JSON.stringify(Breakdown$outboundSchema.parse(breakdown));
+}
+
+export function breakdownFromJSON(
+  jsonString: string,
+): SafeParseResult<Breakdown, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Breakdown$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Breakdown' from JSON`,
+  );
+}
+
+/** @internal */
+export const Payment$inboundSchema: z.ZodType<Payment, z.ZodTypeDef, unknown> =
+  z.object({
+    paymentSessionId: z.string(),
+    checkoutUrl: z.string(),
+    amount: z.string(),
+    status: StatusPending$inboundSchema,
+    breakdown: z.lazy(() => Breakdown$inboundSchema),
+  });
+
+/** @internal */
+export type Payment$Outbound = {
+  paymentSessionId: string;
+  checkoutUrl: string;
+  amount: string;
+  status: string;
+  breakdown: Breakdown$Outbound;
+};
+
+/** @internal */
+export const Payment$outboundSchema: z.ZodType<
+  Payment$Outbound,
+  z.ZodTypeDef,
+  Payment
+> = z.object({
+  paymentSessionId: z.string(),
+  checkoutUrl: z.string(),
+  amount: z.string(),
+  status: StatusPending$outboundSchema,
+  breakdown: z.lazy(() => Breakdown$outboundSchema),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Payment$ {
+  /** @deprecated use `Payment$inboundSchema` instead. */
+  export const inboundSchema = Payment$inboundSchema;
+  /** @deprecated use `Payment$outboundSchema` instead. */
+  export const outboundSchema = Payment$outboundSchema;
+  /** @deprecated use `Payment$Outbound` instead. */
+  export type Outbound = Payment$Outbound;
+}
+
+export function paymentToJSON(payment: Payment): string {
+  return JSON.stringify(Payment$outboundSchema.parse(payment));
+}
+
+export function paymentFromJSON(
+  jsonString: string,
+): SafeParseResult<Payment, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Payment$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Payment' from JSON`,
+  );
+}
+
 /** @internal */
 export const Subscription$inboundSchema: z.ZodType<
   Subscription,
@@ -113,6 +380,9 @@ export const Subscription$inboundSchema: z.ZodType<
   ).optional(),
   terminatedBy: z.string().optional(),
   terminationReason: z.string().optional(),
+  items: z.array(z.lazy(() => Item$inboundSchema)).optional(),
+  prefundAmount: z.string().optional(),
+  payment: z.lazy(() => Payment$inboundSchema).optional(),
 });
 
 /** @internal */
@@ -131,6 +401,9 @@ export type Subscription$Outbound = {
   terminatedAt?: string | undefined;
   terminatedBy?: string | undefined;
   terminationReason?: string | undefined;
+  items?: Array<Item$Outbound> | undefined;
+  prefundAmount?: string | undefined;
+  payment?: Payment$Outbound | undefined;
 };
 
 /** @internal */
@@ -153,6 +426,9 @@ export const Subscription$outboundSchema: z.ZodType<
   terminatedAt: z.date().transform(v => v.toISOString()).optional(),
   terminatedBy: z.string().optional(),
   terminationReason: z.string().optional(),
+  items: z.array(z.lazy(() => Item$outboundSchema)).optional(),
+  prefundAmount: z.string().optional(),
+  payment: z.lazy(() => Payment$outboundSchema).optional(),
 });
 
 /**