@flexprice/sdk 2.1.30 → 2.1.33

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

@@ -9,15 +9,22 @@ import {
   AddAddonRef$Outbound,
   AddAddonRef$outboundSchema,
 } from "./add-addon-ref.js";
+import {
+  RemoveAddonRef,
+  RemoveAddonRef$Outbound,
+  RemoveAddonRef$outboundSchema,
+} from "./remove-addon-ref.js";
 
 export type AddAddonParams = {
   addons?: Array<AddAddonRef> | undefined;
+  removes?: Array<RemoveAddonRef> | undefined;
   subscriptionId?: string | undefined;
 };
 
 /** @internal */
 export type AddAddonParams$Outbound = {
   addons?: Array<AddAddonRef$Outbound> | undefined;
+  removes?: Array<RemoveAddonRef$Outbound> | undefined;
   subscription_id?: string | undefined;
 };
 
@@ -28,6 +35,7 @@ export const AddAddonParams$outboundSchema: z.ZodMiniType<
 > = z.pipe(
   z.object({
     addons: z.optional(z.array(AddAddonRef$outboundSchema)),
+    removes: z.optional(z.array(RemoveAddonRef$outboundSchema)),
     subscriptionId: z.optional(z.string()),
   }),
   z.transform((v) => {

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

@@ -24,10 +24,12 @@ import {
   ProrationBehavior,
   ProrationBehavior$outboundSchema,
 } from "./proration-behavior.js";
+import { ScheduleType, ScheduleType$outboundSchema } from "./schedule-type.js";
 
 export type AddAddonRequest = {
   addonId: string;
   cadence?: AddonCadence | undefined;
+  changeAt?: ScheduleType | undefined;
   checkout?: CheckoutParams | undefined;
   /**
    * LineItemCommitments allows setting commitment configuration per addon line item (keyed by price_id)
@@ -47,6 +49,7 @@ export type AddAddonRequest = {
 export type AddAddonRequest$Outbound = {
   addon_id: string;
   cadence?: string | undefined;
+  change_at?: string | undefined;
   checkout?: CheckoutParams$Outbound | undefined;
   line_item_commitments?:
     | { [k: string]: LineItemCommitmentConfig$Outbound }
@@ -66,6 +69,7 @@ export const AddAddonRequest$outboundSchema: z.ZodMiniType<
   z.object({
     addonId: z.string(),
     cadence: z.optional(AddonCadence$outboundSchema),
+    changeAt: z.optional(ScheduleType$outboundSchema),
     checkout: z.optional(CheckoutParams$outboundSchema),
     lineItemCommitments: z.optional(
       z.record(z.string(), LineItemCommitmentConfig$outboundSchema),
@@ -81,6 +85,7 @@ export const AddAddonRequest$outboundSchema: z.ZodMiniType<
   z.transform((v) => {
     return remap$(v, {
       addonId: "addon_id",
+      changeAt: "change_at",
       lineItemCommitments: "line_item_commitments",
       overrideLineItems: "override_line_items",
       prorationBehavior: "proration_behavior",

package/src/sdk/models/add-addon-to-subscription-request.ts

@@ -19,10 +19,12 @@ import {
   ProrationBehavior,
   ProrationBehavior$outboundSchema,
 } from "./proration-behavior.js";
+import { ScheduleType, ScheduleType$outboundSchema } from "./schedule-type.js";
 
 export type AddAddonToSubscriptionRequest = {
   addonId: string;
   cadence?: AddonCadence | undefined;
+  changeAt?: ScheduleType | undefined;
   /**
    * LineItemCommitments allows setting commitment configuration per addon line item (keyed by price_id)
    */
@@ -40,6 +42,7 @@ export type AddAddonToSubscriptionRequest = {
 export type AddAddonToSubscriptionRequest$Outbound = {
   addon_id: string;
   cadence?: string | undefined;
+  change_at?: string | undefined;
   line_item_commitments?:
     | { [k: string]: LineItemCommitmentConfig$Outbound }
     | undefined;
@@ -57,6 +60,7 @@ export const AddAddonToSubscriptionRequest$outboundSchema: z.ZodMiniType<
   z.object({
     addonId: z.string(),
     cadence: z.optional(AddonCadence$outboundSchema),
+    changeAt: z.optional(ScheduleType$outboundSchema),
     lineItemCommitments: z.optional(
       z.record(z.string(), LineItemCommitmentConfig$outboundSchema),
     ),
@@ -70,6 +74,7 @@ export const AddAddonToSubscriptionRequest$outboundSchema: z.ZodMiniType<
   z.transform((v) => {
     return remap$(v, {
       addonId: "addon_id",
+      changeAt: "change_at",
       lineItemCommitments: "line_item_commitments",
       overrideLineItems: "override_line_items",
       prorationBehavior: "proration_behavior",

package/src/sdk/models/aggregated-entitlement-bucket.ts

@@ -23,6 +23,7 @@ export type AggregatedEntitlementBucket = {
   grantDurationValue?: number | undefined;
   grantMeasure?: EntitlementGrantMeasure | undefined;
   grantQuota?: string | undefined;
+  grantUnlimited?: boolean | undefined;
   sourceEntityId?: string | undefined;
   usageLimit?: number | undefined;
 };
@@ -40,6 +41,7 @@ export const AggregatedEntitlementBucket$inboundSchema: z.ZodMiniType<
     grant_duration_value: types.optional(types.number()),
     grant_measure: types.optional(EntitlementGrantMeasure$inboundSchema),
     grant_quota: types.optional(types.string()),
+    grant_unlimited: types.optional(types.boolean()),
     source_entity_id: types.optional(types.string()),
     usage_limit: types.optional(types.number()),
   }),
@@ -50,6 +52,7 @@ export const AggregatedEntitlementBucket$inboundSchema: z.ZodMiniType<
       "grant_duration_value": "grantDurationValue",
       "grant_measure": "grantMeasure",
       "grant_quota": "grantQuota",
+      "grant_unlimited": "grantUnlimited",
       "source_entity_id": "sourceEntityId",
       "usage_limit": "usageLimit",
     });

package/src/sdk/models/aggregated-entitlement.ts

@@ -15,10 +15,19 @@ import {
   EntitlementAggregationMode,
   EntitlementAggregationMode$inboundSchema,
 } from "./entitlement-aggregation-mode.js";
+import {
+  EntitlementGrantDurationUnit,
+  EntitlementGrantDurationUnit$inboundSchema,
+} from "./entitlement-grant-duration-unit.js";
+import {
+  EntitlementGrantMeasure,
+  EntitlementGrantMeasure$inboundSchema,
+} from "./entitlement-grant-measure.js";
 import {
   EntitlementUsageResetPeriod,
   EntitlementUsageResetPeriod$inboundSchema,
 } from "./entitlement-usage-reset-period.js";
+import { GrantState, GrantState$inboundSchema } from "./grant-state.js";
 import { SDKValidationError } from "./sdk-validation-error.js";
 
 export type ConfigValue = {};
@@ -27,6 +36,12 @@ export type AggregatedEntitlement = {
   aggregationMode?: EntitlementAggregationMode | undefined;
   buckets?: Array<AggregatedEntitlementBucket> | undefined;
   configValues?: Array<{ [k: string]: ConfigValue }> | undefined;
+  grantDurationUnit?: EntitlementGrantDurationUnit | undefined;
+  grantDurationValue?: number | undefined;
+  grantMeasure?: EntitlementGrantMeasure | undefined;
+  grantQuota?: string | undefined;
+  grantState?: GrantState | undefined;
+  grantUnlimited?: boolean | undefined;
   isEnabled?: boolean | undefined;
   isSoftLimit?: boolean | undefined;
   staticValues?: Array<string> | undefined;
@@ -59,6 +74,14 @@ export const AggregatedEntitlement$inboundSchema: z.ZodMiniType<
     config_values: types.optional(
       z.array(z.record(z.string(), z.lazy(() => ConfigValue$inboundSchema))),
     ),
+    grant_duration_unit: types.optional(
+      EntitlementGrantDurationUnit$inboundSchema,
+    ),
+    grant_duration_value: types.optional(types.number()),
+    grant_measure: types.optional(EntitlementGrantMeasure$inboundSchema),
+    grant_quota: types.optional(types.string()),
+    grant_state: types.optional(GrantState$inboundSchema),
+    grant_unlimited: types.optional(types.boolean()),
     is_enabled: types.optional(types.boolean()),
     is_soft_limit: types.optional(types.boolean()),
     static_values: types.optional(z.array(types.string())),
@@ -71,6 +94,12 @@ export const AggregatedEntitlement$inboundSchema: z.ZodMiniType<
     return remap$(v, {
       "aggregation_mode": "aggregationMode",
       "config_values": "configValues",
+      "grant_duration_unit": "grantDurationUnit",
+      "grant_duration_value": "grantDurationValue",
+      "grant_measure": "grantMeasure",
+      "grant_quota": "grantQuota",
+      "grant_state": "grantState",
+      "grant_unlimited": "grantUnlimited",
       "is_enabled": "isEnabled",
       "is_soft_limit": "isSoftLimit",
       "static_values": "staticValues",

package/src/sdk/models/analytics-column.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 { ColumnRole, ColumnRole$inboundSchema } from "./column-role.js";
+import { ColumnType, ColumnType$inboundSchema } from "./column-type.js";
+import { SDKValidationError } from "./sdk-validation-error.js";
+
+export type AnalyticsColumn = {
+  currency?: string | undefined;
+  name?: string | undefined;
+  role?: ColumnRole | undefined;
+  type?: ColumnType | undefined;
+};
+
+/** @internal */
+export const AnalyticsColumn$inboundSchema: z.ZodMiniType<
+  AnalyticsColumn,
+  unknown
+> = z.object({
+  currency: types.optional(types.string()),
+  name: types.optional(types.string()),
+  role: types.optional(ColumnRole$inboundSchema),
+  type: types.optional(ColumnType$inboundSchema),
+});
+
+export function analyticsColumnFromJSON(
+  jsonString: string,
+): SafeParseResult<AnalyticsColumn, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AnalyticsColumn$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AnalyticsColumn' from JSON`,
+  );
+}

package/src/sdk/models/analytics-filter.ts

@@ -0,0 +1,65 @@
+/*
+ * 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 {
+  FilterOperatorType,
+  FilterOperatorType$inboundSchema,
+  FilterOperatorType$outboundSchema,
+} from "./filter-operator-type.js";
+import { SDKValidationError } from "./sdk-validation-error.js";
+
+export type AnalyticsFilter = {
+  field?: string | undefined;
+  op?: FilterOperatorType | undefined;
+  optional?: boolean | undefined;
+  value?: Array<string> | undefined;
+};
+
+/** @internal */
+export const AnalyticsFilter$inboundSchema: z.ZodMiniType<
+  AnalyticsFilter,
+  unknown
+> = z.object({
+  field: types.optional(types.string()),
+  op: types.optional(FilterOperatorType$inboundSchema),
+  optional: types.optional(types.boolean()),
+  value: types.optional(z.array(types.string())),
+});
+/** @internal */
+export type AnalyticsFilter$Outbound = {
+  field?: string | undefined;
+  op?: string | undefined;
+  optional?: boolean | undefined;
+  value?: Array<string> | undefined;
+};
+
+/** @internal */
+export const AnalyticsFilter$outboundSchema: z.ZodMiniType<
+  AnalyticsFilter$Outbound,
+  AnalyticsFilter
+> = z.object({
+  field: z.optional(z.string()),
+  op: z.optional(FilterOperatorType$outboundSchema),
+  optional: z.optional(z.boolean()),
+  value: z.optional(z.array(z.string())),
+});
+
+export function analyticsFilterToJSON(
+  analyticsFilter: AnalyticsFilter,
+): string {
+  return JSON.stringify(AnalyticsFilter$outboundSchema.parse(analyticsFilter));
+}
+export function analyticsFilterFromJSON(
+  jsonString: string,
+): SafeParseResult<AnalyticsFilter, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AnalyticsFilter$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AnalyticsFilter' from JSON`,
+  );
+}

package/src/sdk/models/analytics-query-meta.ts

@@ -0,0 +1,39 @@
+/*
+ * 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 AnalyticsQueryMeta = {
+  querySource?: string | undefined;
+};
+
+/** @internal */
+export const AnalyticsQueryMeta$inboundSchema: z.ZodMiniType<
+  AnalyticsQueryMeta,
+  unknown
+> = z.pipe(
+  z.object({
+    query_source: types.optional(types.string()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "query_source": "querySource",
+    });
+  }),
+);
+
+export function analyticsQueryMetaFromJSON(
+  jsonString: string,
+): SafeParseResult<AnalyticsQueryMeta, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AnalyticsQueryMeta$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AnalyticsQueryMeta' from JSON`,
+  );
+}

package/src/sdk/models/analytics-query-request.ts

@@ -0,0 +1,38 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import {
+  AnalyticsViewDefinition,
+  AnalyticsViewDefinition$Outbound,
+  AnalyticsViewDefinition$outboundSchema,
+} from "./analytics-view-definition.js";
+
+export type AnalyticsQueryRequest = {
+  definition: AnalyticsViewDefinition;
+  variables?: { [k: string]: Array<string> } | undefined;
+};
+
+/** @internal */
+export type AnalyticsQueryRequest$Outbound = {
+  definition: AnalyticsViewDefinition$Outbound;
+  variables?: { [k: string]: Array<string> } | undefined;
+};
+
+/** @internal */
+export const AnalyticsQueryRequest$outboundSchema: z.ZodMiniType<
+  AnalyticsQueryRequest$Outbound,
+  AnalyticsQueryRequest
+> = z.object({
+  definition: AnalyticsViewDefinition$outboundSchema,
+  variables: z.optional(z.record(z.string(), z.array(z.string()))),
+});
+
+export function analyticsQueryRequestToJSON(
+  analyticsQueryRequest: AnalyticsQueryRequest,
+): string {
+  return JSON.stringify(
+    AnalyticsQueryRequest$outboundSchema.parse(analyticsQueryRequest),
+  );
+}

package/src/sdk/models/analytics-query-result.ts

@@ -0,0 +1,43 @@
+/*
+ * 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 {
+  AnalyticsColumn,
+  AnalyticsColumn$inboundSchema,
+} from "./analytics-column.js";
+import {
+  AnalyticsQueryMeta,
+  AnalyticsQueryMeta$inboundSchema,
+} from "./analytics-query-meta.js";
+import { SDKValidationError } from "./sdk-validation-error.js";
+
+export type AnalyticsQueryResult = {
+  columns?: Array<AnalyticsColumn> | undefined;
+  meta?: AnalyticsQueryMeta | undefined;
+  rows?: Array<Array<string>> | undefined;
+};
+
+/** @internal */
+export const AnalyticsQueryResult$inboundSchema: z.ZodMiniType<
+  AnalyticsQueryResult,
+  unknown
+> = z.object({
+  columns: types.optional(z.array(AnalyticsColumn$inboundSchema)),
+  meta: types.optional(AnalyticsQueryMeta$inboundSchema),
+  rows: types.optional(z.array(z.array(types.string()))),
+});
+
+export function analyticsQueryResultFromJSON(
+  jsonString: string,
+): SafeParseResult<AnalyticsQueryResult, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AnalyticsQueryResult$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AnalyticsQueryResult' from JSON`,
+  );
+}

package/src/sdk/models/analytics-sort-spec.ts

@@ -0,0 +1,59 @@
+/*
+ * 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 { SDKValidationError } from "./sdk-validation-error.js";
+import {
+  SortDirection,
+  SortDirection$inboundSchema,
+  SortDirection$outboundSchema,
+} from "./sort-direction.js";
+
+export type AnalyticsSortSpec = {
+  dir?: SortDirection | undefined;
+  field?: string | undefined;
+};
+
+/** @internal */
+export const AnalyticsSortSpec$inboundSchema: z.ZodMiniType<
+  AnalyticsSortSpec,
+  unknown
+> = z.object({
+  dir: types.optional(SortDirection$inboundSchema),
+  field: types.optional(types.string()),
+});
+/** @internal */
+export type AnalyticsSortSpec$Outbound = {
+  dir?: string | undefined;
+  field?: string | undefined;
+};
+
+/** @internal */
+export const AnalyticsSortSpec$outboundSchema: z.ZodMiniType<
+  AnalyticsSortSpec$Outbound,
+  AnalyticsSortSpec
+> = z.object({
+  dir: z.optional(SortDirection$outboundSchema),
+  field: z.optional(z.string()),
+});
+
+export function analyticsSortSpecToJSON(
+  analyticsSortSpec: AnalyticsSortSpec,
+): string {
+  return JSON.stringify(
+    AnalyticsSortSpec$outboundSchema.parse(analyticsSortSpec),
+  );
+}
+export function analyticsSortSpecFromJSON(
+  jsonString: string,
+): SafeParseResult<AnalyticsSortSpec, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AnalyticsSortSpec$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AnalyticsSortSpec' from JSON`,
+  );
+}

