@paygentic/sdk 0.8.0 → 0.8.2

package/src/models/reconciledfeatureadded.ts

@@ -0,0 +1,38 @@
+/*
+ * 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";
+
+export type ReconciledFeatureAdded = {
+  featureId: string;
+  featureKey: string;
+  /**
+   * False when this feature's price never produces a recurring line item (an instant price, a credit-denominated price, or an already-elapsed one-time charge) — the feature is entitled but not billed by this reconciliation.
+   */
+  billed: boolean;
+};
+
+/** @internal */
+export const ReconciledFeatureAdded$inboundSchema: z.ZodType<
+  ReconciledFeatureAdded,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  featureId: z.string(),
+  featureKey: z.string(),
+  billed: z.boolean(),
+});
+
+export function reconciledFeatureAddedFromJSON(
+  jsonString: string,
+): SafeParseResult<ReconciledFeatureAdded, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ReconciledFeatureAdded$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ReconciledFeatureAdded' from JSON`,
+  );
+}

package/src/models/reconciledfeaturefailed.ts

@@ -0,0 +1,55 @@
+/*
+ * 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";
+
+/**
+ * Coded failure reason. `grant_mint_failed` means the entitlement was created but its initial metered grant could not be minted; re-running this reconciliation retries the mint.
+ */
+export const Reason = {
+  EntitlementFailed: "entitlement_failed",
+  GrantMintFailed: "grant_mint_failed",
+} as const;
+/**
+ * Coded failure reason. `grant_mint_failed` means the entitlement was created but its initial metered grant could not be minted; re-running this reconciliation retries the mint.
+ */
+export type Reason = ClosedEnum<typeof Reason>;
+
+export type ReconciledFeatureFailed = {
+  featureId: string;
+  featureKey: string;
+  /**
+   * Coded failure reason. `grant_mint_failed` means the entitlement was created but its initial metered grant could not be minted; re-running this reconciliation retries the mint.
+   */
+  reason: Reason;
+};
+
+/** @internal */
+export const Reason$inboundSchema: z.ZodNativeEnum<typeof Reason> = z
+  .nativeEnum(Reason);
+
+/** @internal */
+export const ReconciledFeatureFailed$inboundSchema: z.ZodType<
+  ReconciledFeatureFailed,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  featureId: z.string(),
+  featureKey: z.string(),
+  reason: Reason$inboundSchema,
+});
+
+export function reconciledFeatureFailedFromJSON(
+  jsonString: string,
+): SafeParseResult<ReconciledFeatureFailed, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ReconciledFeatureFailed$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ReconciledFeatureFailed' from JSON`,
+  );
+}

package/src/models/reconciledfeatureremoved.ts

@@ -0,0 +1,33 @@
+/*
+ * 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";
+
+export type ReconciledFeatureRemoved = {
+  featureId: string;
+  featureKey: string;
+};
+
+/** @internal */
+export const ReconciledFeatureRemoved$inboundSchema: z.ZodType<
+  ReconciledFeatureRemoved,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  featureId: z.string(),
+  featureKey: z.string(),
+});
+
+export function reconciledFeatureRemovedFromJSON(
+  jsonString: string,
+): SafeParseResult<ReconciledFeatureRemoved, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ReconciledFeatureRemoved$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ReconciledFeatureRemoved' from JSON`,
+  );
+}

package/src/models/reconciledfeatureskipped.ts

@@ -0,0 +1,33 @@
+/*
+ * 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";
+
+export type ReconciledFeatureSkipped = {
+  featureId: string;
+  featureKey: string;
+};
+
+/** @internal */
+export const ReconciledFeatureSkipped$inboundSchema: z.ZodType<
+  ReconciledFeatureSkipped,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  featureId: z.string(),
+  featureKey: z.string(),
+});
+
+export function reconciledFeatureSkippedFromJSON(
+  jsonString: string,
+): SafeParseResult<ReconciledFeatureSkipped, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ReconciledFeatureSkipped$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ReconciledFeatureSkipped' from JSON`,
+  );
+}

