@flexprice/sdk 2.1.25 → 2.1.30

package/src/sdk/invoices.ts

@@ -4,6 +4,7 @@
 
 import { invoicesAttemptInvoicePayment } from "../funcs/invoices-attempt-invoice-payment.js";
 import { invoicesCreateInvoice } from "../funcs/invoices-create-invoice.js";
+import { invoicesExecuteInvoiceModify } from "../funcs/invoices-execute-invoice-modify.js";
 import { invoicesFinalizeInvoice } from "../funcs/invoices-finalize-invoice.js";
 import { invoicesGetCustomerInvoiceSummary } from "../funcs/invoices-get-customer-invoice-summary.js";
 import { invoicesGetInvoicePdf } from "../funcs/invoices-get-invoice-pdf.js";
@@ -165,6 +166,25 @@ export class Invoices extends ClientSDK {
     ));
   }
 
+  /**
+   * Execute invoice modification
+   *
+   * @remarks
+   * Execute a modification on a draft or finalized invoice. Supports line item changes: add (bulk), update (one line item per call; the edit is versioned, so the line item id changes), and remove (bulk, soft delete). Totals are recalculated from the remaining line items; a manual edit marks the invoice as manually edited, which disables recompute. Modifying a FINALIZED invoice voids it and recreates it as a draft copy carrying all current data (description, billing period, due date, metadata, line items); the modification lands on the copy and the response returns the new draft — chain subsequent calls to the returned invoice id; a call that still targets the voided original is rejected with an error naming the replacement.
+   */
+  async executeInvoiceModify(
+    id: string,
+    body: models.ExecuteInvoiceModifyRequest,
+    options?: RequestOptions,
+  ): Promise<models.InvoiceModifyResponse> {
+    return unwrapAsync(invoicesExecuteInvoiceModify(
+      this,
+      id,
+      body,
+      options,
+    ));
+  }
+
   /**
    * Update invoice payment status
    *

package/src/sdk/models/add-addon-params.ts

@@ -4,37 +4,17 @@
 
 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 * as types from "../../types/primitives.js";
 import {
   AddAddonRef,
-  AddAddonRef$inboundSchema,
   AddAddonRef$Outbound,
   AddAddonRef$outboundSchema,
 } from "./add-addon-ref.js";
-import { SDKValidationError } from "./sdk-validation-error.js";
 
 export type AddAddonParams = {
   addons?: Array<AddAddonRef> | undefined;
   subscriptionId?: string | undefined;
 };
 
-/** @internal */
-export const AddAddonParams$inboundSchema: z.ZodMiniType<
-  AddAddonParams,
-  unknown
-> = z.pipe(
-  z.object({
-    addons: types.optional(z.array(AddAddonRef$inboundSchema)),
-    subscription_id: types.optional(types.string()),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "subscription_id": "subscriptionId",
-    });
-  }),
-);
 /** @internal */
 export type AddAddonParams$Outbound = {
   addons?: Array<AddAddonRef$Outbound> | undefined;
@@ -60,12 +40,3 @@ export const AddAddonParams$outboundSchema: z.ZodMiniType<
 export function addAddonParamsToJSON(addAddonParams: AddAddonParams): string {
   return JSON.stringify(AddAddonParams$outboundSchema.parse(addAddonParams));
 }
-export function addAddonParamsFromJSON(
-  jsonString: string,
-): SafeParseResult<AddAddonParams, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => AddAddonParams$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AddAddonParams' from JSON`,
-  );
-}

package/src/sdk/models/add-addon-ref.ts

@@ -4,20 +4,11 @@
 
 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 * as types from "../../types/primitives.js";
-import {
-  AddonCadence,
-  AddonCadence$inboundSchema,
-  AddonCadence$outboundSchema,
-} from "./addon-cadence.js";
+import { AddonCadence, AddonCadence$outboundSchema } from "./addon-cadence.js";
 import {
   ProrationBehavior,
-  ProrationBehavior$inboundSchema,
   ProrationBehavior$outboundSchema,
 } from "./proration-behavior.js";
