@schematichq/schematic-typescript-node 1.5.13 → 1.6.1

package/README.md

@@ -800,13 +800,12 @@ const client = new SchematicClient({
 
 ## Credit Leases and Reservations
 
-For features metered by credit burndown (e.g. inference tokens), the SDK can enforce credit balances locally — without a Schematic API call on every check — using a lease-and-reservation system:
+For features metered by credit burndown (e.g. inference tokens), `check()` holds credits for the work about to run and `trackWithReservation()` settles the hold with actual usage. The SDK gates in one of two modes:
 
-- A **lease** is a tranche of credits acquired transactionally from Schematic's API. It functions as a hold against the company's credit balance until it is consumed, released, or expires.
-- A **reservation** is a client-side hold carved out of the lease at check time, sized to the upper bound of the operation's usage. This protects against races and over-spend between the check and the eventual usage report.
-- When the work completes, a track call reports actual usage; the difference between reserved and actual usage is refunded to the lease.
+- **Client mode** acquires a **lease**, a tranche of credits held against the company's balance, and carves a per-request **reservation** out of it locally, so a check needs no API call. It requires [DataStream](#datastream) (or [Replicator Mode](#replicator-mode)) and, across multiple processes, a shared Redis so every instance gates against the same lease.
+- **Server mode** makes one `check-and-reserve` API call per check. No lease, no Redis, no local state.
 
-> **Requirements:** Credit leases require [DataStream](#datastream) (or [Replicator Mode](#replicator-mode)) — lease-bearing checks are evaluated locally against cached flag and company state. In a horizontally-scaled deployment, a shared Redis backend is also required so that all SDK instances gate against the same lease balance; without one, lease state is per-process.
+`creditLeases.mode` defaults to `auto`: client when DataStream is enabled, server otherwise. Client mode suits high-throughput gating; server mode suits low-volume checks and operations that run for seconds.
 
 ### Setup
 
@@ -821,25 +820,35 @@ const client = new SchematicClient({
     apiKey: process.env.SCHEMATIC_API_KEY,
     useDataStream: true,
     dataStream: {
-        redisClient, // also backs lease + reservation state automatically
+        redisClient, // also backs lease + reservation state
     },
     creditLeases: {
-        defaultLeaseDuration: 5 * 60 * 1000, // lease lifetime (ms)
-        defaultReservationTTL: 60 * 1000, // how long a reservation is held if not settled by a track (ms)
         defaultLeaseSize: 10_000, // credits requested per lease
-        lowWaterMark: 0.25, // extend the lease in the background when its balance dips below this fraction
+        defaultLeaseDuration: 5 * 60 * 1000, // lease lifetime (ms)
+        defaultReservationTTL: 60 * 1000, // how long a reservation is held if no track settles it (ms)
     },
 });
 ```
 
-When `dataStream.redisClient` is configured, lease and reservation state automatically lives in the same Redis, with atomic reservations driven by Lua scripts — no additional configuration needed. To point lease state at a *different* Redis, set `creditLeases.redisClient` explicitly.
+Set `creditLeases.redisClient` to keep lease state in a different Redis than the DataStream cache.
 
-### Checking and tracking
+Server mode needs only a TTL:
 
-`check()` reserves the operation's upper-bound usage against the lease and returns a reservation handle; `trackWithReservation()` settles it with actual usage:
+```ts
+const client = new SchematicClient({
+    apiKey: process.env.SCHEMATIC_API_KEY,
+    creditLeases: {
+        defaultReservationTTL: 60 * 1000, // how long the server holds the credits if no track settles them (ms, max 1 hour)
+    },
+});
+```
+
+Only `mode` and `defaultReservationTTL` apply in server mode; the SDK warns at startup if a client-only option is set.
+
+### Checking and tracking
 
 ```ts
-// Per-request: reserve up to maxTokens against the lease.
+// Reserve up to maxTokens for this operation.
 const result = await client.check(
     { company: { id: "your-company-id" } },
     "inference",
@@ -854,15 +863,25 @@ if (!result.allowed) {
 
 const inference = await runInference(/* ... */);
 
-// Report actual usage; the unused slice of the reservation is refunded to the lease.
-await client.trackWithReservation(result.reservation!, inference.tokensUsed);
+// Report actual usage; the unused slice of the reservation is refunded.
+if (result.reservation) {
+    await client.trackWithReservation(result.reservation, inference.tokensUsed);
+} else {
+    await client.track({
+        event: "inference_tokens",
+        company: { id: "your-company-id" },
+        quantity: inference.tokensUsed,
+    });
+}
 ```
 
-If the caller never settles a reservation, it expires after `defaultReservationTTL` and its credits are returned to the lease. If the work outlives the reservation's TTL, `trackWithReservation` still bills the usage — the track event carries a deterministic idempotency key, so duplicate or recovery emits never double-bill. However, the local lease balance is not re-debited on that late settle (the expired reservation's hold was already swept back to the lease), so it reads high until the lease rolls over. **Set `defaultReservationTTL` above the longest expected gap between `check()` and `trackWithReservation()`** to keep the local balance accurate.
+A check can allow without taking a hold (the feature is not credit-metered, `usage` is 0, or the check failed open), and that usage still has to be tracked.
+
+An unsettled reservation expires after `defaultReservationTTL` and its credits return to the lease. A late settle still bills the usage (the track event carries a deterministic idempotency key, so it never double-bills) but does not re-debit the local lease, so set `defaultReservationTTL` above the longest expected gap between `check()` and `trackWithReservation()`.
 
 ### Pre-warming
 
-To avoid paying the lease-acquire round trip on a session's first check, pre-warm leases when the user is identified:
+Pre-warm leases when the user is identified, so a session's first check does not wait on a lease acquire:
 
 ```ts
 await client.identify(
@@ -874,11 +893,11 @@ await client.identify(
 );
 ```
 
-Or call `client.prewarm(evalCtx, creditTypeIds)` directly.
+Or call `client.prewarm(evalCtx, creditTypeIds)` directly. Both are no-ops in server mode.
 
 ### Failure behavior
 
-By default, a check that cannot be gated (API unreachable, Redis down, lease exhausted) **fails closed** (`allowed: false`). Override per check for callers where letting traffic through is preferable to a denial:
+A check that cannot be gated (API unreachable, Redis down, lease exhausted) fails closed by default. Override per check:
 
 ```ts
 const result = await client.check(evalCtx, "inference", {
@@ -888,20 +907,22 @@ const result = await client.check(evalCtx, "inference", {
 });
 ```
 
-`fail-open` does not skip evaluation: the flag's rules still run with the credit balance assumed sufficient, so plan targeting, overrides, and all non-credit conditions still apply — only the credit gate is bypassed.
+In client mode, `fail-open` still evaluates the flag's rules with the credit balance assumed sufficient, so plan targeting and all non-credit conditions apply and only the credit gate is bypassed. In server mode it returns the flag's default value, which is `false` unless you pass `defaultValue` or configure a `flagDefaults` entry.
 
 ### Configuration options
 
 | Option | Type | Default | Description |
 |---|---|---|---|
-| `defaultLeaseDuration` | `number` | 5 minutes | Lease lifetime in milliseconds |
-| `defaultReservationTTL` | `number` | 60 seconds | How long an unsettled reservation is held (ms); set above your longest expected work duration |
-| `defaultLeaseSize` | `number` | 10000 | Credits requested per lease acquire/extend |
-| `lowWaterMark` | `number` | 0.25 | Extend in the background when the lease balance dips below this fraction |
-| `sweepIntervalMs` | `number` | 1000 | Sweep interval for expired reservations (ms) |
-| `redisClient` | `RedisClient` | `dataStream.redisClient` | Redis client for lease + reservation state |
-| `redisKeyPrefix` | `string` | `dataStream.redisKeyPrefix` | Key prefix for lease + reservation keys |
-| `overrides` | `object` | — | Per-credit-type overrides of the above (keyed by credit type ID) |
+| `mode` | `"client" \| "server" \| "auto"` | `auto` | Where the credit hold lives; `auto` picks client when DataStream is enabled, server otherwise |
+| `defaultReservationTTL` | `number` | 60 seconds | How long an unsettled reservation is held (ms) |
+| `defaultLeaseDuration` | `number` | 5 minutes | (client mode) Lease lifetime (ms) |
+| `defaultLeaseSize` | `number` | 10000 | (client mode) Credits requested per lease acquire or extend |
+| `lowWaterMark` | `number` | 0.25 | (client mode) Extend in the background when the lease balance dips below this fraction |
+| `sweepIntervalMs` | `number` | 1000 | (client mode) Sweep interval for expired reservations (ms) |
+| `prewarmResolveTimeoutMs` | `number` | 5000 | (client mode) How long `prewarm()` waits for a freshly identified company to surface (ms) |
+| `redisClient` | `RedisClient` | `dataStream.redisClient` | (client mode) Redis client for lease and reservation state |
+| `redisKeyPrefix` | `string` | `dataStream.redisKeyPrefix` | (client mode) Key prefix for lease and reservation keys |
+| `overrides` | `object` | — | (client mode) Per-credit-type overrides of the above, keyed by credit type ID |
 
 ## Testing
 

package/dist/api/resources/credits/client/Client.d.ts

@@ -447,7 +447,6 @@ export declare class CreditsClient {
     private __extendCreditLease;
     /**
      * @param {string} lease_id - lease_id
-     * @param {Schematic.ReleaseCreditLeaseRequestBody} request
      * @param {CreditsClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Schematic.BadRequestError}
@@ -459,11 +458,9 @@ export declare class CreditsClient {
      * @throws {@link errors.SchematicTimeoutError}
      *
      * @example
-     *     await client.credits.releaseCreditLease("lease_id", {
-     *         "key": "value"
-     *     })
+     *     await client.credits.releaseCreditLease("lease_id")
      */
-    releaseCreditLease(lease_id: string, request: Schematic.ReleaseCreditLeaseRequestBody, requestOptions?: CreditsClient.RequestOptions): core.HttpResponsePromise<Schematic.ReleaseCreditLeaseResponse>;
+    releaseCreditLease(lease_id: string, requestOptions?: CreditsClient.RequestOptions): core.HttpResponsePromise<Schematic.ReleaseCreditLeaseResponse>;
     private __releaseCreditLease;
     /**
      * @param {Schematic.ListBillingPlanCreditGrantsRequest} request
@@ -597,6 +594,45 @@ export declare class CreditsClient {
      */
     countBillingPlanCreditGrants(request?: Schematic.CountBillingPlanCreditGrantsRequest, requestOptions?: CreditsClient.RequestOptions): core.HttpResponsePromise<Schematic.CountBillingPlanCreditGrantsResponse>;
     private __countBillingPlanCreditGrants;
+    /**
+     * @param {Schematic.ReserveCreditsRequestBody} request
+     * @param {CreditsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Schematic.BadRequestError}
+     * @throws {@link Schematic.UnauthorizedError}
+     * @throws {@link Schematic.PaymentRequiredError}
+     * @throws {@link Schematic.ForbiddenError}
+     * @throws {@link Schematic.NotFoundError}
+     * @throws {@link Schematic.InternalServerError}
+     * @throws {@link errors.SchematicError}
+     * @throws {@link errors.SchematicTimeoutError}
+     *
+     * @example
+     *     await client.credits.reserveCredits({
+     *         amount: 1.1,
+     *         companyId: "company_id",
+     *         creditTypeId: "credit_type_id"
+     *     })
+     */
+    reserveCredits(request: Schematic.ReserveCreditsRequestBody, requestOptions?: CreditsClient.RequestOptions): core.HttpResponsePromise<Schematic.ReserveCreditsResponse>;
+    private __reserveCredits;
+    /**
+     * @param {string} reservation_id - reservation_id
+     * @param {CreditsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Schematic.BadRequestError}
+     * @throws {@link Schematic.UnauthorizedError}
+     * @throws {@link Schematic.ForbiddenError}
+     * @throws {@link Schematic.NotFoundError}
+     * @throws {@link Schematic.InternalServerError}
+     * @throws {@link errors.SchematicError}
+     * @throws {@link errors.SchematicTimeoutError}
+     *
+     * @example
+     *     await client.credits.releaseCreditReservation("reservation_id")
+     */
+    releaseCreditReservation(reservation_id: string, requestOptions?: CreditsClient.RequestOptions): core.HttpResponsePromise<Schematic.ReleaseCreditReservationResponse>;
+    private __releaseCreditReservation;
     /**
      * @param {Schematic.ListCreditSpendPoliciesRequest} request
      * @param {CreditsClient.RequestOptions} requestOptions - Request-specific configuration.

package/dist/api/resources/credits/client/requests/ReserveCreditsRequestBody.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @example
+ *     {
+ *         amount: 1.1,
+ *         companyId: "company_id",
+ *         creditTypeId: "credit_type_id"
+ *     }
+ */
+export interface ReserveCreditsRequestBody {
+    /** Credits to hold for the operation. The full amount must be available; a partial hold is never taken */
+    amount: number;
+    companyId: string;
+    creditTypeId: string;
+    /** When the hold lapses if no track event settles it; defaults to one minute from now and may be at most one hour out. The unspent hold is refunded on expiry */
+    expiresAt?: Date;
+    /** A caller-chosen key for safe retries: a second request with the same key returns the original reservation instead of taking another hold */
+    idempotencyKey?: string;
+}

package/dist/api/resources/credits/client/requests/index.d.ts

@@ -20,6 +20,7 @@ export type { ListCreditBundlesRequest } from "./ListCreditBundlesRequest";
 export type { ListCreditEventLedgerRequest } from "./ListCreditEventLedgerRequest";
 export type { ListCreditSpendPoliciesRequest } from "./ListCreditSpendPoliciesRequest";
 export type { ListGrantsForCreditRequest } from "./ListGrantsForCreditRequest";
+export type { ReserveCreditsRequestBody } from "./ReserveCreditsRequestBody";
 export type { UpdateBillingCreditRequestBody } from "./UpdateBillingCreditRequestBody";
 export type { UpdateCreditBundleDetailsRequestBody } from "./UpdateCreditBundleDetailsRequestBody";
 export type { UpdateCreditSpendPolicyRequestBody } from "./UpdateCreditSpendPolicyRequestBody";

package/dist/api/resources/credits/types/ReleaseCreditReservationResponse.d.ts

@@ -0,0 +1,6 @@
+import type * as Schematic from "../../../index";
+export interface ReleaseCreditReservationResponse {
+    data: Schematic.CreditReservationResponseData;
+    /** Input parameters */
+    params: Record<string, unknown>;
+}

package/dist/api/resources/credits/types/ReserveCreditsResponse.d.ts

@@ -0,0 +1,6 @@
+import type * as Schematic from "../../../index";
+export interface ReserveCreditsResponse {
+    data: Schematic.CreditReservationResponseData;
+    /** Input parameters */
+    params: Record<string, unknown>;
+}

package/dist/api/resources/credits/types/index.d.ts

@@ -44,6 +44,8 @@ export * from "./ListCreditSpendPoliciesResponse";
 export * from "./ListGrantsForCreditParams";
 export * from "./ListGrantsForCreditResponse";
 export * from "./ReleaseCreditLeaseResponse";
+export * from "./ReleaseCreditReservationResponse";
+export * from "./ReserveCreditsResponse";
 export * from "./SoftDeleteBillingCreditResponse";
 export * from "./UpdateBillingCreditResponse";
 export * from "./UpdateBillingPlanCreditGrantResponse";

package/dist/api/resources/features/client/Client.d.ts

@@ -318,6 +318,24 @@ export declare class FeaturesClient {
      */
     checkFlag(key: string, request: Schematic.CheckFlagRequestBody, requestOptions?: FeaturesClient.RequestOptions): core.HttpResponsePromise<Schematic.CheckFlagResponse>;
     private __checkFlag;
+    /**
+     * @param {string} key - key
+     * @param {Schematic.CheckAndReserveFlagRequestBody} request
+     * @param {FeaturesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Schematic.BadRequestError}
+     * @throws {@link Schematic.UnauthorizedError}
+     * @throws {@link Schematic.ForbiddenError}
+     * @throws {@link Schematic.NotFoundError}
+     * @throws {@link Schematic.InternalServerError}
+     * @throws {@link errors.SchematicError}
+     * @throws {@link errors.SchematicTimeoutError}
+     *
+     * @example
+     *     await client.features.checkAndReserveFlag("key")
+     */
+    checkAndReserveFlag(key: string, request?: Schematic.CheckAndReserveFlagRequestBody, requestOptions?: FeaturesClient.RequestOptions): core.HttpResponsePromise<Schematic.CheckAndReserveFlagResponse>;
+    private __checkAndReserveFlag;
     /**
      * @param {Schematic.CheckFlagRequestBody} request
      * @param {FeaturesClient.RequestOptions} requestOptions - Request-specific configuration.

package/dist/api/resources/features/client/requests/CheckAndReserveFlagRequestBody.d.ts

@@ -0,0 +1,15 @@
+import type * as Schematic from "../../../../index";
+/**
+ * @example
+ *     {}
+ */
+export interface CheckAndReserveFlagRequestBody {
+    company?: Record<string, string>;
+    /** When the hold lapses if no track event settles it; defaults to one minute from now and may be at most one hour out. The unspent hold is refunded on expiry */
+    expiresAt?: Date;
+    /** Hypothetical usage to evaluate the flag against. When credit_cost names the entitlement's credit, that cost is what gets held; otherwise the hold is quantity times the entitlement's consumption rate */
+    preflight?: Schematic.PreflightRequestBody;
+    /** Units of the feature the operation will consume; defaults to 1. Sets the hold size together with the entitlement's consumption rate, and is echoed back on the reservation for the settling track event */
+    quantity?: number;
+    user?: Record<string, string>;
+}

package/dist/api/resources/features/client/requests/index.d.ts

@@ -1,3 +1,4 @@
+export type { CheckAndReserveFlagRequestBody } from "./CheckAndReserveFlagRequestBody";
 export type { CheckFlagsBulkRequestBody } from "./CheckFlagsBulkRequestBody";
 export type { CountFeaturesRequest } from "./CountFeaturesRequest";
 export type { CountFlagsRequest } from "./CountFlagsRequest";

package/dist/api/resources/features/types/CheckAndReserveFlagResponse.d.ts

@@ -0,0 +1,6 @@
+import type * as Schematic from "../../../index";
+export interface CheckAndReserveFlagResponse {
+    data: Schematic.CheckAndReserveFlagResponseData;
+    /** Input parameters */
+    params: Record<string, unknown>;
+}

package/dist/api/resources/features/types/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./CheckAndReserveFlagResponse";
 export * from "./CheckFlagResponse";
 export * from "./CheckFlagsBulkResponse";
 export * from "./CheckFlagsResponse";

package/dist/api/resources/planmigrations/client/Client.d.ts

@@ -87,13 +87,14 @@ export declare class PlanmigrationsClient {
      *
      * @example
      *     await client.planmigrations.listMigrations({
+     *         featureId: "feature_id",
      *         planVersionId: "plan_version_id",
      *         status: "cancelled",
      *         limit: 1000000,
      *         offset: 1000000
      *     })
      */
-    listMigrations(request: Schematic.ListMigrationsRequest, requestOptions?: PlanmigrationsClient.RequestOptions): core.HttpResponsePromise<Schematic.ListMigrationsResponse>;
+    listMigrations(request?: Schematic.ListMigrationsRequest, requestOptions?: PlanmigrationsClient.RequestOptions): core.HttpResponsePromise<Schematic.ListMigrationsResponse>;
     private __listMigrations;
     /**
      * @param {Schematic.CreateMigrationInput} request
@@ -202,13 +203,14 @@ export declare class PlanmigrationsClient {
      *
      * @example
      *     await client.planmigrations.countMigrations({
+     *         featureId: "feature_id",
      *         planVersionId: "plan_version_id",
      *         status: "cancelled",
      *         limit: 1000000,
      *         offset: 1000000
      *     })
      */
-    countMigrations(request: Schematic.CountMigrationsRequest, requestOptions?: PlanmigrationsClient.RequestOptions): core.HttpResponsePromise<Schematic.CountMigrationsResponse>;
+    countMigrations(request?: Schematic.CountMigrationsRequest, requestOptions?: PlanmigrationsClient.RequestOptions): core.HttpResponsePromise<Schematic.CountMigrationsResponse>;
     private __countMigrations;
     /**
      * @param {Schematic.PreviewMigrationRequestBody} request

package/dist/api/resources/planmigrations/client/requests/CountMigrationsRequest.d.ts

@@ -2,6 +2,7 @@ import type * as Schematic from "../../../../index";
 /**
  * @example
  *     {
+ *         featureId: "feature_id",
  *         planVersionId: "plan_version_id",
  *         status: "cancelled",
  *         limit: 1000000,
@@ -9,7 +10,8 @@ import type * as Schematic from "../../../../index";
  *     }
  */
 export interface CountMigrationsRequest {
-    planVersionId: string;
+    featureId?: string;
+    planVersionId?: string;
     status?: Schematic.PlanVersionMigrationStatus;
     /** Page limit (default 100) */
     limit?: number;

package/dist/api/resources/planmigrations/client/requests/ListMigrationsRequest.d.ts

@@ -2,6 +2,7 @@ import type * as Schematic from "../../../../index";
 /**
  * @example
  *     {
+ *         featureId: "feature_id",
  *         planVersionId: "plan_version_id",
  *         status: "cancelled",
  *         limit: 1000000,
@@ -9,7 +10,8 @@ import type * as Schematic from "../../../../index";
  *     }
  */
 export interface ListMigrationsRequest {
-    planVersionId: string;
+    featureId?: string;
+    planVersionId?: string;
     status?: Schematic.PlanVersionMigrationStatus;
     /** Page limit (default 100) */
     limit?: number;

package/dist/api/resources/planmigrations/types/CountMigrationsParams.d.ts

@@ -3,6 +3,7 @@ import type * as Schematic from "../../../index";
  * Input parameters
  */
 export interface CountMigrationsParams {
+    featureId?: string;
     /** Page limit (default 100) */
     limit?: number;
     /** Page offset (default 0) */

package/dist/api/resources/planmigrations/types/ListMigrationsParams.d.ts

@@ -3,6 +3,7 @@ import type * as Schematic from "../../../index";
  * Input parameters
  */
 export interface ListMigrationsParams {
+    featureId?: string;
     /** Page limit (default 100) */
     limit?: number;
     /** Page offset (default 0) */

package/dist/api/resources/plans/client/Client.d.ts

@@ -143,6 +143,8 @@ export declare class PlansClient {
      *         q: "q",
      *         scopedToCompanyId: "scoped_to_company_id",
      *         withEntitlements: true,
+     *         withPublishedVersion: true,
+     *         withoutEntitlementForIncludeDrafts: true,
      *         withoutEntitlementFor: "without_entitlement_for",
      *         withoutPaidProductId: true,
      *         limit: 1000000,
@@ -342,6 +344,8 @@ export declare class PlansClient {
      *         q: "q",
      *         scopedToCompanyId: "scoped_to_company_id",
      *         withEntitlements: true,
+     *         withPublishedVersion: true,
+     *         withoutEntitlementForIncludeDrafts: true,
      *         withoutEntitlementFor: "without_entitlement_for",
      *         withoutPaidProductId: true,
      *         limit: 1000000,

package/dist/api/resources/plans/client/requests/CountPlansRequest.d.ts

@@ -16,6 +16,8 @@ import type * as Schematic from "../../../../index";
  *         q: "q",
  *         scopedToCompanyId: "scoped_to_company_id",
  *         withEntitlements: true,
+ *         withPublishedVersion: true,
+ *         withoutEntitlementForIncludeDrafts: true,
  *         withoutEntitlementFor: "without_entitlement_for",
  *         withoutPaidProductId: true,
  *         limit: 1000000,
@@ -48,6 +50,10 @@ export interface CountPlansRequest {
     scopedToCompanyId?: string;
     /** Include each plan's entitlements in the response */
     withEntitlements?: boolean;
+    /** Only return plans that have a published version */
+    withPublishedVersion?: boolean;
+    /** With without_entitlement_for, also treat an entitlement on a plan's draft version as existing */
+    withoutEntitlementForIncludeDrafts?: boolean;
     /** Filter out plans that already have a plan entitlement for the specified feature ID */
     withoutEntitlementFor?: string;
     /** Filter out plans that have a paid billing product ID */

package/dist/api/resources/plans/client/requests/ListPlansRequest.d.ts

@@ -16,6 +16,8 @@ import type * as Schematic from "../../../../index";
  *         q: "q",
  *         scopedToCompanyId: "scoped_to_company_id",
  *         withEntitlements: true,
+ *         withPublishedVersion: true,
+ *         withoutEntitlementForIncludeDrafts: true,
  *         withoutEntitlementFor: "without_entitlement_for",
  *         withoutPaidProductId: true,
  *         limit: 1000000,
@@ -48,6 +50,10 @@ export interface ListPlansRequest {
     scopedToCompanyId?: string;
     /** Include each plan's entitlements in the response */
     withEntitlements?: boolean;
+    /** Only return plans that have a published version */
+    withPublishedVersion?: boolean;
+    /** With without_entitlement_for, also treat an entitlement on a plan's draft version as existing */
+    withoutEntitlementForIncludeDrafts?: boolean;
     /** Filter out plans that already have a plan entitlement for the specified feature ID */
     withoutEntitlementFor?: string;
     /** Filter out plans that have a paid billing product ID */

package/dist/api/resources/plans/types/CountPlansParams.d.ts

@@ -32,8 +32,12 @@ export interface CountPlansParams {
     scopedToCompanyId?: string;
     /** Include each plan's entitlements in the response */
     withEntitlements?: boolean;
+    /** Only return plans that have a published version */
+    withPublishedVersion?: boolean;
     /** Filter out plans that already have a plan entitlement for the specified feature ID */
     withoutEntitlementFor?: string;
+    /** With without_entitlement_for, also treat an entitlement on a plan's draft version as existing */
+    withoutEntitlementForIncludeDrafts?: boolean;
     /** Filter out plans that have a paid billing product ID */
     withoutPaidProductId?: boolean;
 }

package/dist/api/resources/plans/types/ListPlansParams.d.ts

@@ -32,8 +32,12 @@ export interface ListPlansParams {
     scopedToCompanyId?: string;
     /** Include each plan's entitlements in the response */
     withEntitlements?: boolean;
+    /** Only return plans that have a published version */
+    withPublishedVersion?: boolean;
     /** Filter out plans that already have a plan entitlement for the specified feature ID */
     withoutEntitlementFor?: string;
+    /** With without_entitlement_for, also treat an entitlement on a plan's draft version as existing */
+    withoutEntitlementForIncludeDrafts?: boolean;
     /** Filter out plans that have a paid billing product ID */
     withoutPaidProductId?: boolean;
 }

package/dist/api/types/CheckAndReserveFlagResponseData.d.ts

@@ -0,0 +1,35 @@
+import type * as Schematic from "../index";
+export interface CheckAndReserveFlagResponseData {
+    /** If company keys were provided and matched a company, its ID */
+    companyId?: string;
+    /** If a feature entitlement rule was matched, its entitlement details */
+    entitlement?: Schematic.FeatureEntitlement;
+    /** If an error occurred while checking the flag, the error message */
+    error?: string;
+    /** Deprecated: Use Entitlement.Allocation instead. */
+    featureAllocation?: number;
+    /** Deprecated: Use Entitlement.Usage instead. */
+    featureUsage?: number;
+    /** Deprecated: Use Entitlement.EventName instead. */
+    featureUsageEvent?: string;
+    /** Deprecated: Use Entitlement.MetricPeriod instead. */
+    featureUsagePeriod?: Schematic.MetricPeriod;
+    /** Deprecated: Use Entitlement.MetricResetAt instead. */
+    featureUsageResetAt?: Date;
+    /** The key used to check the flag */
+    flag: string;
+    /** If a flag was found, its ID */
+    flagId?: string;
+    /** A human-readable explanation of the result */
+    reason: string;
+    /** The hold taken on the company's credit balance for this operation, when the flag allowed it and the feature is credit-metered. Settle it by sending a track event carrying its ID as reservation_id; the unspent hold is refunded at expires_at otherwise */
+    reservation?: Schematic.FlagCheckReservationResponseData;
+    /** If a rule was found, its ID */
+    ruleId?: string;
+    /** If a rule was found, its type */
+    ruleType?: Schematic.RuleType;
+    /** If user keys were provided and matched a user, its ID */
+    userId?: string;
+    /** A boolean flag check result; for feature entitlements, this represents whether further consumption of the feature is permitted */
+    value: boolean;
+}

package/dist/api/types/CreditReservationResponseData.d.ts

@@ -0,0 +1,15 @@
+export interface CreditReservationResponseData {
+    companyId: string;
+    createdAt: Date;
+    creditTypeId: string;
+    /** When the unspent hold is refunded if no track event settles it */
+    expiresAt: Date;
+    id: string;
+    /** When the reservation was settled, released, or expired; null while the hold is open */
+    releasedAt?: Date;
+    /** Credits held from the company's balance for the operation */
+    reservedAmount: number;
+    /** Credits the settling track event recorded against the hold; zero until settled. May exceed reserved_amount, in which case the overage was debited from the balance, up to the overdraft limit when one is set */
+    settledAmount: number;
+    updatedAt: Date;
+}

package/dist/api/types/CreditUsageReason.d.ts

@@ -3,6 +3,8 @@ export declare const CreditUsageReason: {
     readonly LeaseRelease: "lease_release";
     readonly ManualAdjustment: "manual_adjustment";
     readonly Reconciliation: "reconciliation";
+    readonly ReservationHold: "reservation_hold";
+    readonly ReservationRelease: "reservation_release";
     readonly Track: "track";
 };
 export type CreditUsageReason = (typeof CreditUsageReason)[keyof typeof CreditUsageReason];

package/dist/api/types/EventBodyTrack.d.ts

@@ -7,6 +7,8 @@ export interface EventBodyTrack {
     leaseId?: string;
     /** Optionally specify the quantity of the event */
     quantity?: number;
+    /** Credit reservation ID this track event settles. lease_id takes precedence when both are set */
+    reservationId?: string;
     /** A map of trait names to trait values */
     traits?: Record<string, unknown>;
     /** Key-value pairs to identify user associated with track event */

package/dist/api/types/EventDetailResponseData.d.ts

@@ -18,6 +18,7 @@ export interface EventDetailResponseData {
     loadedAt?: Date;
     processedAt?: Date;
     quantity: number;
+    reservationId?: string;
     sentAt?: Date;
     status: Schematic.EventStatus;
     subtype?: string;

package/dist/api/types/EventResponseData.d.ts

@@ -15,6 +15,7 @@ export interface EventResponseData {
     loadedAt?: Date;
     processedAt?: Date;
     quantity: number;
+    reservationId?: string;
     sentAt?: Date;
     status: Schematic.EventStatus;
     subtype?: string;

package/dist/api/types/FlagCheckReservationResponseData.d.ts

@@ -0,0 +1,15 @@
+export interface FlagCheckReservationResponseData {
+    companyId: string;
+    /** Credits per unit of usage the hold was priced at */
+    consumptionRate: number;
+    creditTypeId: string;
+    /** Credits held from the company's balance */
+    creditsReserved: number;
+    /** The event subtype the settling track event should carry */
+    eventSubtype?: string;
+    /** When the unspent hold is refunded if no track event settles it */
+    expiresAt: Date;
+    id: string;
+    /** Units of usage the hold covers, as requested */
+    quantityReserved: number;
+}

package/dist/api/types/PlanVersionMigrationResponseData.d.ts

@@ -5,6 +5,8 @@ export interface PlanVersionMigrationResponseData {
     createdAt: Date;
     error?: string;
     failedCompanies: number;
+    featureId?: string;
+    featurePlanRolloutId?: string;
     id: string;
     nextDueAt?: Date;
     planId: string;