@paygentic/sdk 0.9.14 → 0.9.16

package/src/models/operations/resetmerchant.ts

@@ -0,0 +1,40 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as models from "../index.js";
+
+export type ResetMerchantRequest = {
+  merchantId: string;
+  merchantReset: models.MerchantReset;
+};
+
+/** @internal */
+export type ResetMerchantRequest$Outbound = {
+  merchantId: string;
+  MerchantReset: models.MerchantReset$Outbound;
+};
+
+/** @internal */
+export const ResetMerchantRequest$outboundSchema: z.ZodType<
+  ResetMerchantRequest$Outbound,
+  z.ZodTypeDef,
+  ResetMerchantRequest
+> = z.object({
+  merchantId: z.string(),
+  merchantReset: models.MerchantReset$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    merchantReset: "MerchantReset",
+  });
+});
+
+export function resetMerchantRequestToJSON(
+  resetMerchantRequest: ResetMerchantRequest,
+): string {
+  return JSON.stringify(
+    ResetMerchantRequest$outboundSchema.parse(resetMerchantRequest),
+  );
+}

package/src/models/operations/retryinvoicepayment.ts

@@ -0,0 +1,74 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+
+export type RetryInvoicePaymentRequestBody = {
+  /**
+   * Optional reason for the manual retry (for audit logging)
+   */
+  reason?: string | undefined;
+};
+
+export type RetryInvoicePaymentRequest = {
+  /**
+   * The invoice ID
+   */
+  id: string;
+  requestBody?: RetryInvoicePaymentRequestBody | undefined;
+};
+
+/** @internal */
+export type RetryInvoicePaymentRequestBody$Outbound = {
+  reason?: string | undefined;
+};
+
+/** @internal */
+export const RetryInvoicePaymentRequestBody$outboundSchema: z.ZodType<
+  RetryInvoicePaymentRequestBody$Outbound,
+  z.ZodTypeDef,
+  RetryInvoicePaymentRequestBody
+> = z.object({
+  reason: z.string().optional(),
+});
+
+export function retryInvoicePaymentRequestBodyToJSON(
+  retryInvoicePaymentRequestBody: RetryInvoicePaymentRequestBody,
+): string {
+  return JSON.stringify(
+    RetryInvoicePaymentRequestBody$outboundSchema.parse(
+      retryInvoicePaymentRequestBody,
+    ),
+  );
+}
+
+/** @internal */
+export type RetryInvoicePaymentRequest$Outbound = {
+  id: string;
+  RequestBody?: RetryInvoicePaymentRequestBody$Outbound | undefined;
+};
+
+/** @internal */
+export const RetryInvoicePaymentRequest$outboundSchema: z.ZodType<
+  RetryInvoicePaymentRequest$Outbound,
+  z.ZodTypeDef,
+  RetryInvoicePaymentRequest
+> = z.object({
+  id: z.string(),
+  requestBody: z.lazy(() => RetryInvoicePaymentRequestBody$outboundSchema)
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    requestBody: "RequestBody",
+  });
+});
+
+export function retryInvoicePaymentRequestToJSON(
+  retryInvoicePaymentRequest: RetryInvoicePaymentRequest,
+): string {
+  return JSON.stringify(
+    RetryInvoicePaymentRequest$outboundSchema.parse(retryInvoicePaymentRequest),
+  );
+}

package/src/models/operations/terminatesubscription.ts

