@paygentic/sdk 0.9.4 → 0.9.6

package/src/models/priceproperties.ts

@@ -0,0 +1,325 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+/**
+ * Percentage pricing model
+ */
+export type PercentagePriceProperties = {
+  /**
+   * Ceiling amount limiting total charge regardless of percentage calculation. Sample values: '500.00' caps fees at $500 maximum, '2000.00' limits charges to $2000 per period
+   */
+  maxCharge: string;
+  /**
+   * Floor amount charged regardless of percentage calculation. Sample values: '5.00' ensures minimum $5 fee, '25.00' guarantees at least $25 per billing event
+   */
+  minCharge: string;
+  /**
+   * Rate expressed as decimal between 0 and 10, supporting up to 4 decimal precision. Sample values: '0.03' represents 3%, '0.075' represents 7.5%, '1.10' represents 110%
+   */
+  percentage: string;
+};
+
+export type VolumeTier = {
+  /**
+   * Inclusive upper bound of the band, as a decimal string. Null on the last band only, which carries the remainder. Sample values: '100' bounds the band at 100 units, null leaves the top open.
+   */
+  upTo: string | null;
+  /**
+   * Per-unit cost inside this band, as a decimal string, capped at 6 decimal places. Sample values: '5' represents $5 per unit, '0.004' represents $0.004 per unit.
+   */
+  unitPrice: string;
+};
+
+/**
+ * Volume pricing model
+ */
+export type VolumePriceProperties = {
+  /**
+   * Ordered ladder of bands. The band is selected by the period's total metered usage, and its rate applies to every billed unit. A band matches when the quantity is less than or equal to its `upTo`, and the first matching band wins; the previous band's `upTo` is the exclusive lower bound, and the first band's floor is 0.
+   */
+  tiers: Array<VolumeTier>;
+};
+
+/**
+ * Dynamic pricing model
+ */
+export type DynamicPriceProperties = {
+  /**
+   * Upper limit of the price range for dynamic pricing. Sample values: '0.10' means $0.10 per token for large volumes at peak times
+   */
+  maxPrice: string;
+  /**
+   * Lower limit of the price range for dynamic pricing. Sample values: '0.01' means $0.01 per token for low volumes during off-peak hours
+   */
+  minPrice: string;
+};
+
+/**
+ * Standard pricing model
+ */
+export type StandardPriceProperties = {
+  /**
+   * Per-unit cost in decimal format for fixed-rate pricing. Sample values: '0.00002' represents $0.00002 per token, '0.15' represents $0.15 per gigabyte stored, '0.05' represents $0.05 per API call. Per unit. Total per period = quantity × unitPrice; see the `quantity` field. A negative value defines a usage-scaled rebate: the line's subtotal is negative and reduces the invoice. A rebate never drives an invoice total below zero, so set rebate rates below the charges they offset. A negative unitPrice is only valid on a metered price (a billableMetricId is required — there is no usage to scale on a fee price) and cannot be combined with grantDiscountEnabled, a hard-limit feature, or a pricingUnitId. When a rebate and a charge price share a billable metric but attach to different features, they compute against different quantity bases: a price attached to a feature bills the overage against its allowance, while a featureless price bills the raw metered usage. That is a permitted configuration, not an error. Attach both to the same feature to bill them against one basis.
+   */
+  unitPrice: string;
+};
+
+export type PriceProperties =
+  | PercentagePriceProperties
+  | DynamicPriceProperties
+  | StandardPriceProperties
+  | VolumePriceProperties;
+
+/** @internal */
+export const PercentagePriceProperties$inboundSchema: z.ZodType<
+  PercentagePriceProperties,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  maxCharge: z.string(),
+  minCharge: z.string(),
+  percentage: z.string(),
+});
+/** @internal */
+export type PercentagePriceProperties$Outbound = {
+  maxCharge: string;
+  minCharge: string;
+  percentage: string;
+};
+
+/** @internal */
+export const PercentagePriceProperties$outboundSchema: z.ZodType<
+  PercentagePriceProperties$Outbound,
+  z.ZodTypeDef,
+  PercentagePriceProperties
+> = z.object({
+  maxCharge: z.string(),
+  minCharge: z.string(),
+  percentage: z.string(),
+});
+
+export function percentagePricePropertiesToJSON(
+  percentagePriceProperties: PercentagePriceProperties,
+): string {
+  return JSON.stringify(
+    PercentagePriceProperties$outboundSchema.parse(percentagePriceProperties),
+  );
+}
+export function percentagePricePropertiesFromJSON(
+  jsonString: string,
+): SafeParseResult<PercentagePriceProperties, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PercentagePriceProperties$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PercentagePriceProperties' from JSON`,
+  );
+}
+
+/** @internal */
+export const VolumeTier$inboundSchema: z.ZodType<
+  VolumeTier,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  upTo: z.nullable(z.string()),
+  unitPrice: z.string(),
+});
+/** @internal */
+export type VolumeTier$Outbound = {
+  upTo: string | null;
+  unitPrice: string;
+};
+
+/** @internal */
+export const VolumeTier$outboundSchema: z.ZodType<
+  VolumeTier$Outbound,
+  z.ZodTypeDef,
+  VolumeTier
+> = z.object({
+  upTo: z.nullable(z.string()),
+  unitPrice: z.string(),
+});
+
+export function volumeTierToJSON(volumeTier: VolumeTier): string {
+  return JSON.stringify(VolumeTier$outboundSchema.parse(volumeTier));
+}
+export function volumeTierFromJSON(
+  jsonString: string,
+): SafeParseResult<VolumeTier, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VolumeTier$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VolumeTier' from JSON`,
+  );
+}
+
+/** @internal */
+export const VolumePriceProperties$inboundSchema: z.ZodType<
+  VolumePriceProperties,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  tiers: z.array(z.lazy(() => VolumeTier$inboundSchema)),
+});
+/** @internal */
+export type VolumePriceProperties$Outbound = {
+  tiers: Array<VolumeTier$Outbound>;
+};
+
+/** @internal */
+export const VolumePriceProperties$outboundSchema: z.ZodType<
+  VolumePriceProperties$Outbound,
+  z.ZodTypeDef,
+  VolumePriceProperties
+> = z.object({
+  tiers: z.array(z.lazy(() => VolumeTier$outboundSchema)),
+});
+
+export function volumePricePropertiesToJSON(
+  volumePriceProperties: VolumePriceProperties,
+): string {
+  return JSON.stringify(
+    VolumePriceProperties$outboundSchema.parse(volumePriceProperties),
+  );
+}
+export function volumePricePropertiesFromJSON(
+  jsonString: string,
+): SafeParseResult<VolumePriceProperties, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VolumePriceProperties$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VolumePriceProperties' from JSON`,
+  );
+}
+
+/** @internal */
+export const DynamicPriceProperties$inboundSchema: z.ZodType<
+  DynamicPriceProperties,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  maxPrice: z.string(),
+  minPrice: z.string(),
+});
+/** @internal */
+export type DynamicPriceProperties$Outbound = {
+  maxPrice: string;
+  minPrice: string;
+};
+
+/** @internal */
+export const DynamicPriceProperties$outboundSchema: z.ZodType<
+  DynamicPriceProperties$Outbound,
+  z.ZodTypeDef,
+  DynamicPriceProperties
+> = z.object({
+  maxPrice: z.string(),
+  minPrice: z.string(),
+});
+
+export function dynamicPricePropertiesToJSON(
+  dynamicPriceProperties: DynamicPriceProperties,
+): string {
+  return JSON.stringify(
+    DynamicPriceProperties$outboundSchema.parse(dynamicPriceProperties),
+  );
+}
+export function dynamicPricePropertiesFromJSON(
+  jsonString: string,
+): SafeParseResult<DynamicPriceProperties, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DynamicPriceProperties$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DynamicPriceProperties' from JSON`,
+  );
+}
+
+/** @internal */
+export const StandardPriceProperties$inboundSchema: z.ZodType<
+  StandardPriceProperties,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  unitPrice: z.string(),
+});
+/** @internal */
+export type StandardPriceProperties$Outbound = {
+  unitPrice: string;
+};
+
+/** @internal */
+export const StandardPriceProperties$outboundSchema: z.ZodType<
+  StandardPriceProperties$Outbound,
+  z.ZodTypeDef,
+  StandardPriceProperties
+> = z.object({
+  unitPrice: z.string(),
+});
+
+export function standardPricePropertiesToJSON(
+  standardPriceProperties: StandardPriceProperties,
+): string {
+  return JSON.stringify(
+    StandardPriceProperties$outboundSchema.parse(standardPriceProperties),
+  );
+}
+export function standardPricePropertiesFromJSON(
+  jsonString: string,
+): SafeParseResult<StandardPriceProperties, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StandardPriceProperties$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StandardPriceProperties' from JSON`,
+  );
+}
+
+/** @internal */
+export const PriceProperties$inboundSchema: z.ZodType<
+  PriceProperties,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => PercentagePriceProperties$inboundSchema),
+  z.lazy(() => DynamicPriceProperties$inboundSchema),
+  z.lazy(() => StandardPriceProperties$inboundSchema),
+  z.lazy(() => VolumePriceProperties$inboundSchema),
+]);
+/** @internal */
+export type PriceProperties$Outbound =
+  | PercentagePriceProperties$Outbound
+  | DynamicPriceProperties$Outbound
+  | StandardPriceProperties$Outbound
+  | VolumePriceProperties$Outbound;
+
+/** @internal */
+export const PriceProperties$outboundSchema: z.ZodType<
+  PriceProperties$Outbound,
+  z.ZodTypeDef,
+  PriceProperties
+> = z.union([
+  z.lazy(() => PercentagePriceProperties$outboundSchema),
+  z.lazy(() => DynamicPriceProperties$outboundSchema),
+  z.lazy(() => StandardPriceProperties$outboundSchema),
+  z.lazy(() => VolumePriceProperties$outboundSchema),
+]);
+
+export function pricePropertiesToJSON(
+  priceProperties: PriceProperties,
+): string {
+  return JSON.stringify(PriceProperties$outboundSchema.parse(priceProperties));
+}
+export function pricePropertiesFromJSON(
+  jsonString: string,
+): SafeParseResult<PriceProperties, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PriceProperties$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PriceProperties' from JSON`,
+  );
+}

