@flexprice/sdk 2.1.25 → 2.1.26

package/src/sdk/models/subscription-change-v2-request.ts

@@ -4,11 +4,25 @@
 
 import * as z from "zod/v4-mini";
 import { remap as remap$ } from "../../lib/primitives.js";
+import {
+  BillingPeriodBehaviour,
+  BillingPeriodBehaviour$outboundSchema,
+} from "./billing-period-behaviour.js";
+import {
+  BillingPeriodConfig,
+  BillingPeriodConfig$Outbound,
+  BillingPeriodConfig$outboundSchema,
+} from "./billing-period-config.js";
 import {
   ProrationBehavior,
   ProrationBehavior$outboundSchema,
 } from "./proration-behavior.js";
 import { ScheduleType, ScheduleType$outboundSchema } from "./schedule-type.js";
+import {
+  SubscriptionChangeConflictPolicies,
+  SubscriptionChangeConflictPolicies$Outbound,
+  SubscriptionChangeConflictPolicies$outboundSchema,
+} from "./subscription-change-conflict-policies.js";
 import {
   SubscriptionChangeEntityPolicies,
   SubscriptionChangeEntityPolicies$Outbound,
@@ -16,20 +30,28 @@ import {
 } from "./subscription-change-entity-policies.js";
 
 export type SubscriptionChangeV2Request = {
+  billingPeriodBehaviour?: BillingPeriodBehaviour | undefined;
+  billingPeriodConfig?: BillingPeriodConfig | undefined;
   changeAt?: ScheduleType | undefined;
   entityPolicies?: SubscriptionChangeEntityPolicies | undefined;
   idempotencyKey?: string | undefined;
   metadata?: { [k: string]: string } | undefined;
+  onConflictPolicies?: SubscriptionChangeConflictPolicies | undefined;
   prorationBehavior: ProrationBehavior;
   targetPlanId: string;
 };
 
 /** @internal */
 export type SubscriptionChangeV2Request$Outbound = {
+  billing_period_behaviour?: string | undefined;
+  billing_period_config?: BillingPeriodConfig$Outbound | undefined;
   change_at?: string | undefined;
   entity_policies?: SubscriptionChangeEntityPolicies$Outbound | undefined;
   idempotency_key?: string | undefined;
   metadata?: { [k: string]: string } | undefined;
+  on_conflict_policies?:
+    | SubscriptionChangeConflictPolicies$Outbound
+    | undefined;
   proration_behavior: string;
   target_plan_id: string;
 };
@@ -40,18 +62,26 @@ export const SubscriptionChangeV2Request$outboundSchema: z.ZodMiniType<
   SubscriptionChangeV2Request
 > = z.pipe(
   z.object({
+    billingPeriodBehaviour: z.optional(BillingPeriodBehaviour$outboundSchema),
+    billingPeriodConfig: z.optional(BillingPeriodConfig$outboundSchema),
     changeAt: z.optional(ScheduleType$outboundSchema),
     entityPolicies: z.optional(SubscriptionChangeEntityPolicies$outboundSchema),
     idempotencyKey: z.optional(z.string()),
     metadata: z.optional(z.record(z.string(), z.string())),
+    onConflictPolicies: z.optional(
+      SubscriptionChangeConflictPolicies$outboundSchema,
+    ),
     prorationBehavior: ProrationBehavior$outboundSchema,
     targetPlanId: z.string(),
   }),
   z.transform((v) => {
     return remap$(v, {
+      billingPeriodBehaviour: "billing_period_behaviour",
+      billingPeriodConfig: "billing_period_config",
       changeAt: "change_at",
       entityPolicies: "entity_policies",
       idempotencyKey: "idempotency_key",
+      onConflictPolicies: "on_conflict_policies",
       prorationBehavior: "proration_behavior",
       targetPlanId: "target_plan_id",
     });

package/src/sdk/models/subscription-change-v2-response.ts

@@ -17,6 +17,10 @@ import {
 } from "./entity-change-result.js";
 import { PlanSummary, PlanSummary$inboundSchema } from "./plan-summary.js";
 import { SDKValidationError } from "./sdk-validation-error.js";
+import {
+  SubscriptionChangeBillingPeriodResult,
+  SubscriptionChangeBillingPeriodResult$inboundSchema,
+} from "./subscription-change-billing-period-result.js";
 import {
   SubscriptionChangeType,
   SubscriptionChangeType$inboundSchema,
@@ -27,6 +31,7 @@ import {
 } from "./subscription-response.js";
 
 export type SubscriptionChangeV2Response = {
+  billingPeriod?: SubscriptionChangeBillingPeriodResult | undefined;
   changeType?: SubscriptionChangeType | undefined;
   changedResources?: ChangedResources | undefined;
   effectiveAt?: Date | undefined;
@@ -43,6 +48,13 @@ export type SubscriptionChangeV2Response = {
   scheduleId?: string | undefined;
   scheduledAt?: Date | undefined;
   subscription?: SubscriptionResponse | undefined;
+  /**
+   * SupersededSchedules lists the plan-change schedules this request cancelled under
+   *
+   * @remarks
+   * on_conflict_policies.on_pending_schedule. Preview reports what execute would cancel.
+   */
+  supersededSchedules?: Array<string> | undefined;
   toPlan?: PlanSummary | undefined;
   warnings?: Array<string> | undefined;
 };
@@ -53,6 +65,9 @@ export const SubscriptionChangeV2Response$inboundSchema: z.ZodMiniType<
   unknown
 > = z.pipe(
   z.object({
+    billing_period: types.optional(
+      SubscriptionChangeBillingPeriodResult$inboundSchema,
+    ),
     change_type: types.optional(SubscriptionChangeType$inboundSchema),
     changed_resources: types.optional(ChangedResources$inboundSchema),
     effective_at: types.optional(types.date()),
@@ -63,11 +78,13 @@ export const SubscriptionChangeV2Response$inboundSchema: z.ZodMiniType<
     schedule_id: types.optional(types.string()),
     scheduled_at: types.optional(types.date()),
     subscription: types.optional(SubscriptionResponse$inboundSchema),
+    superseded_schedules: types.optional(z.array(types.string())),
     to_plan: types.optional(PlanSummary$inboundSchema),
     warnings: types.optional(z.array(types.string())),
   }),
   z.transform((v) => {
     return remap$(v, {
+      "billing_period": "billingPeriod",
       "change_type": "changeType",
       "changed_resources": "changedResources",
       "effective_at": "effectiveAt",
@@ -76,6 +93,7 @@ export const SubscriptionChangeV2Response$inboundSchema: z.ZodMiniType<
       "is_scheduled": "isScheduled",
       "schedule_id": "scheduleId",
       "scheduled_at": "scheduledAt",
+      "superseded_schedules": "supersededSchedules",
       "to_plan": "toPlan",
     });
   }),

package/src/sdk/models/usage-record-filter.ts

@@ -0,0 +1,130 @@
+/*
+ * 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 { ClosedEnum } from "../../types/enums.js";
+import {
+  FilterCondition,
+  FilterCondition$Outbound,
+  FilterCondition$outboundSchema,
+} from "./filter-condition.js";
+import {
+  SortCondition,
+  SortCondition$Outbound,
+  SortCondition$outboundSchema,
+} from "./sort-condition.js";
+import { Status, Status$outboundSchema } from "./status.js";
+
+export const UsageRecordFilterOrder = {
+  Asc: "asc",
+  Desc: "desc",
+} as const;
+export type UsageRecordFilterOrder = ClosedEnum<typeof UsageRecordFilterOrder>;
+
+export type UsageRecordFilter = {
+  currency?: string | undefined;
+  customerExternalId?: string | undefined;
+  customerId?: string | undefined;
+  endTime?: Date | undefined;
+  expand?: string | undefined;
+  /**
+   * Generic predicate and ordering escape hatch, for comparisons that have no dedicated field
+   *
+   * @remarks
+   * below — a range such as period_end at or after a cutoff goes here.
+   */
+  filters?: Array<FilterCondition> | undefined;
+  limit?: number | undefined;
+  offset?: number | undefined;
+  order?: UsageRecordFilterOrder | undefined;
+  periodEnd?: Date | undefined;
+  /**
+   * Exact-match on the window boundaries. Together with SubscriptionID these identify a single row:
+   *
+   * @remarks
+   * they are the columns the table's unique index is built on.
+   */
+  periodStart?: Date | undefined;
+  planId?: string | undefined;
+  sort?: Array<SortCondition> | undefined;
+  startTime?: Date | undefined;
+  status?: Status | undefined;
+  subscriptionId?: string | undefined;
+  synced?: boolean | undefined;
+};
+
+/** @internal */
+export const UsageRecordFilterOrder$outboundSchema: z.ZodMiniEnum<
+  typeof UsageRecordFilterOrder
+> = z.enum(UsageRecordFilterOrder);
+
+/** @internal */
+export type UsageRecordFilter$Outbound = {
+  currency?: string | undefined;
+  customer_external_id?: string | undefined;
+  customer_id?: string | undefined;
+  end_time?: string | undefined;
+  expand?: string | undefined;
+  filters?: Array<FilterCondition$Outbound> | undefined;
+  limit?: number | undefined;
+  offset?: number | undefined;
+  order?: string | undefined;
+  period_end?: string | undefined;
+  period_start?: string | undefined;
+  plan_id?: string | undefined;
+  sort?: Array<SortCondition$Outbound> | undefined;
+  start_time?: string | undefined;
+  status?: string | undefined;
+  subscription_id?: string | undefined;
+  synced?: boolean | undefined;
+};
+
+/** @internal */
+export const UsageRecordFilter$outboundSchema: z.ZodMiniType<
+  UsageRecordFilter$Outbound,
+  UsageRecordFilter
+> = z.pipe(
+  z.object({
+    currency: z.optional(z.string()),
+    customerExternalId: z.optional(z.string()),
+    customerId: z.optional(z.string()),
+    endTime: z.optional(z.pipe(z.date(), z.transform(v => v.toISOString()))),
+    expand: z.optional(z.string()),
+    filters: z.optional(z.array(FilterCondition$outboundSchema)),
+    limit: z.optional(z.int()),
+    offset: z.optional(z.int()),
+    order: z.optional(UsageRecordFilterOrder$outboundSchema),
+    periodEnd: z.optional(z.pipe(z.date(), z.transform(v => v.toISOString()))),
+    periodStart: z.optional(
+      z.pipe(z.date(), z.transform(v => v.toISOString())),
+    ),
+    planId: z.optional(z.string()),
+    sort: z.optional(z.array(SortCondition$outboundSchema)),
+    startTime: z.optional(z.pipe(z.date(), z.transform(v => v.toISOString()))),
+    status: z.optional(Status$outboundSchema),
+    subscriptionId: z.optional(z.string()),
+    synced: z.optional(z.boolean()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      customerExternalId: "customer_external_id",
+      customerId: "customer_id",
+      endTime: "end_time",
+      periodEnd: "period_end",
+      periodStart: "period_start",
+      planId: "plan_id",
+      startTime: "start_time",
+      subscriptionId: "subscription_id",
+    });
+  }),
+);
+
+export function usageRecordFilterToJSON(
+  usageRecordFilter: UsageRecordFilter,
+): string {
+  return JSON.stringify(
+    UsageRecordFilter$outboundSchema.parse(usageRecordFilter),
+  );
+}

package/src/sdk/models/usage-record-response.ts

@@ -0,0 +1,93 @@
+/*
+ * 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 * as types from "../../types/primitives.js";
+import { SDKValidationError } from "./sdk-validation-error.js";
+import { Status, Status$inboundSchema } from "./status.js";
+import {
+  UsageRecordSyncEntry,
+  UsageRecordSyncEntry$inboundSchema,
+} from "./usage-record-sync-entry.js";
+
+export type UsageRecordResponse = {
+  amount?: number | undefined;
+  createdAt?: Date | undefined;
+  createdBy?: string | undefined;
+  currency?: string | undefined;
+  customerExternalId?: string | undefined;
+  customerId?: string | undefined;
+  environmentId?: string | undefined;
+  id?: string | undefined;
+  periodEnd?: Date | undefined;
+  periodStart?: Date | undefined;
+  planId?: string | undefined;
+  quantity?: number | undefined;
+  status?: Status | undefined;
+  subscriptionId?: string | undefined;
+  synced?: boolean | undefined;
+  syncs?: { [k: string]: UsageRecordSyncEntry } | undefined;
+  tenantId?: string | undefined;
+  updatedAt?: Date | undefined;
+  updatedBy?: string | undefined;
+};
+
+/** @internal */
+export const UsageRecordResponse$inboundSchema: z.ZodMiniType<
+  UsageRecordResponse,
+  unknown
+> = z.pipe(
+  z.object({
+    amount: types.optional(types.number()),
+    created_at: types.optional(types.date()),
+    created_by: types.optional(types.string()),
+    currency: types.optional(types.string()),
+    customer_external_id: types.optional(types.string()),
+    customer_id: types.optional(types.string()),
+    environment_id: types.optional(types.string()),
+    id: types.optional(types.string()),
+    period_end: types.optional(types.date()),
+    period_start: types.optional(types.date()),
+    plan_id: types.optional(types.string()),
+    quantity: types.optional(types.number()),
+    status: types.optional(Status$inboundSchema),
+    subscription_id: types.optional(types.string()),
+    synced: types.optional(types.boolean()),
+    syncs: types.optional(
+      z.record(z.string(), UsageRecordSyncEntry$inboundSchema),
+    ),
+    tenant_id: types.optional(types.string()),
+    updated_at: types.optional(types.date()),
+    updated_by: types.optional(types.string()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "created_at": "createdAt",
+      "created_by": "createdBy",
+      "customer_external_id": "customerExternalId",
+      "customer_id": "customerId",
+      "environment_id": "environmentId",
+      "period_end": "periodEnd",
+      "period_start": "periodStart",
+      "plan_id": "planId",
+      "subscription_id": "subscriptionId",
+      "tenant_id": "tenantId",
+      "updated_at": "updatedAt",
+      "updated_by": "updatedBy",
+    });
+  }),
+);
+
+export function usageRecordResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<UsageRecordResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UsageRecordResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UsageRecordResponse' from JSON`,
+  );
+}

package/src/sdk/models/usage-record-sync-entry.ts

@@ -0,0 +1,70 @@
+/*
+ * 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 * as types from "../../types/primitives.js";
+import { SDKValidationError } from "./sdk-validation-error.js";
+
+export type UsageRecordSyncEntry = {
+  /**
+   * AgreementID is the subscription's identifier on this marketplace: license_arn on AWS,
+   *
+   * @remarks
+   * usage_reporting_id on GCP, resource_id on Azure. It records which agreement the usage was
+   * billed against, which stays meaningful after the connection that reported it is replaced.
+   */
+  agreementId?: string | undefined;
+  /**
+   * ConnectionID is the connection that reported this entry, kept for tracing which credentials
+   *
+   * @remarks
+   * were used. It is deliberately not part of the map key: a replaced connection must not make an
+   * already reported record look unreported.
+   */
+  connectionId?: string | undefined;
+  reportingId?: string | undefined;
+  skipReason?: string | undefined;
+  skipped?: boolean | undefined;
+  /**
+   * SyncedAt is when the marketplace accepted the record. Zero on a skip, since nothing was sent.
+   */
+  syncedAt?: Date | undefined;
+};
+
+/** @internal */
+export const UsageRecordSyncEntry$inboundSchema: z.ZodMiniType<
+  UsageRecordSyncEntry,
+  unknown
+> = z.pipe(
+  z.object({
+    agreement_id: types.optional(types.string()),
+    connection_id: types.optional(types.string()),
+    reporting_id: types.optional(types.string()),
+    skip_reason: types.optional(types.string()),
+    skipped: types.optional(types.boolean()),
+    synced_at: types.optional(types.date()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "agreement_id": "agreementId",
+      "connection_id": "connectionId",
+      "reporting_id": "reportingId",
+      "skip_reason": "skipReason",
+      "synced_at": "syncedAt",
+    });
+  }),
+);
+
+export function usageRecordSyncEntryFromJSON(
+  jsonString: string,
+): SafeParseResult<UsageRecordSyncEntry, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UsageRecordSyncEntry$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UsageRecordSyncEntry' from JSON`,
+  );
+}