-import { SDKValidationError } from "./sdk-validation-error.js";
 
 export type AddAddonRef = {
   addonId?: string | undefined;
@@ -27,25 +18,6 @@ export type AddAddonRef = {
   startDate?: Date | undefined;
 };
 
-/** @internal */
-export const AddAddonRef$inboundSchema: z.ZodMiniType<AddAddonRef, unknown> = z
-  .pipe(
-    z.object({
-      addon_id: types.optional(types.string()),
-      association_id: types.optional(types.string()),
-      cadence: types.optional(AddonCadence$inboundSchema),
-      proration_behavior: types.optional(ProrationBehavior$inboundSchema),
-      start_date: types.optional(types.date()),
-    }),
-    z.transform((v) => {
-      return remap$(v, {
-        "addon_id": "addonId",
-        "association_id": "associationId",
-        "proration_behavior": "prorationBehavior",
-        "start_date": "startDate",
-      });
-    }),
-  );
 /** @internal */
 export type AddAddonRef$Outbound = {
   addon_id?: string | undefined;
@@ -80,12 +52,3 @@ export const AddAddonRef$outboundSchema: z.ZodMiniType<
 export function addAddonRefToJSON(addAddonRef: AddAddonRef): string {
   return JSON.stringify(AddAddonRef$outboundSchema.parse(addAddonRef));
 }
-export function addAddonRefFromJSON(
-  jsonString: string,
-): SafeParseResult<AddAddonRef, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => AddAddonRef$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AddAddonRef' from JSON`,
-  );
-}

package/src/sdk/models/add-line-item-request.ts

@@ -0,0 +1,57 @@
+/*
+ * 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";
+
+export type AddLineItemRequest = {
+  amount: string;
+  description?: string | undefined;
+  displayName: string;
+  periodEnd?: Date | undefined;
+  periodStart?: Date | undefined;
+  quantity: string;
+};
+
+/** @internal */
+export type AddLineItemRequest$Outbound = {
+  amount: string;
+  description?: string | undefined;
+  display_name: string;
+  period_end?: string | undefined;
+  period_start?: string | undefined;
+  quantity: string;
+};
+
+/** @internal */
+export const AddLineItemRequest$outboundSchema: z.ZodMiniType<
+  AddLineItemRequest$Outbound,
+  AddLineItemRequest
+> = z.pipe(
+  z.object({
+    amount: z.string(),
+    description: z.optional(z.string()),
+    displayName: z.string(),
+    periodEnd: z.optional(z.pipe(z.date(), z.transform(v => v.toISOString()))),
+    periodStart: z.optional(
+      z.pipe(z.date(), z.transform(v => v.toISOString())),
+    ),
+    quantity: z.string(),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      displayName: "display_name",
+      periodEnd: "period_end",
+      periodStart: "period_start",
+    });
+  }),
+);
+
+export function addLineItemRequestToJSON(
+  addLineItemRequest: AddLineItemRequest,
+): string {
+  return JSON.stringify(
+    AddLineItemRequest$outboundSchema.parse(addLineItemRequest),
+  );
+}

package/src/sdk/models/addon-cadence.ts

@@ -3,18 +3,14 @@
  */
 
 import * as z from "zod/v4-mini";
-import * as openEnums from "../../types/enums.js";
-import { OpenEnum } from "../../types/enums.js";
+import { ClosedEnum } from "../../types/enums.js";
 
 export const AddonCadence = {
   Onetime: "onetime",
   Recurring: "recurring",
 } as const;
-export type AddonCadence = OpenEnum<typeof AddonCadence>;
+export type AddonCadence = ClosedEnum<typeof AddonCadence>;
 
 /** @internal */