@@ -4,12 +4,17 @@
 
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
+import * as models from "../index.js";
 
 export type TerminateSubscriptionRequestBody = {
   /**
    * Cancellation explanation text. Sample values: 'Customer requested cancellation', 'Payment failure', 'Service migration', 'Contract expiration'
    */
   reason: string;
+  /**
+   * Why a change was made. `correction` fixes data to match what was agreed; `migration` moves a contract from another system; `commercial` is a real change to the deal. Defaults to `unspecified`.
+   */
+  changeReason?: models.ChangeReason | undefined;
 };
 
 export type TerminateSubscriptionRequest = {
@@ -23,6 +28,7 @@ export type TerminateSubscriptionRequest = {
 /** @internal */
 export type TerminateSubscriptionRequestBody$Outbound = {
   reason: string;
+  changeReason?: string | undefined;
 };
 
 /** @internal */
@@ -32,6 +38,7 @@ export const TerminateSubscriptionRequestBody$outboundSchema: z.ZodType<
   TerminateSubscriptionRequestBody
 > = z.object({
   reason: z.string(),
+  changeReason: models.ChangeReason$outboundSchema.optional(),
 });
 
 export function terminateSubscriptionRequestBodyToJSON(

package/src/models/operations/updateplan.ts

@@ -107,6 +107,10 @@ export type UpdatePlanRequestBody = {
    * Governs price identity when a price is replaced by minting a new plan version and making it default. When true (default), replacing a price at make-default keeps the original price id live (its value changes) and the superseded value is preserved under a new id. When false, the replacement price's id goes live instead and the superseded value stays under the original id. Has no effect on this request's own prices field: prices carried over keep their ids, but swapping one price for another there moves the plan to the new price's id rather than keeping the original live.
    */
   stablePriceIds?: boolean | undefined;
+  /**
+   * When a move to a new plan version takes effect for this plan's subscriptions. `end_of_current_period` (the default) moves everything at the end of the current billing period. `immediate` changes entitlements at the move, in-arrears prices for the whole current period, and in-advance prices from the next period. Neither prorates.
+   */
+  versionTransition?: models.VersionTransition | undefined;
 };
 
 export type UpdatePlanRequest = {
@@ -148,6 +152,7 @@ export type UpdatePlanRequestBody$Outbound = {
   billingAnchor?: string | null | undefined;
   creditAllocations?: Array<models.PlanCreditAllocation$Outbound> | undefined;
   stablePriceIds?: boolean | undefined;
+  versionTransition?: models.VersionTransition$Outbound | undefined;
 };
 
 /** @internal */
@@ -172,6 +177,7 @@ export const UpdatePlanRequestBody$outboundSchema: z.ZodType<
   creditAllocations: z.array(models.PlanCreditAllocation$outboundSchema)
     .optional(),
   stablePriceIds: z.boolean().optional(),
+  versionTransition: models.VersionTransition$outboundSchema.optional(),
 });
 
 export function updatePlanRequestBodyToJSON(

package/src/models/operations/updatewebhooks.ts

@@ -0,0 +1,71 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+
+export type UpdateWebhooksRequestBody = {
+  /**
+   * Whether webhooks are enabled
+   */
+  enabled: boolean;
+};
+
+export type UpdateWebhooksRequest = {
+  /**
+   * The merchant organization ID. If omitted, defaults to the merchant associated with the authenticated API key.
+   */
+  merchantId?: string | undefined;
+  requestBody: UpdateWebhooksRequestBody;
+};
+
+/** @internal */
+export type UpdateWebhooksRequestBody$Outbound = {
+  enabled: boolean;
+};
+
+/** @internal */
+export const UpdateWebhooksRequestBody$outboundSchema: z.ZodType<
+  UpdateWebhooksRequestBody$Outbound,
+  z.ZodTypeDef,
+  UpdateWebhooksRequestBody
+> = z.object({
+  enabled: z.boolean(),
+});
+
+export function updateWebhooksRequestBodyToJSON(
+  updateWebhooksRequestBody: UpdateWebhooksRequestBody,
+): string {
+  return JSON.stringify(
+    UpdateWebhooksRequestBody$outboundSchema.parse(updateWebhooksRequestBody),
+  );
+}
+
+/** @internal */
+export type UpdateWebhooksRequest$Outbound = {
+  merchantId?: string | undefined;
+  RequestBody: UpdateWebhooksRequestBody$Outbound;
+};
+
+/** @internal */
+export const UpdateWebhooksRequest$outboundSchema: z.ZodType<
+  UpdateWebhooksRequest$Outbound,
+  z.ZodTypeDef,
+  UpdateWebhooksRequest
+> = z.object({
+  merchantId: z.string().optional(),
+  requestBody: z.lazy(() => UpdateWebhooksRequestBody$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    requestBody: "RequestBody",
+  });
+});
+
+export function updateWebhooksRequestToJSON(
+  updateWebhooksRequest: UpdateWebhooksRequest,
+): string {
+  return JSON.stringify(
+    UpdateWebhooksRequest$outboundSchema.parse(updateWebhooksRequest),
+  );
+}

package/src/models/outofbandpaymentresult.ts

@@ -0,0 +1,37 @@
+/*
+ * 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 { Invoice, Invoice$inboundSchema } from "./invoice.js";
+
+export type OutOfBandPaymentResult = {
+  /**
+   * Discriminator: an out-of-band payment was recorded.
+   */
+  method: "out_of_band";
+  invoice: Invoice;
+};
+
+/** @internal */
+export const OutOfBandPaymentResult$inboundSchema: z.ZodType<
+  OutOfBandPaymentResult,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  method: z.literal("out_of_band"),
+  invoice: Invoice$inboundSchema,
+});
+
+export function outOfBandPaymentResultFromJSON(
+  jsonString: string,
+): SafeParseResult<OutOfBandPaymentResult, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OutOfBandPaymentResult$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OutOfBandPaymentResult' from JSON`,
+  );
+}