package/src/sdk/sdk.ts

@@ -33,6 +33,7 @@ import { Tasks } from "./tasks.js";
 import { TaxAssociations } from "./tax-associations.js";
 import { TaxRates } from "./tax-rates.js";
 import { Tenants } from "./tenants.js";
+import { UsageRecords } from "./usage-records.js";
 import { Users } from "./users.js";
 import { Wallets } from "./wallets.js";
 import { WebhookEvents } from "./webhook-events.js";
@@ -194,6 +195,11 @@ export class Flexprice extends ClientSDK {
     return (this._tenants ??= new Tenants(this._options));
   }
 
+  private _usageRecords?: UsageRecords;
+  get usageRecords(): UsageRecords {
+    return (this._usageRecords ??= new UsageRecords(this._options));
+  }
+
   private _users?: Users;
   get users(): Users {
     return (this._users ??= new Users(this._options));

package/src/sdk/subscriptions.ts

@@ -319,7 +319,9 @@ export class Subscriptions extends ClientSDK {
    *
    * scheduled_at is resolved from the subscription's current period end at request time. If that period end is already in the past (a backdated start date, a resumed pause, or worker downtime can all leave a subscription behind), the change is due immediately and fires on the next billing scan rather than a period away — inspect scheduled_at to see this.
    *
-   * Only one plan change may be pending per subscription; request a second one and this returns 400. Cancel the existing schedule via POST /subscriptions/schedules/{schedule_id}/cancel first. Pending schedules are listable via GET /subscriptions/{id}/schedules.
+   * Only one plan change may be pending per subscription. By default (on_conflict_policies.on_pending_schedule = 'reject') a second request returns 400; cancel the existing schedule via POST /subscriptions/schedules/{schedule_id}/cancel first. Pending schedules are listable via GET /subscriptions/{id}/schedules.
+   *
+   * Set on_conflict_policies.on_pending_schedule to 'supersede' to replace the queued change instead: the pending schedule is cancelled and this request applied in the same transaction, so both land or neither does. The cancelled schedule ids are returned in superseded_schedules, and preview reports the same list without writing.
    */
   async executeSubscriptionPlanChangeV2(
     id: string,

package/src/sdk/usage-records.ts

@@ -0,0 +1,27 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { usageRecordsPostUsageRecordsSearch } from "../funcs/usage-records-post-usage-records-search.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import { unwrapAsync } from "../types/fp.js";
+import * as models from "./models/index.js";
+
+export class UsageRecords extends ClientSDK {
+  /**
+   * List usage records
+   *
+   * @remarks
+   * Lists usage records. Also accepts filters/sort for a filtered query.
+   */
+  async postUsageRecordsSearch(
+    request: models.UsageRecordFilter,
+    options?: RequestOptions,
+  ): Promise<models.ListUsageRecordsResponse> {
+    return unwrapAsync(usageRecordsPostUsageRecordsSearch(
+      this,
+      request,
+      options,
+    ));
+  }
+}