package/src/models/subscriptionreconciliation.ts

@@ -0,0 +1,144 @@
+/*
+ * 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 {
+  ReconciledFeatureAdded,
+  ReconciledFeatureAdded$inboundSchema,
+} from "./reconciledfeatureadded.js";
+import {
+  ReconciledFeatureFailed,
+  ReconciledFeatureFailed$inboundSchema,
+} from "./reconciledfeaturefailed.js";
+import {
+  ReconciledFeatureRemoved,
+  ReconciledFeatureRemoved$inboundSchema,
+} from "./reconciledfeatureremoved.js";
+import {
+  ReconciledFeatureSkipped,
+  ReconciledFeatureSkipped$inboundSchema,
+} from "./reconciledfeatureskipped.js";
+
+export const SubscriptionReconciliationObject = {
+  SubscriptionReconciliation: "subscriptionReconciliation",
+} as const;
+export type SubscriptionReconciliationObject = ClosedEnum<
+  typeof SubscriptionReconciliationObject
+>;
+
+export type Features = {
+  added: Array<ReconciledFeatureAdded>;
+  /**
+   * Features the subscription already had an active entitlement for — left unchanged.
+   */
+  skipped: Array<ReconciledFeatureSkipped>;
+  /**
+   * Features no longer on the plan: their entitlement was canceled and grants voided so the subscription matches the plan's current features.
+   */
+  removed: Array<ReconciledFeatureRemoved>;
+  /**
+   * Features that could not be fully provisioned. Never billed by this call.
+   */
+  failed: Array<ReconciledFeatureFailed>;
+};
+
+export type SubscriptionReconciliationLineItems = {
+  /**
+   * Number of features newly billed on the subscription by this reconciliation. A dry-run preview returns the same count as the applied run.
+   */
+  created: number;
+  /**
+   * Number of features whose billing was removed from the subscription's upcoming (not-yet-invoiced) invoice because their price is no longer on the plan.
+   */
+  removed: number;
+  /**
+   * True when entitlements were provisioned successfully but the line-item synchronization step failed. Safe to retry.
+   */
+  syncFailed?: boolean | undefined;
+};
+
+export type SubscriptionReconciliation = {
+  object: SubscriptionReconciliationObject;
+  /**
+   * True when this reconciliation was a preview — no entitlement, grant, or line item was created.
+   */
+  dryRun: boolean;
+  features: Features;
+  lineItems: SubscriptionReconciliationLineItems;
+};
+
+/** @internal */
+export const SubscriptionReconciliationObject$inboundSchema: z.ZodNativeEnum<
+  typeof SubscriptionReconciliationObject
+> = z.nativeEnum(SubscriptionReconciliationObject);
+
+/** @internal */
+export const Features$inboundSchema: z.ZodType<
+  Features,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  added: z.array(ReconciledFeatureAdded$inboundSchema),
+  skipped: z.array(ReconciledFeatureSkipped$inboundSchema),
+  removed: z.array(ReconciledFeatureRemoved$inboundSchema),
+  failed: z.array(ReconciledFeatureFailed$inboundSchema),
+});
+
+export function featuresFromJSON(
+  jsonString: string,
+): SafeParseResult<Features, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Features$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Features' from JSON`,
+  );
+}
+
+/** @internal */
+export const SubscriptionReconciliationLineItems$inboundSchema: z.ZodType<
+  SubscriptionReconciliationLineItems,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  created: z.number().int(),
+  removed: z.number().int(),
+  syncFailed: z.boolean().optional(),
+});
+
+export function subscriptionReconciliationLineItemsFromJSON(
+  jsonString: string,
+): SafeParseResult<SubscriptionReconciliationLineItems, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      SubscriptionReconciliationLineItems$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SubscriptionReconciliationLineItems' from JSON`,
+  );
+}
+
+/** @internal */
+export const SubscriptionReconciliation$inboundSchema: z.ZodType<
+  SubscriptionReconciliation,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  object: SubscriptionReconciliationObject$inboundSchema,
+  dryRun: z.boolean(),
+  features: z.lazy(() => Features$inboundSchema),
+  lineItems: z.lazy(() => SubscriptionReconciliationLineItems$inboundSchema),
+});
+
+export function subscriptionReconciliationFromJSON(
+  jsonString: string,
+): SafeParseResult<SubscriptionReconciliation, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SubscriptionReconciliation$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SubscriptionReconciliation' from JSON`,
+  );
+}