package/src/models/schemasprice.ts

@@ -10,9 +10,9 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { PriceFeature, PriceFeature$inboundSchema } from "./pricefeature.js";
 import { PriceModel, PriceModel$inboundSchema } from "./pricemodel.js";
 import {
-  PricePropertiesUnion,
-  PricePropertiesUnion$inboundSchema,
-} from "./pricepropertiesunion.js";
+  PriceProperties,
+  PriceProperties$inboundSchema,
+} from "./priceproperties.js";
 
 export const SchemasPriceObject = {
   Price: "price",
@@ -56,11 +56,11 @@ export type SchemasPrice = {
   createdAt: Date;
   invoiceDisplayName: string;
   /**
-   * Pricing model of a price as returned by the API. Includes legacy models ('dynamic', 'volume', 'percentage') retained for existing prices; only 'standard' can be created (see PriceModelInput).
+   * Pricing model of a price as returned by the API. Includes the legacy models ('dynamic', 'percentage') retained for existing prices; 'standard' and 'volume' can be created (see PriceModelInput).
    */
   model?: PriceModel | undefined;
   paymentTerm: SchemasPricePaymentTerm;
-  properties: PricePropertiesUnion;
+  properties: PriceProperties;
   updatedAt: Date;
   /**
    * Features associated with this price
@@ -70,6 +70,10 @@ export type SchemasPrice = {
    * When true, grants applied to a subscription will discount usage charged by this price. Only supported for standard metered prices.
    */
   grantDiscountEnabled: boolean;
+  /**
+   * A fixed amount owed whole rather than a per-period rate. An obligation is not prorated over a partial first period: when a subscription starts before its billing anchor, no truncated stub is billed and the first charge is the full amount at the next anchor. An obligation also refuses an interval boundary that falls strictly inside one of its own billing periods, since part of an amount owed whole is not a thing to bill. Defaults to false, which is a rate and is today's behaviour for every price. Not supported on a metered price, whose amount resolves from usage at close.
+   */
+  isObligation: boolean;
   /**
    * Quantity for invoice line items. Total per period = quantity × unitPrice. Only supported for fee prices; metered prices derive quantity from usage. Defaults to 1.
    */
@@ -103,10 +107,11 @@ export const SchemasPrice$inboundSchema: z.ZodType<
   invoiceDisplayName: z.string(),
   model: PriceModel$inboundSchema.optional(),
   paymentTerm: SchemasPricePaymentTerm$inboundSchema,
-  properties: PricePropertiesUnion$inboundSchema,
+  properties: PriceProperties$inboundSchema,
   updatedAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),
   features: z.array(PriceFeature$inboundSchema).optional(),
   grantDiscountEnabled: z.boolean().default(false),
+  isObligation: z.boolean().default(false),
   quantity: z.number().int(),
 });
 