package/src/sdk/models/analytics-time-spec-raw.ts

@@ -0,0 +1,55 @@
+/*
+ * 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 { Grain, Grain$inboundSchema, Grain$outboundSchema } from "./grain.js";
+import { SDKValidationError } from "./sdk-validation-error.js";
+
+export type AnalyticsTimeSpecRaw = {
+  grain?: Grain | undefined;
+  range?: string | undefined;
+};
+
+/** @internal */
+export const AnalyticsTimeSpecRaw$inboundSchema: z.ZodMiniType<
+  AnalyticsTimeSpecRaw,
+  unknown
+> = z.object({
+  grain: types.optional(Grain$inboundSchema),
+  range: types.optional(types.string()),
+});
+/** @internal */
+export type AnalyticsTimeSpecRaw$Outbound = {
+  grain?: string | undefined;
+  range?: string | undefined;
+};
+
+/** @internal */
+export const AnalyticsTimeSpecRaw$outboundSchema: z.ZodMiniType<
+  AnalyticsTimeSpecRaw$Outbound,
+  AnalyticsTimeSpecRaw
+> = z.object({
+  grain: z.optional(Grain$outboundSchema),
+  range: z.optional(z.string()),
+});
+
+export function analyticsTimeSpecRawToJSON(
+  analyticsTimeSpecRaw: AnalyticsTimeSpecRaw,
+): string {
+  return JSON.stringify(
+    AnalyticsTimeSpecRaw$outboundSchema.parse(analyticsTimeSpecRaw),
+  );
+}
+export function analyticsTimeSpecRawFromJSON(
+  jsonString: string,
+): SafeParseResult<AnalyticsTimeSpecRaw, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AnalyticsTimeSpecRaw$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AnalyticsTimeSpecRaw' from JSON`,
+  );
+}