-export const AddonCadence$inboundSchema: z.ZodMiniType<AddonCadence, unknown> =
-  openEnums.inboundSchema(AddonCadence);
-/** @internal */
-export const AddonCadence$outboundSchema: z.ZodMiniType<string, AddonCadence> =
-  openEnums.outboundSchema(AddonCadence);
+export const AddonCadence$outboundSchema: z.ZodMiniEnum<typeof AddonCadence> = z
+  .enum(AddonCadence);

package/src/sdk/models/alert-settings.ts

@@ -7,6 +7,11 @@ import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import * as types from "../../types/primitives.js";
+import {
+  AlertThresholdType,
+  AlertThresholdType$inboundSchema,
+  AlertThresholdType$outboundSchema,
+} from "./alert-threshold-type.js";
 import {
   AlertThreshold,
   AlertThreshold$inboundSchema,
@@ -17,6 +22,7 @@ import { SDKValidationError } from "./sdk-validation-error.js";
 
 export type AlertSettings = {
   alertEnabled?: boolean | undefined;
+  alertThresholdType?: AlertThresholdType | undefined;
   critical?: AlertThreshold | undefined;
   info?: AlertThreshold | undefined;
   warning?: AlertThreshold | undefined;
@@ -29,6 +35,7 @@ export const AlertSettings$inboundSchema: z.ZodMiniType<
 > = z.pipe(
   z.object({
     alert_enabled: types.optional(types.boolean()),
+    alert_threshold_type: types.optional(AlertThresholdType$inboundSchema),
     critical: types.optional(AlertThreshold$inboundSchema),
     info: types.optional(AlertThreshold$inboundSchema),
     warning: types.optional(AlertThreshold$inboundSchema),
@@ -36,12 +43,14 @@ export const AlertSettings$inboundSchema: z.ZodMiniType<
   z.transform((v) => {
     return remap$(v, {
       "alert_enabled": "alertEnabled",
+      "alert_threshold_type": "alertThresholdType",
     });
   }),
 );
 /** @internal */
 export type AlertSettings$Outbound = {
   alert_enabled?: boolean | undefined;
+  alert_threshold_type?: string | undefined;
   critical?: AlertThreshold$Outbound | undefined;
   info?: AlertThreshold$Outbound | undefined;
   warning?: AlertThreshold$Outbound | undefined;
@@ -54,6 +63,7 @@ export const AlertSettings$outboundSchema: z.ZodMiniType<
 > = z.pipe(
   z.object({
     alertEnabled: z.optional(z.boolean()),
+    alertThresholdType: z.optional(AlertThresholdType$outboundSchema),
     critical: z.optional(AlertThreshold$outboundSchema),
     info: z.optional(AlertThreshold$outboundSchema),
     warning: z.optional(AlertThreshold$outboundSchema),
@@ -61,6 +71,7 @@ export const AlertSettings$outboundSchema: z.ZodMiniType<
   z.transform((v) => {
     return remap$(v, {
       alertEnabled: "alert_enabled",
+      alertThresholdType: "alert_threshold_type",
     });
   }),
 );

package/src/sdk/models/alert-threshold-type.ts

@@ -0,0 +1,24 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
+
+export const AlertThresholdType = {
+  Absolute: "absolute",
+  Percentage: "percentage",
+} as const;
+export type AlertThresholdType = OpenEnum<typeof AlertThresholdType>;
+
+/** @internal */
+export const AlertThresholdType$inboundSchema: z.ZodMiniType<
+  AlertThresholdType,
+  unknown
+> = openEnums.inboundSchema(AlertThresholdType);
+/** @internal */
+export const AlertThresholdType$outboundSchema: z.ZodMiniType<
+  string,
+  AlertThresholdType
+> = openEnums.outboundSchema(AlertThresholdType);

package/src/sdk/models/billing-period-behaviour.ts

@@ -0,0 +1,25 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
+
+export const BillingPeriodBehaviour = {
+  Unchanged: "unchanged",
+  AnchorAtEffect: "anchor_at_effect",
+  AnchorAtConfig: "anchor_at_config",
+} as const;
+export type BillingPeriodBehaviour = OpenEnum<typeof BillingPeriodBehaviour>;
+
+/** @internal */
+export const BillingPeriodBehaviour$inboundSchema: z.ZodMiniType<
+  BillingPeriodBehaviour,
+  unknown
+> = openEnums.inboundSchema(BillingPeriodBehaviour);
+/** @internal */
+export const BillingPeriodBehaviour$outboundSchema: z.ZodMiniType<
+  string,
+  BillingPeriodBehaviour
+> = openEnums.outboundSchema(BillingPeriodBehaviour);

package/src/sdk/models/billing-period-config.ts

@@ -0,0 +1,57 @@
+/*
+ * 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 { BillingCycle, BillingCycle$outboundSchema } from "./billing-cycle.js";
+import {
+  BillingPeriod,
+  BillingPeriod$outboundSchema,
+} from "./billing-period.js";
+
+export type BillingPeriodConfig = {
+  billingAnchor?: Date | undefined;
+  billingCycle?: BillingCycle | undefined;
+  billingPeriodCount?: number | undefined;
+  billingPeriodUnit?: BillingPeriod | undefined;
+};
+
+/** @internal */
+export type BillingPeriodConfig$Outbound = {
+  billing_anchor?: string | undefined;
+  billing_cycle?: string | undefined;
+  billing_period_count?: number | undefined;
+  billing_period_unit?: string | undefined;
+};
+
+/** @internal */
+export const BillingPeriodConfig$outboundSchema: z.ZodMiniType<
+  BillingPeriodConfig$Outbound,
+  BillingPeriodConfig
+> = z.pipe(
+  z.object({
+    billingAnchor: z.optional(
+      z.pipe(z.date(), z.transform(v => v.toISOString())),
+    ),
+    billingCycle: z.optional(BillingCycle$outboundSchema),
+    billingPeriodCount: z.optional(z.int()),
+    billingPeriodUnit: z.optional(BillingPeriod$outboundSchema),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      billingAnchor: "billing_anchor",
+      billingCycle: "billing_cycle",
+      billingPeriodCount: "billing_period_count",
+      billingPeriodUnit: "billing_period_unit",
+    });
+  }),
+);
+
+export function billingPeriodConfigToJSON(
+  billingPeriodConfig: BillingPeriodConfig,
+): string {
+  return JSON.stringify(
+    BillingPeriodConfig$outboundSchema.parse(billingPeriodConfig),
+  );
+}

package/src/sdk/models/changed-invoice-status.ts

@@ -6,16 +6,10 @@ import * as z from "zod/v4-mini";
 import * as openEnums from "../../types/enums.js";
 import { OpenEnum } from "../../types/enums.js";
 
-/**
- * preview | issued | INITIATED | PENDING | PROCESSING | SUCCEEDED | OVERPAID | FAILED | REFUNDED | PARTIALLY_REFUNDED
- */
 export const ChangedInvoiceStatus = {
   Preview: "preview",
   Issued: "issued",
 } as const;
-/**
- * preview | issued | INITIATED | PENDING | PROCESSING | SUCCEEDED | OVERPAID | FAILED | REFUNDED | PARTIALLY_REFUNDED
- */
 export type ChangedInvoiceStatus = OpenEnum<typeof ChangedInvoiceStatus>;
 
 /** @internal */

package/src/sdk/models/changed-invoice.ts

@@ -32,9 +32,6 @@ export type ChangedInvoice = {
   action?: ChangedInvoiceAction | undefined;
   id?: string | undefined;
   invoice?: InvoiceResponse | undefined;
-  /**
-   * preview | issued | INITIATED | PENDING | PROCESSING | SUCCEEDED | OVERPAID | FAILED | REFUNDED | PARTIALLY_REFUNDED
-   */
   status?: ChangedInvoiceStatus | undefined;
   walletTransaction?: WalletTransactionResponse | undefined;
 };

package/src/sdk/models/checkout-payment-block.ts

@@ -0,0 +1,39 @@
+/*
+ * 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 * as types from "../../types/primitives.js";
+import {
+  PaymentStatus,
+  PaymentStatus$inboundSchema,
+} from "./payment-status.js";
+import { SDKValidationError } from "./sdk-validation-error.js";
+
+export type CheckoutPaymentBlock = {
+  gateway?: string | undefined;
+  id?: string | undefined;
+  status?: PaymentStatus | undefined;
+};
+
+/** @internal */
+export const CheckoutPaymentBlock$inboundSchema: z.ZodMiniType<
+  CheckoutPaymentBlock,
+  unknown
+> = z.object({
+  gateway: types.optional(types.string()),
+  id: types.optional(types.string()),
+  status: types.optional(PaymentStatus$inboundSchema),
+});
+
+export function checkoutPaymentBlockFromJSON(
+  jsonString: string,
+): SafeParseResult<CheckoutPaymentBlock, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CheckoutPaymentBlock$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CheckoutPaymentBlock' from JSON`,
+  );
+}

package/src/sdk/models/checkout-payment-provider-config.ts

@@ -15,6 +15,14 @@ import {
 
 export type CheckoutPaymentProviderConfig = {
   collectionMethod?: CollectionMethod | undefined;
+  /**
+   * CustomerNotPresent is the unattended/MIT opt-in. Zero value (omitted) means
+   *
+   * @remarks
+   * the customer is present, so a missed auto-charge may fall back to a hosted
+   * authorization link. Set true only from merchant-initiated paths (auto top-up).
+   */
+  customerNotPresent?: boolean | undefined;
   maxMandateLimit?: string | undefined;
   paymentMethod?: PaymentMethodType | undefined;
 };
@@ -22,6 +30,7 @@ export type CheckoutPaymentProviderConfig = {
 /** @internal */
 export type CheckoutPaymentProviderConfig$Outbound = {
   collection_method?: string | undefined;
+  customer_not_present?: boolean | undefined;
   max_mandate_limit?: string | undefined;
   payment_method?: string | undefined;
 };
@@ -33,12 +42,14 @@ export const CheckoutPaymentProviderConfig$outboundSchema: z.ZodMiniType<
 > = z.pipe(
   z.object({
     collectionMethod: z.optional(CollectionMethod$outboundSchema),
+    customerNotPresent: z.optional(z.boolean()),
     maxMandateLimit: z.optional(z.string()),
     paymentMethod: z.optional(PaymentMethodType$outboundSchema),
   }),
   z.transform((v) => {
     return remap$(v, {
       collectionMethod: "collection_method",
+      customerNotPresent: "customer_not_present",
       maxMandateLimit: "max_mandate_limit",
       paymentMethod: "payment_method",
     });

package/src/sdk/models/checkout-payment-provider.ts

@@ -3,20 +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 CheckoutPaymentProvider = {
   Razorpay: "razorpay",
+  Chargebee: "chargebee",
 } as const;
-export type CheckoutPaymentProvider = ClosedEnum<
-  typeof CheckoutPaymentProvider
->;
+export type CheckoutPaymentProvider = OpenEnum<typeof CheckoutPaymentProvider>;
 
 /** @internal */
-export const CheckoutPaymentProvider$inboundSchema: z.ZodMiniEnum<
-  typeof CheckoutPaymentProvider
-> = z.enum(CheckoutPaymentProvider);
+export const CheckoutPaymentProvider$inboundSchema: z.ZodMiniType<
+  CheckoutPaymentProvider,
+  unknown
+> = openEnums.inboundSchema(CheckoutPaymentProvider);
 /** @internal */
-export const CheckoutPaymentProvider$outboundSchema: z.ZodMiniEnum<
-  typeof CheckoutPaymentProvider
-> = CheckoutPaymentProvider$inboundSchema;
+export const CheckoutPaymentProvider$outboundSchema: z.ZodMiniType<
+  string,
+  CheckoutPaymentProvider
+> = openEnums.outboundSchema(CheckoutPaymentProvider);