package/src/models/subscriptionadjustment.ts

@@ -0,0 +1,94 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+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 { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export const SubscriptionAdjustmentObject = {
+  SubscriptionAdjustment: "subscriptionAdjustment",
+} as const;
+export type SubscriptionAdjustmentObject = ClosedEnum<
+  typeof SubscriptionAdjustmentObject
+>;
+
+export const SubscriptionAdjustmentType = {
+  PercentageDiscount: "percentageDiscount",
+} as const;
+export type SubscriptionAdjustmentType = ClosedEnum<
+  typeof SubscriptionAdjustmentType
+>;
+
+export type SubscriptionAdjustment = {
+  object: SubscriptionAdjustmentObject;
+  /**
+   * The adjustment ID
+   */
+  id: string;
+  /**
+   * Unique identifier for a subscription
+   */
+  subscriptionId: string;
+  type: SubscriptionAdjustmentType;
+  /**
+   * The discount rate as a decimal fraction between 0 and 1. "0.35" means 35 percent.
+   */
+  percentageDiscount: string;
+  /**
+   * The first instant the discount applies. Inclusive.
+   */
+  effectiveFrom: Date;
+  /**
+   * The instant the discount stops applying. Exclusive. Null means the discount never stops.
+   */
+  effectiveTo: Date | null;
+  /**
+   * The deal's own name, shown on each discount line of the invoice.
+   */
+  description: string | null;
+  createdAt: Date;
+};
+
+/** @internal */
+export const SubscriptionAdjustmentObject$inboundSchema: z.ZodNativeEnum<
+  typeof SubscriptionAdjustmentObject
+> = z.nativeEnum(SubscriptionAdjustmentObject);
+
+/** @internal */
+export const SubscriptionAdjustmentType$inboundSchema: z.ZodNativeEnum<
+  typeof SubscriptionAdjustmentType
+> = z.nativeEnum(SubscriptionAdjustmentType);
+
+/** @internal */
+export const SubscriptionAdjustment$inboundSchema: z.ZodType<
+  SubscriptionAdjustment,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  object: SubscriptionAdjustmentObject$inboundSchema,
+  id: z.string(),
+  subscriptionId: z.string(),
+  type: SubscriptionAdjustmentType$inboundSchema,
+  percentageDiscount: z.string(),
+  effectiveFrom: z.string().datetime({ offset: true }).transform(v =>
+    new Date(v)
+  ),
+  effectiveTo: z.nullable(
+    z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  ),
+  description: z.nullable(z.string()),
+  createdAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+});
+
+export function subscriptionAdjustmentFromJSON(
+  jsonString: string,
+): SafeParseResult<SubscriptionAdjustment, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SubscriptionAdjustment$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SubscriptionAdjustment' from JSON`,
+  );
+}