package/src/models/usageresponse.ts

@@ -22,6 +22,10 @@ export type WindowedValue = {
 export type GroupedValue = {
   groupBy: { [k: string]: string };
   value: number;
+  /**
+   * Number of raw events in this group
+   */
+  eventCount?: number | undefined;
 };
 
 export type UsageResponse = {
@@ -35,13 +39,17 @@ export type UsageResponse = {
    */
   totalValue: number;
   /**
-   * Time-bucketed values. Only present when windowSize is specified.
+   * Time-bucketed values. Only present when windowSize is specified. When both windowSize and groupBy are set, windowedValues[i] is index-aligned with groupedValues[i] (same window and group).
    */
   windowedValues?: Array<WindowedValue> | undefined;
   /**
-   * Dimension-grouped values. Only present when groupBy is specified.
+   * Dimension-grouped values. Only present when groupBy is specified. When both windowSize and groupBy are set, groupedValues[i] is index-aligned with windowedValues[i] (same window and group).
    */
   groupedValues?: Array<GroupedValue> | undefined;
+  /**
+   * Total distinct groups before groupLimit/groupOffset truncation. Only present when groupLimit is specified; use it to drive pagination totals.
+   */
+  groupCount?: number | undefined;
 };
 
 /** @internal */
@@ -80,6 +88,7 @@ export const GroupedValue$inboundSchema: z.ZodType<
 > = z.object({
   groupBy: z.record(z.string()),
   value: z.number(),
+  eventCount: z.number().int().optional(),
 });
 
 export function groupedValueFromJSON(
@@ -103,6 +112,7 @@ export const UsageResponse$inboundSchema: z.ZodType<
   totalValue: z.number(),
   windowedValues: z.array(z.lazy(() => WindowedValue$inboundSchema)).optional(),
   groupedValues: z.array(z.lazy(() => GroupedValue$inboundSchema)).optional(),
+  groupCount: z.number().int().optional(),
 });
 
 export function usageResponseFromJSON(

package/src/sdk/subscriptions.ts

@@ -6,6 +6,7 @@ import { subscriptionsCreate } from "../funcs/subscriptionsCreate.js";
 import { subscriptionsGeneratePortalLink } from "../funcs/subscriptionsGeneratePortalLink.js";
 import { subscriptionsGet } from "../funcs/subscriptionsGet.js";
 import { subscriptionsList } from "../funcs/subscriptionsList.js";
+import { subscriptionsReconcileSubscriptionFeatures } from "../funcs/subscriptionsReconcileSubscriptionFeatures.js";
 import { subscriptionsTerminate } from "../funcs/subscriptionsTerminate.js";
 import { subscriptionsUpdateSubscription } from "../funcs/subscriptionsUpdateSubscription.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
@@ -106,4 +107,21 @@ export class Subscriptions extends ClientSDK {
       options,
     ));
   }
+
+  /**
+   * Reconcile Features
+   *
+   * @remarks
+   * Creates a reconciliation that converges a subscription's feature entitlements to its current plan. Provisions a missing entitlement (and, for metered features, its initial grant) for every plan feature the subscription does not already have; cancels the entitlement and voids the grants of any feature no longer on the plan; then synchronizes the corresponding prices' billing. An already-present feature is left unchanged. Restricted to active subscriptions billed on their plan's line-item schedule.
+   */
+  async reconcileSubscriptionFeatures(
+    request: operations.ReconcileSubscriptionFeaturesRequest,
+    options?: RequestOptions,
+  ): Promise<models.SubscriptionReconciliation> {
+    return unwrapAsync(subscriptionsReconcileSubscriptionFeatures(
+      this,
+      request,
+      options,
+    ));
+  }
 }