package/src/sdk/models/analytics-variable.ts

@@ -0,0 +1,67 @@
+/*
+ * 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 { SDKValidationError } from "./sdk-validation-error.js";
+import {
+  VariableType,
+  VariableType$inboundSchema,
+  VariableType$outboundSchema,
+} from "./variable-type.js";
+
+export type AnalyticsVariable = {
+  default?: Array<string> | undefined;
+  name?: string | undefined;
+  required?: boolean | undefined;
+  type: VariableType;
+};
+
+/** @internal */
+export const AnalyticsVariable$inboundSchema: z.ZodMiniType<
+  AnalyticsVariable,
+  unknown
+> = z.object({
+  default: types.optional(z.array(types.string())),
+  name: types.optional(types.string()),
+  required: types.optional(types.boolean()),
+  type: VariableType$inboundSchema,
+});
+/** @internal */
+export type AnalyticsVariable$Outbound = {
+  default?: Array<string> | undefined;
+  name?: string | undefined;
+  required?: boolean | undefined;
+  type: string;
+};
+
+/** @internal */
+export const AnalyticsVariable$outboundSchema: z.ZodMiniType<
+  AnalyticsVariable$Outbound,
+  AnalyticsVariable
+> = z.object({
+  default: z.optional(z.array(z.string())),
+  name: z.optional(z.string()),
+  required: z.optional(z.boolean()),
+  type: VariableType$outboundSchema,
+});
+
+export function analyticsVariableToJSON(
+  analyticsVariable: AnalyticsVariable,
+): string {
+  return JSON.stringify(
+    AnalyticsVariable$outboundSchema.parse(analyticsVariable),
+  );
+}
+export function analyticsVariableFromJSON(
+  jsonString: string,
+): SafeParseResult<AnalyticsVariable, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AnalyticsVariable$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AnalyticsVariable' from JSON`,
+  );
+}