package/src/models/subscriptionadjustmentsresponse.ts

@@ -0,0 +1,44 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import {
+  OffsetPagination,
+  OffsetPagination$inboundSchema,
+} from "./offsetpagination.js";
+import {
+  SubscriptionAdjustment,
+  SubscriptionAdjustment$inboundSchema,
+} from "./subscriptionadjustment.js";
+
+export type SubscriptionAdjustmentsResponse = {
+  data: Array<SubscriptionAdjustment>;
+  /**
+   * Offset-based pagination response.
+   */
+  pagination: OffsetPagination;
+};
+
+/** @internal */
+export const SubscriptionAdjustmentsResponse$inboundSchema: z.ZodType<
+  SubscriptionAdjustmentsResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.array(SubscriptionAdjustment$inboundSchema),
+  pagination: OffsetPagination$inboundSchema,
+});
+
+export function subscriptionAdjustmentsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<SubscriptionAdjustmentsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SubscriptionAdjustmentsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SubscriptionAdjustmentsResponse' from JSON`,
+  );
+}

package/src/sdk/subscriptions.ts

@@ -3,9 +3,12 @@
  */
 
 import { subscriptionsCreate } from "../funcs/subscriptionsCreate.js";
+import { subscriptionsCreateSubscriptionAdjustment } from "../funcs/subscriptionsCreateSubscriptionAdjustment.js";
+import { subscriptionsDeleteSubscriptionAdjustment } from "../funcs/subscriptionsDeleteSubscriptionAdjustment.js";
 import { subscriptionsGeneratePortalLink } from "../funcs/subscriptionsGeneratePortalLink.js";
 import { subscriptionsGet } from "../funcs/subscriptionsGet.js";
 import { subscriptionsList } from "../funcs/subscriptionsList.js";