package/src/models/plan.ts

@@ -13,6 +13,10 @@ import {
   PlanCreditAllocation$inboundSchema,
 } from "./plancreditallocation.js";
 import { PlanPrice, PlanPrice$inboundSchema } from "./planprice.js";
+import {
+  VersionTransition,
+  VersionTransition$inboundSchema,
+} from "./versiontransition.js";
 
 export const PlanObject = {
   Plan: "plan",
@@ -126,6 +130,10 @@ export type Plan = {
    * Governs price identity when a price on this plan's default version is replaced. When true (default), replacing a price at make-default keeps the original price id live (its value changes) and the superseded value is preserved under a new id. When false, the replacement price's id goes live instead and the superseded value stays under the original id.
    */
   stablePriceIds: boolean;
+  /**
+   * When a move to a new plan version takes effect for this plan's subscriptions. `end_of_current_period` (the default) moves everything at the end of the current billing period. `immediate` changes entitlements at the move, in-arrears prices for the whole current period, and in-advance prices from the next period. Neither prorates.
+   */
+  versionTransition: VersionTransition;
 };
 
 /** @internal */
@@ -202,6 +210,7 @@ export const Plan$inboundSchema: z.ZodType<Plan, z.ZodTypeDef, unknown> = z
     creditAllocations: z.array(PlanCreditAllocation$inboundSchema).optional(),
     defaultVersionId: z.string().optional(),
     stablePriceIds: z.boolean().default(true),
+    versionTransition: VersionTransition$inboundSchema,
   });
 
 export function planFromJSON(

package/src/models/profitabilityrow.ts

@@ -4,24 +4,34 @@
 
 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";
-import {
-  ProfitabilityTrend,
-  ProfitabilityTrend$inboundSchema,
-} from "./profitabilitytrend.js";
+
+/**
+ * Whether metering recorded usage against a cost for every customer the row covers (`recorded`), some of them (`partial`, only on the 'Other' and 'deleted' rows) or none (`none`). Usage that prices at zero is recorded, so `recorded` with a zero `totalCost` is a measured zero. `none` means no cost data, not a zero cost.
+ */
+export const CostData = {
+  Recorded: "recorded",
+  Partial: "partial",
+  None: "none",
+} as const;
+/**
+ * Whether metering recorded usage against a cost for every customer the row covers (`recorded`), some of them (`partial`, only on the 'Other' and 'deleted' rows) or none (`none`). Usage that prices at zero is recorded, so `recorded` with a zero `totalCost` is a measured zero. `none` means no cost data, not a zero cost.
+ */
+export type CostData = ClosedEnum<typeof CostData>;
 
 export type ProfitabilityRow = {
   /**
-   * Customer ID, or the literal 'other' for the overflow row.
+   * Customer ID, the literal 'other' for the overflow row, or the literal 'deleted' for the row that folds every soft-deleted customer with revenue or cost in the period.
    */
   customerId: string;
   /**
-   * Display name for the row. 'Other' for the overflow row.
+   * Display name for the row. 'Other' for the overflow row, 'Deleted customers' for the deleted row.
    */
   customerName: string;
   /**
-   * Revenue excluding tax (paid + outstanding invoices issued in the period), in unit currency, with two decimals.
+   * Revenue excluding tax, in units of the currency, with two decimals: what was billed in the period, recognised when each invoice is issued. Every invoice issued in the period counts, whether it was since paid, is still outstanding, failed payment or was written off, less non-voided refunds issued in the period. It is billings, not cash collected, and the same figure /v0/revenue reports.
    */
   netRevenue: string;
   /**
@@ -33,15 +43,19 @@ export type ProfitabilityRow = {
    */
   profit: string;
   /**
-   * Margin percent (profit / revenue × 100), with two decimals. Null when revenue is zero.
+   * Margin percent (profit / revenue × 100), with two decimals. Null when revenue is zero or negative, and when `costData` is not `recorded`: a cost nobody recorded reads as zero, and a margin over it would claim the row costs nothing.
    */
   marginPct: string | null;
   /**
-   * Per-customer revenue trend over the period. Null for the 'Other' row and when there's insufficient data.
+   * Whether metering recorded usage against a cost for every customer the row covers (`recorded`), some of them (`partial`, only on the 'Other' and 'deleted' rows) or none (`none`). Usage that prices at zero is recorded, so `recorded` with a zero `totalCost` is a measured zero. `none` means no cost data, not a zero cost.
    */
-  trend: ProfitabilityTrend | null;
+  costData?: CostData | undefined;
 };
 
+/** @internal */
+export const CostData$inboundSchema: z.ZodNativeEnum<typeof CostData> = z
+  .nativeEnum(CostData);
+
 /** @internal */
 export const ProfitabilityRow$inboundSchema: z.ZodType<
   ProfitabilityRow,
@@ -54,7 +68,7 @@ export const ProfitabilityRow$inboundSchema: z.ZodType<
   totalCost: z.string(),
   profit: z.string(),
   marginPct: z.nullable(z.string()),
-  trend: z.nullable(ProfitabilityTrend$inboundSchema),
+  costData: CostData$inboundSchema.optional(),
 });
 
 export function profitabilityRowFromJSON(

package/src/models/profitabilitysummaryresponse.ts

@@ -49,9 +49,25 @@ export type ProfitabilitySummaryResponse = {
    */
   currency: string;
   /**
-   * Top-N customer rows by profit descending, optionally followed by a single 'Other' row when more than topN customers contributed.
+   * Top-N customer rows by profit descending, optionally followed by a single 'Other' row when more than topN customers contributed. Soft-deleted customers appear only through the 'deleted' row, which comes last, never by name. With `excludeEmpty=true`, customers with neither revenue nor cost in the period are left out.
    */
   rows: Array<ProfitabilityRow>;
+  /**
+   * The merchant's customers this summary scored, whether or not they made a row.
+   */
+  customerCount?: number | undefined;
+  /**
+   * Customers with neither revenue nor cost in the period, counted whether or not `excludeEmpty` left them out of `rows`. Null when a cost read failed: their cost was never established, so none is counted and `excludeEmpty` leaves nobody out.
+   */
+  emptyCustomerCount?: number | null | undefined;
+  /**
+   * Customers `rows` does not carry because a cost read failed (see `warnings`) and they had no revenue in the period. Null when every cost read settled.
+   */
+  unloadedCustomerCount?: number | null | undefined;
+  /**
+   * The customers `emptyCustomerCount` counts that `rows` does not carry, either as a row or folded into the 'Other' row, sorted by name, each reading zero with a null margin. Present only when `includeEmpty=true` and the count is answered. They are never ranked, never part of the top-N and never folded into the 'Other' row.
+   */
+  emptyCustomers?: Array<ProfitabilityRow> | undefined;
   /**
    * Non-fatal warnings collected during cost discovery (e.g. an individual cost query failed). Empty array on a clean run.
    */
@@ -122,6 +138,10 @@ export const ProfitabilitySummaryResponse$inboundSchema: z.ZodType<
   object: z.literal("profitability_summary"),
   currency: z.string(),
   rows: z.array(ProfitabilityRow$inboundSchema),
+  customerCount: z.number().int().optional(),
+  emptyCustomerCount: z.nullable(z.number().int()).optional(),
+  unloadedCustomerCount: z.nullable(z.number().int()).optional(),
+  emptyCustomers: z.array(ProfitabilityRow$inboundSchema).optional(),
   warnings: z.array(z.string()).optional(),
   revenueRange: z.nullable(
     z.lazy(() => ProfitabilitySummaryResponseRevenueRange$inboundSchema),

package/src/models/retrypaymenterror.ts

@@ -0,0 +1,52 @@
+/*
+ * 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";
+
+/**
+ * Why a payment retry did not collect the money.
+ */
+export type RetryPaymentError = {
+  /**
+   * Human-readable message. Do not parse it; use `code`.
+   */
+  message: string;
+  /**
+   * Error category, for example `card_error` or `processing`.
+   */
+  type?: string | undefined;
+  /**
+   * Machine-readable reason. See the operation description for the values.
+   */
+  code?: string | undefined;
+  /**
+   * The card decline code from the provider, when one is available.
+   */
+  declineCode?: string | undefined;
+};
+
+/** @internal */
+export const RetryPaymentError$inboundSchema: z.ZodType<
+  RetryPaymentError,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  message: z.string(),
+  type: z.string().optional(),
+  code: z.string().optional(),
+  declineCode: z.string().optional(),
+});
+
+export function retryPaymentErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<RetryPaymentError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RetryPaymentError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RetryPaymentError' from JSON`,
+  );
+}