+import { subscriptionsListSubscriptionAdjustments } from "../funcs/subscriptionsListSubscriptionAdjustments.js";
 import { subscriptionsReconcileSubscriptionFeatures } from "../funcs/subscriptionsReconcileSubscriptionFeatures.js";
 import { subscriptionsTerminate } from "../funcs/subscriptionsTerminate.js";
 import { subscriptionsUpdateSubscription } from "../funcs/subscriptionsUpdateSubscription.js";
@@ -124,4 +127,55 @@ export class Subscriptions extends ClientSDK {
       options,
     ));
   }
+
+  /**
+   * List Adjustments
+   *
+   * @remarks
+   * Reads the adjustments on the subscription, oldest window first. A subscription with no adjustment returns an empty array. Paginated, because a long-running subscription accumulates one adjustment per rate change of every deal it has carried.
+   */
+  async listSubscriptionAdjustments(
+    request: operations.ListSubscriptionAdjustmentsRequest,
+    options?: RequestOptions,
+  ): Promise<models.SubscriptionAdjustmentsResponse> {
+    return unwrapAsync(subscriptionsListSubscriptionAdjustments(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Create Adjustment
+   *
+   * @remarks
+   * Attaches a percentage discount to the subscription for a dated window. Every invoice calculated while the window is open carries one discount line for each discounted charge, and tax is assessed on the reduced amount. An invoice that already exists is not changed, including one still in draft — the discount reaches the periods that close after it is created. There is no update operation, and a window cannot be changed after it is created. To change a rate before any invoice has issued under the discount, delete the adjustment and create a replacement. Once an invoice has issued the adjustment is permanent, so set effectiveTo at creation time whenever the deal has a known end date.
+   */
+  async createSubscriptionAdjustment(
+    request: operations.CreateSubscriptionAdjustmentRequest,
+    options?: RequestOptions,
+  ): Promise<models.SubscriptionAdjustment> {
+    return unwrapAsync(subscriptionsCreateSubscriptionAdjustment(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete Adjustment
+   *
+   * @remarks
+   * Deletes an adjustment that has not yet reached an issued invoice. No invoice changes: an invoice still in draft keeps its numbers, and loses the discount only when its period is calculated again. An adjustment that has already discounted an issued invoice cannot be deleted, because the invoice records why the customer was charged that amount. Its window cannot be shortened afterwards either, so set effectiveTo at creation time whenever the deal has a known end date.
+   */
+  async deleteSubscriptionAdjustment(
+    request: operations.DeleteSubscriptionAdjustmentRequest,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(subscriptionsDeleteSubscriptionAdjustment(
+      this,
+      request,
+      options,
+    ));
+  }
 }