package/src/models/retrypaymentresponse.ts

@@ -0,0 +1,80 @@
+/*
+ * 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";
+import {
+  RetryPaymentError,
+  RetryPaymentError$inboundSchema,
+} from "./retrypaymenterror.js";
+
+/**
+ * The object type
+ */
+export const RetryPaymentResponseObject = {
+  RetryPaymentResult: "retry_payment_result",
+} as const;
+/**
+ * The object type
+ */
+export type RetryPaymentResponseObject = ClosedEnum<
+  typeof RetryPaymentResponseObject
+>;
+
+/**
+ * The result of a payment retry. Every response status of the retry operation that is not an error envelope uses this shape.
+ */
+export type RetryPaymentResponse = {
+  /**
+   * The object type
+   */
+  object: RetryPaymentResponseObject;
+  /**
+   * True only when the charge succeeded or no amount is unpaid. The response status is 200 only when this is true.
+   */
+  success: boolean;
+  /**
+   * The invoice ID
+   */
+  invoiceId: string;
+  /**
+   * The provider's payment reference for the charge, when the provider has one.
+   */
+  paymentIntentId?: string | undefined;
+  /**
+   * Why a payment retry did not collect the money.
+   */
+  error?: RetryPaymentError | undefined;
+};
+
+/** @internal */
+export const RetryPaymentResponseObject$inboundSchema: z.ZodNativeEnum<
+  typeof RetryPaymentResponseObject
+> = z.nativeEnum(RetryPaymentResponseObject);
+
+/** @internal */
+export const RetryPaymentResponse$inboundSchema: z.ZodType<
+  RetryPaymentResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  object: RetryPaymentResponseObject$inboundSchema,
+  success: z.boolean(),
+  invoiceId: z.string(),
+  paymentIntentId: z.string().optional(),
+  error: RetryPaymentError$inboundSchema.optional(),
+});
+
+export function retryPaymentResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<RetryPaymentResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RetryPaymentResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RetryPaymentResponse' from JSON`,
+  );
+}

package/src/models/revenuesummaryresponse.ts

@@ -47,7 +47,7 @@ export type RevenueSummaryResponse = {
    */
   object: "revenue_summary";
   /**
-   * Revenue in dollars, excluding tax: invoices issued in the period plus completed payments, less non-voided refunds issued in the period. Invoices and refunds are counted excluding tax. Omitted when groupBy=currency is active.
+   * Revenue: what was billed in the period, excluding tax, in units of the currency. On the default issue-date basis it is recognised when each invoice is issued; with periodBasis=billingPeriod, each invoice line counts in the period it bills, and a refund splits across its invoice's lines. An invoice counts whether it was since paid, is still outstanding, failed payment or was written off, less non-voided refunds. It is billings, not cash collected: what customers still owe is invoices.outstanding, including tax, and payment-link collections are under payments. Omitted when groupBy=currency is active.
    */
   netRevenue?: string | undefined;
   /**

package/src/models/revenuetrendbucket.ts

@@ -17,7 +17,11 @@ export type RevenueTrendBucket = {
    */
   timestamp: Date;
   /**
-   * Total amount of all invoices issued in this bucket (all statuses, by issuedAt), excluding tax
+   * Revenue for this bucket, computed exactly as netRevenue: invoices issued in the bucket (on periodBasis=billingPeriod, lines billing it), excluding tax, less refunds issued in it, excluding tax. The buckets sum to netRevenue.
+   */
+  revenue: string;
+  /**
+   * Total amount of all invoices issued in this bucket (all statuses, by issuedAt), excluding tax, before refunds. Revenue is the revenue field.
    */
   issuedInvoices: string;
   /**
@@ -25,7 +29,7 @@ export type RevenueTrendBucket = {
    */
   writtenOffInvoices: string;
   /**
-   * Revenue from completed payments in dollars for this bucket
+   * Completed payment-link payments in dollars for this bucket, reported beside revenue, not in it
    */
   completedPayments: string;
   /**
@@ -45,6 +49,7 @@ export const RevenueTrendBucket$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   timestamp: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  revenue: z.string(),
   issuedInvoices: z.string(),
   writtenOffInvoices: z.string(),
   completedPayments: z.string(),