@clocknext/sdk 0.15.0 → 0.16.0

package/dist/index.d.cts

@@ -15,12 +15,15 @@ type SignalStatus = "SUCCESS" | "FAILURE" | "PENDING";
 /**
  * Token counts for a signal. `input` and `output` are required — every metered
  * call has them, and the server requires them. `cache` (provider-specific
- * prompt-cache reads) is optional and defaults to 0 server-side when omitted.
+ * prompt-cache reads) and `cacheWrite` (tokens written into the prompt cache,
+ * priced at the model's separate cache-write rate) are optional and default to
+ * 0 server-side when omitted.
  */
 interface Tokens {
     input: number;
     output: number;
     cache?: number;
+    cacheWrite?: number;
 }
 /**
  * Groups a signal into one occurrence of a **composite** — a bundle of credits
@@ -239,7 +242,10 @@ interface SerializedUsageLog {
     member: string | null;
     inputTokens: number;
     outputTokens: number;
+    /** Cache-read tokens. */
     cacheTokens: number;
+    /** Cache-write tokens, priced separately from cache reads. */
+    cacheWriteTokens: number;
     /** Total credits deducted: the call's real per-model provider cost as a
      *  fraction of the credit's base price (i.e. cost + your margin), plus any
      *  credit-rule add-ons; 0 for wallet-money calls. */
@@ -392,7 +398,10 @@ interface UsageLogEntry {
     usage: {
         inputTokens: number;
         outputTokens: number;
+        /** Cache-read tokens. */
         cacheTokens: number;
+        /** Cache-write tokens, priced separately from cache reads. */
+        cacheWriteTokens: number;
     };
     /** Formatted USD strings (e.g. `"$0.0064"`). */
     cost: {
@@ -527,8 +536,25 @@ interface UnitBalance {
     granted: number;
     remaining: number;
 }
-/** Wallet / credit / outcome / unit balances for a customer's active plan
- *  (`customers.balances()`). */
+/** One prepaid (ADVANCE) composite pool on a customer's plan. */
+interface CompositeBalance {
+    compositeId: string;
+    /** The tag signals send in their `composite` block. */
+    refId: string;
+    name: string;
+    /** The pool size the plan grants this cycle. */
+    granted: number;
+    /** Slots claimed this cycle — one per distinct tag value. */
+    used: number;
+    /** `granted - used` plus this cycle's manual adjustments. May be negative:
+     *  running past the pool is allowed and carries into the next cycle. */
+    remaining: number;
+    /** What `granted` was before the pool was ever resized for this customer;
+     *  `null` if it never was. */
+    originalGranted: number | null;
+}
+/** Wallet / credit / outcome / unit balances and composite pools for a
+ *  customer's active plan (`customers.balances()`). */
 interface CustomerBalances {
     customerId: string;
     currency: {
@@ -536,18 +562,21 @@ interface CustomerBalances {
         rateUsd: number;
     };
     hasPlan: boolean;
-    /** `null` when the plan has no Wallet component. */
+    /** Both wallet balances, in USD. Always present. */
     wallet: {
-        balanceUsd: number;
-    } | null;
-    /** The Reserved Wallet; `null` when the org hasn't enabled it. Independent
-     *  of `wallet` — present whether or not the plan has a Wallet. */
-    reservedWallet: {
-        balanceUsd: number;
-    } | null;
+        /** The ordinary wallet — always reported, also when the plan has no
+         *  Wallet component or there's no plan. May be negative. */
+        balance: number;
+        /** The Reserved Wallet; absent when the org hasn't enabled it, otherwise
+         *  present whether or not the plan has a Wallet. Never negative. */
+        reservedBalance?: number;
+    };
     credits: CreditBalance[];
     outcomes: OutcomeBalance[];
     units: UnitBalance[];
+    /** ADVANCE composite pools. A composite billed in ARREAR has no pool and
+     *  isn't listed. */
+    composites: CompositeBalance[];
 }
 /** The customer's active plan (the `plan` field of `customers.plan()`);
  *  `null` when the customer is unsubscribed. */
@@ -591,8 +620,8 @@ interface PortalToken {
     /** Seconds until expiry. */
     expiresIn: number;
 }
-/** How often a plan bills. `FREE` is a one-time grant; `EVERY_5_MIN` is a test cadence. */
-type BillingCycle = "MONTHLY" | "QUARTERLY" | "SEMI_ANNUAL" | "YEARLY" | "EVERY_5_MIN" | "FREE";
+/** How often a plan bills. `FREE` is a one-time grant. */
+type BillingCycle = "MONTHLY" | "QUARTERLY" | "SEMI_ANNUAL" | "YEARLY" | "FREE";
 type PlanType = "WALLET" | "BUNDLE";
 type PlanKind = "FLAT_PRICE" | "PAY_AS_YOU_GO" | "PAY_PER_SEAT";
 /**
@@ -606,7 +635,8 @@ type PlanKind = "FLAT_PRICE" | "PAY_AS_YOU_GO" | "PAY_PER_SEAT";
 type ComponentType = "WALLET" | "CREDIT" | "OUTCOME" | "UNIT" | "FLAT" | "PRICING_METRIC";
 /** ADVANCE bills up-front for the cycle; ARREAR bills for what was consumed. */
 type BillingMode = "ADVANCE" | "ARREAR";
-interface PlanComponent {
+/** One line of a plan (`plan.entitlements[]`). */
+interface PlanEntitlement {
     id: string;
     type: ComponentType;
     billingMode: BillingMode;
@@ -619,13 +649,17 @@ interface PlanComponent {
     targetName: string | null;
     quantity: number | null;
     amount: number | null;
+    /** ADVANCE credit / outcome / composite / wallet components: what's left at
+     *  the end of a cycle carries into the next one instead of resetting.
+     *  Always false for unit, flat and ARREAR components and on FREE plans. */
+    rollover: boolean;
 }
+/** @deprecated Renamed to {@link PlanEntitlement} — a plan's lines are `entitlements` now. */
+type PlanComponent = PlanEntitlement;
 interface Plan {
     id: string;
     name: string;
     description: string | null;
-    type: PlanType;
-    kind: PlanKind;
     billingCycle: BillingCycle;
     cost: number;
     /** Signed adjustment applied to the plan's headline price (default 0). */
@@ -633,10 +667,254 @@ interface Plan {
     /** When true, ARREAR consumption is funded from the customer's wallet as it
      *  happens instead of being invoiced at cycle end. All-or-nothing per plan. */
     walletFundedArrear: boolean;
+    /** The workspace's primary currency when the plan was created. */
     currencyCode: string;
     isActive: boolean;
-    components: PlanComponent[];
+    createdAt: string;
+    updatedAt: string;
+    /** The plan's lines — what a customer on it is granted or metered for. */
+    entitlements: PlanEntitlement[];
+}
+/** One line of a plan, as you send it to `plans.create()` / `plans.update()`.
+ *  Set the id that matches `type`: `creditId` (CREDIT), `outcomeId`
+ *  (OUTCOME), `unitId` (UNIT) or `compositeId` (PRICING_METRIC — a
+ *  composite). The lines `plans.get()` returns can be sent back as they are. */
+interface PlanEntitlementInput {
+    type: ComponentType;
+    billingMode: BillingMode;
+    creditId?: string | null;
+    outcomeId?: string | null;
+    unitId?: string | null;
+    compositeId?: string | null;
+    /** ADVANCE credit / outcome / unit / composite: granted each cycle (0 allowed). */
+    quantity?: number | null;
+    /** WALLET (ADVANCE prepaid balance, $0 allowed) or FLAT (fee, above $0), in USD. */
+    amount?: number | null;
+    /** ADVANCE credit / outcome / composite / wallet: carry leftovers into the next cycle. */
+    rollover?: boolean;
+}
+/** `plans.create()` body. The plan's currency is the workspace's primary
+ *  currency — it can't be chosen. A new plan is active; retire it with
+ *  `plans.archive()`. */
+interface CreatePlanInput {
+    name: string;
+    billingCycle: BillingCycle;
+    description?: string | null;
+    /** Pay ARREAR usage from the prepaid wallet as it happens. Needs an ADVANCE
+     *  WALLET line and at least one ARREAR credit / outcome / unit / composite. */
+    walletFundedArrear?: boolean;
+    /** Signed rounding nudge (USD) on the due-at-purchase total. */
+    priceAdjustment?: number;
+    /** At least one line. At most one WALLET and one FLAT. */
+    entitlements: PlanEntitlementInput[];
+}
+/** `plans.update()` body — a PARTIAL update: only the fields you send change.
+ *  `entitlements`, when sent, is the complete new list. */
+type UpdatePlanInput = Partial<CreatePlanInput>;
+/** One model line of a credit's / outcome step's pricing bundle, as returned. */
+interface ModelBundleLine {
+    /** The workspace's model row id (`id` from the Models API). */
+    orgModelId: string;
+    /** The model's display name, filled in by the server. */
+    modelName: string;
+    /** Average tokens one LLM call uses on this model. */
+    averageTokensPerLLMCall: number;
+    /** Whole-percent split of those tokens; the four add up to 100. */
+    input: number;
+    output: number;
+    cache: number;
+    /** 0 on a model with no cache-write price. */
+    cacheWrite: number;
+}
+/** One model line as you send it. Several lines (one per model) are allowed;
+ *  the price is the sum of their costs, worked out on the server from the
+ *  models' live prices. */
+interface ModelBundleLineInput {
+    orgModelId: string;
+    /** Above 0. */
+    averageTokensPerLLMCall: number;
+    input: number;
+    output: number;
+    cache: number;
+    /** Default 0. Only on a model that has a cache-write price. */
+    cacheWrite?: number;
 }
+/** A credit — a token-metered entitlement your product draws down by its
+ *  `agentKey`. */
+interface Credit {
+    id: string;
+    name: string;
+    /** What a credit signal names; unique in the workspace. */
+    agentKey: string;
+    description: string | null;
+    /** Sum of the bundle lines' tokens (display figure). */
+    tokensPerCredit: number;
+    /** Cost of one credit, worked out from `modelBundle`. */
+    basePrice: number;
+    modelBundle: ModelBundleLine[];
+    marginPercent: number;
+    /** `basePrice` plus the margin — what a customer pays per credit. */
+    pricePerCredit: number;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+/** `credits.create()` body. The price is always worked out on the server from
+ *  `modelBundle` — it is never typed in. */
+interface CreateCreditInput {
+    name: string;
+    agentKey: string;
+    /** -100 or more. */
+    marginPercent: number;
+    /** At least one line. */
+    modelBundle: ModelBundleLineInput[];
+    description?: string | null;
+}
+/** `credits.update()` body — PARTIAL. Send `modelBundle` to re-price; leave it
+ *  out to keep the stored base price (a new margin is applied on top). */
+type UpdateCreditInput = Partial<CreateCreditInput>;
+/** An outcome — a multi-step deliverable billed per completed outcome. */
+interface Outcome {
+    id: string;
+    name: string;
+    /** The outcome's own key (unique in the workspace) — not what a step signal
+     *  names; each step has its own `agentKey`. */
+    agentKey: string;
+    description: string | null;
+    isActive: boolean;
+    /** Sum of the steps' base prices. */
+    basePrice: number;
+    marginPercent: number;
+    pricePerOutcome: number;
+    createdAt: string;
+    updatedAt: string;
+}
+/** One step of an outcome. */
+interface OutcomeStep {
+    /** Send it back on `outcomes.update()` to keep this step. */
+    id: string;
+    name: string;
+    /** What an outcome step signal names; unique in the workspace. */
+    agentKey: string;
+    order: number;
+    basePrice: number;
+    modelBundle: ModelBundleLine[];
+}
+/** `outcomes.get()` — the outcome with its steps in full. */
+interface OutcomeWithSteps extends Outcome {
+    steps: OutcomeStep[];
+}
+/** One step as you send it. */
+interface OutcomeStepInput {
+    /** An existing step's id, to keep that step (update only). A step sent
+     *  without an id but with an existing step's `agentKey` is that step too. */
+    id?: string;
+    name: string;
+    agentKey: string;
+    /** Required for a new step. Leave it out on an existing step to keep its
+     *  price. */
+    modelBundle?: ModelBundleLineInput[];
+}
+/** `outcomes.create()` body. */
+interface CreateOutcomeInput {
+    name: string;
+    agentKey: string;
+    /** -100 or more. */
+    marginPercent: number;
+    /** 1–50 steps; names and agent keys unique. */
+    steps: OutcomeStepInput[];
+    description?: string | null;
+}
+/** `outcomes.update()` body — PARTIAL. Leave `steps` out to leave the steps
+ *  alone; send it and it is the complete step list (stored steps left out are
+ *  removed). */
+type UpdateOutcomeInput = Partial<CreateOutcomeInput>;
+/** How a unit is priced. */
+type UnitPricingType = "FLAT" | "SLAB" | "VOLUME";
+/** One price band of a SLAB / VOLUME unit. */
+interface UnitTier {
+    id: string;
+    /** Inclusive upper bound; `null` on the last tier ("and above"). */
+    upTo: number | null;
+    /** Per-unit price for this band. */
+    price: number;
+    order: number;
+}
+/** A unit — a fixed-price, non-LLM event (an upload, a seat, an API call). */
+interface Unit {
+    id: string;
+    name: string;
+    /** What a unit signal names; unique in the workspace. */
+    agentKey: string;
+    description: string | null;
+    pricingType: UnitPricingType;
+    /** FLAT only. */
+    flatPrice: number;
+    /** SLAB / VOLUME only. */
+    tiers: UnitTier[];
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+    createdByName: string | null;
+}
+/** `units.create()` body. */
+interface CreateUnitInput {
+    name: string;
+    agentKey: string;
+    pricingType: UnitPricingType;
+    /** FLAT only. */
+    flatPrice?: number;
+    /** SLAB / VOLUME: 1–50 tiers, `upTo` rising; the last one `upTo: null`. */
+    tiers?: {
+        upTo: number | null;
+        price: number;
+    }[];
+    description?: string | null;
+}
+/** `units.update()` body — PARTIAL. `tiers`, when sent, is the complete list. */
+type UpdateUnitInput = Partial<CreateUnitInput>;
+/** A catalogue item a composite wraps. */
+interface CompositeItem {
+    id: string;
+    name: string;
+    agentKey: string;
+}
+/** A composite — several credits / outcomes / units grouped under one tag and
+ *  billed as ONE thing, per completed occurrence, once a plan sells it. */
+interface Composite {
+    id: string;
+    name: string;
+    /** The tag your signals send in their `composite` block. */
+    refId: string;
+    description: string | null;
+    /** USD per completed occurrence, once a plan sells it. */
+    price: number;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+    entitlements: {
+        credits: CompositeItem[];
+        outcomes: CompositeItem[];
+        units: CompositeItem[];
+    };
+}
+/** `composites.create()` body. */
+interface CreateCompositeInput {
+    name: string;
+    refId: string;
+    price: number;
+    description?: string | null;
+    /** At least one id across the three lists. Every item must be active, and a
+     *  unit must be FLAT-priced. */
+    entitlements: {
+        creditIds?: string[];
+        outcomeIds?: string[];
+        unitIds?: string[];
+    };
+}
+/** `composites.update()` body — PARTIAL. `entitlements`, when sent, is the
+ *  complete new set. */
+type UpdateCompositeInput = Partial<CreateCompositeInput>;
 type PurchaseStatus = "SCHEDULED" | "ACTIVE" | "CANCELLED";
 type CreatePurchaseInput = CustomerRef & {
     planId: string;
@@ -871,11 +1149,12 @@ interface UpdateMemberInput {
     email?: string;
 }
 /**
- * Which of a customer's two wallet balances an entry moves: `MAIN` (the
- * ordinary wallet) or `RESERVED` (the Reserved Wallet — an org-gated second
- * balance behind it; see {@link WalletAdjustInput.pool}).
+ * Which of a customer's two wallet balances an entry moves: `"main"` (the
+ * ordinary wallet) or `"reserved"` (the Reserved Wallet — an org-gated second
+ * balance behind it; see {@link WalletAdjustInput.pool}). Lowercase only —
+ * the API refuses `"MAIN"` / `"RESERVED"`.
  */
-type WalletPool = "MAIN" | "RESERVED";
+type WalletPool = "main" | "reserved";
 /** Top up (positive) or draw down (negative) a customer's wallet. `delta` is
  *  a non-zero amount in USD (cents allowed); absolute value ≤ 10,000,000. No
  *  `agentKey` — a customer has exactly one wallet. The wallet can always be
@@ -886,16 +1165,17 @@ interface WalletAdjustInput {
     delta: number;
     notes?: string;
     /**
-     * Which balance to move. Default `"MAIN"`, the ordinary wallet.
+     * Which balance to move. Default `"main"`, the ordinary wallet (leave it
+     * out; `null` is refused).
      *
-     * `"RESERVED"` moves the Reserved Wallet instead — a second balance behind
+     * `"reserved"` moves the Reserved Wallet instead — a second balance behind
      * the wallet that a wallet-funded Arrear charge draws on once the wallet
      * runs out (Wallet → Reserved down to 0 → Wallet goes negative). It must be
      * switched on for the org (Settings → Organisation → "Enable Reserved
      * balance in wallet"), else this is a `PlanError`. It never goes negative:
      * a reduce below zero is refused (an `AllowanceError`), not capped — drawing
      * down to exactly 0 is fine. `remaining` is then the Reserved balance. A
-     * `"MAIN"` adjustment never touches it.
+     * `"main"` adjustment never touches it.
      */
     pool?: WalletPool;
     /**
@@ -1310,6 +1590,75 @@ declare class Transport {
     private buildUrl;
 }
 
+/**
+ * The `composites` resource — several credits / outcomes / units grouped under
+ * one tag (`refId`) and billed as ONE thing per completed occurrence.
+ * `/api/v1/composites`.
+ *
+ * Creating a composite charges nobody: it only bills once a plan sells it as
+ * a `PRICING_METRIC` entitlement (`plans.create()` with its `compositeId`).
+ *
+ * There is no `delete()` — the API never deletes catalogue items. Retire a
+ * composite with `archive()` (new signals stop resolving to it; its history is
+ * kept); `unarchive()` brings it back.
+ */
+declare class Composites {
+    private readonly transport;
+    constructor(transport: Transport);
+    /** List them. `{ active: true }` returns only active ones, `{ active: false }`
+     *  only archived ones; omit it for both. */
+    list(params?: {
+        active?: boolean;
+    }): Promise<Composite[]>;
+    /** One composite's configuration. */
+    get(id: string): Promise<Composite>;
+    /** Create one. It starts active. Not retried on failure — a retry could
+     *  create a second row. */
+    create(input: CreateCompositeInput): Promise<Composite>;
+    /** PARTIAL update: only the fields you send change. `entitlements`, when
+     *  sent, is the complete new set. Renaming `refId` cuts live traffic over at
+     *  once — ship the new tag to your callers first. */
+    update(id: string, input: UpdateCompositeInput): Promise<Composite>;
+    /** Retire it (`isActive` → false). Nothing is deleted. Safe to retry. */
+    archive(id: string): Promise<Composite>;
+    /** Bring an archived one back (`isActive` → true). Safe to retry. */
+    unarchive(id: string): Promise<Composite>;
+}
+
+/**
+ * The `credits` resource — the token-metered credits your product draws down
+ * by `agentKey`. `/api/v1/credits`.
+ *
+ * Pricing is never typed in: `create()` takes a `modelBundle` (one line per
+ * model, each with `averageTokensPerLLMCall` and its input / output / cache /
+ * cacheWrite split) and the server works out `basePrice` and
+ * `pricePerCredit` from the models' live prices.
+ *
+ * There is no `delete()` — the API never deletes catalogue items. Retire a
+ * credit with `archive()`; `unarchive()` brings it back unchanged.
+ */
+declare class Credits {
+    private readonly transport;
+    constructor(transport: Transport);
+    /** List them. `{ active: true }` returns only active ones, `{ active: false }`
+     *  only archived ones; omit it for both. */
+    list(params?: {
+        active?: boolean;
+    }): Promise<Credit[]>;
+    /** One credit's configuration. */
+    get(id: string): Promise<Credit>;
+    /** Create one. It starts active. Not retried on failure — a retry could
+     *  create a second row. */
+    create(input: CreateCreditInput): Promise<Credit>;
+    /** PARTIAL update: only the fields you send change. Send `modelBundle` to
+     *  re-price; leave it out to keep the stored base price. */
+    update(id: string, input: UpdateCreditInput): Promise<Credit>;
+    /** Retire it (`isActive` → false). Nothing is deleted. Safe to retry. */
+    archive(id: string): Promise<Credit>;
+    /** Bring an archived one back (`isActive` → true). Safe to retry. */
+    unarchive(id: string): Promise<Credit>;
+}
+
 /**
  * The `customers` resource — full CRUD over the org's customers plus the
  * read-only insight endpoints (balances / plan). Every call is scoped
@@ -1414,7 +1763,7 @@ declare class Customers {
      * Top up (positive `delta`) or draw down (negative `delta`) a customer's
      * wallet, in USD — allowed whatever the customer's plan. `remaining` is the
      * resulting USD balance. No `agentKey` — a customer has exactly one wallet.
-     * Pass `pool: "RESERVED"` to move the Reserved Wallet instead (then
+     * Pass `pool: "reserved"` to move the Reserved Wallet instead (then
      * `remaining` is its balance). `POST …/:id/wallet/adjust`.
      */
     adjustWallet(id: string, input: WalletAdjustInput): Promise<AdjustResult>;
@@ -1478,6 +1827,40 @@ declare class Invoices {
     payLink(id: string): Promise<PayLink>;
 }
 
+/**
+ * The `outcomes` resource — multi-step deliverables billed per completed
+ * outcome. `/api/v1/outcomes`.
+ *
+ * `list()` and every write return the outcome without its steps; `get()`
+ * returns it with every step in full (ids included). Each new step is priced
+ * from its own `modelBundle`, on the server.
+ *
+ * There is no `delete()` — the API never deletes catalogue items. Retire an
+ * outcome with `archive()`; `unarchive()` brings it back unchanged.
+ */
+declare class Outcomes {
+    private readonly transport;
+    constructor(transport: Transport);
+    /** List them. `{ active: true }` returns only active ones, `{ active: false }`
+     *  only archived ones; omit it for both. */
+    list(params?: {
+        active?: boolean;
+    }): Promise<Outcome[]>;
+    /** One outcome's configuration, with every step in full. */
+    get(id: string): Promise<OutcomeWithSteps>;
+    /** Create one. It starts active. Not retried on failure — a retry could
+     *  create a second row. */
+    create(input: CreateOutcomeInput): Promise<Outcome>;
+    /** PARTIAL update: only the fields you send change. Leave `steps` out to
+     *  leave the steps alone; send it and it is the complete list — pass each
+     *  existing step's `id` (or its same `agentKey`) to keep it. */
+    update(id: string, input: UpdateOutcomeInput): Promise<Outcome>;
+    /** Retire it (`isActive` → false). Nothing is deleted. Safe to retry. */
+    archive(id: string): Promise<Outcome>;
+    /** Bring an archived one back (`isActive` → true). Safe to retry. */
+    unarchive(id: string): Promise<Outcome>;
+}
+
 /**
  * The `payments` resource — read-only. A payment is a PAID invoice; the `id`
  * used here is that underlying invoice id. `/api/v1/payments`.
@@ -1495,9 +1878,14 @@ declare class Payments {
 }
 
 /**
- * The `plans` resource — read the billing plans customers can subscribe to.
- * Each plan is a set of entitlement components (wallet / credit / outcome /
- * unit / flat) billed on a cycle. `/api/v1/plans`.
+ * The `plans` resource — the billing plans customers subscribe to. Each plan
+ * is a set of `entitlements` (wallet / credit / outcome / unit / composite /
+ * flat lines) billed on a cycle. `/api/v1/plans`.
+ *
+ * A plan's currency is the workspace's primary currency; it can't be chosen.
+ * There is no `delete()` — the API never deletes plans, so customers already
+ * on one keep what they bought. Retire a plan with `archive()`; `unarchive()`
+ * makes it purchasable again.
  */
 declare class Plans {
     private readonly transport;
@@ -1508,6 +1896,20 @@ declare class Plans {
     list(params?: {
         active?: boolean;
     }): Promise<Plan[]>;
+    /** One plan's configuration. */
+    get(id: string): Promise<Plan>;
+    /** Create a plan. It starts active. Not retried on failure — a retry could
+     *  create a second plan. */
+    create(input: CreatePlanInput): Promise<Plan>;
+    /** PARTIAL update: only the fields you send change. `entitlements`, when
+     *  sent, is the complete new list — the list `get()` returned can be sent
+     *  back as it is. Changes apply to new purchases only. */
+    update(id: string, input: UpdatePlanInput): Promise<Plan>;
+    /** Retire a plan (`isActive` → false): it can't be bought any more; customers
+     *  already on it are unaffected. Safe to retry. */
+    archive(id: string): Promise<Plan>;
+    /** Make an archived plan purchasable again (`isActive` → true). Safe to retry. */
+    unarchive(id: string): Promise<Plan>;
 }
 
 /**
@@ -1775,6 +2177,35 @@ declare class Signals {
     usageLog(params: UsageLogListParams): Promise<UsageLogPage>;
 }
 
+/**
+ * The `units` resource — fixed-price, non-LLM events (uploads, seats, API
+ * calls), priced FLAT, SLAB or VOLUME. `/api/v1/units`.
+ *
+ * There is no `delete()` — the API never deletes catalogue items. Retire a
+ * unit with `archive()`; `unarchive()` brings it back unchanged.
+ */
+declare class Units {
+    private readonly transport;
+    constructor(transport: Transport);
+    /** List them. `{ active: true }` returns only active ones, `{ active: false }`
+     *  only archived ones; omit it for both. */
+    list(params?: {
+        active?: boolean;
+    }): Promise<Unit[]>;
+    /** One unit's configuration. */
+    get(id: string): Promise<Unit>;
+    /** Create one. It starts active. Not retried on failure — a retry could
+     *  create a second row. */
+    create(input: CreateUnitInput): Promise<Unit>;
+    /** PARTIAL update: only the fields you send change. `tiers`, when sent, is
+     *  the complete new tier list. */
+    update(id: string, input: UpdateUnitInput): Promise<Unit>;
+    /** Retire it (`isActive` → false). Nothing is deleted. Safe to retry. */
+    archive(id: string): Promise<Unit>;
+    /** Bring an archived one back (`isActive` → true). Safe to retry. */
+    unarchive(id: string): Promise<Unit>;
+}
+
 /**
  * The ClockNext client.
  *
@@ -1797,8 +2228,16 @@ declare class ClockNext {
     readonly signals: Signals;
     /** Manage customers, their members, and balances. */
     readonly customers: Customers;
-    /** List billing plans. */
+    /** Billing plans: list, get, create, update, archive, unarchive. */
     readonly plans: Plans;
+    /** Credits: list, get, create, update, archive, unarchive (no delete). */
+    readonly credits: Credits;
+    /** Outcomes: list, get, create, update, archive, unarchive (no delete). */
+    readonly outcomes: Outcomes;
+    /** Units: list, get, create, update, archive, unarchive (no delete). */
+    readonly units: Units;
+    /** Composites: list, get, create, update, archive, unarchive (no delete). */
+    readonly composites: Composites;
     /** Subscribe customers to plans (purchases). */
     readonly purchases: Purchases;
     /** Read invoices and mint hosted pay links. */
@@ -1894,4 +2333,4 @@ declare class NetworkError extends ClockNextError {
     });
 }
 
-export { type AddMemberInput, type AdjustResult, AllowanceError, type ApiCustomer, AuthError, type BillingCycle, type BillingMode, ClockNext, type ClockNextConfig, ClockNextError, type ClockNextErrorCode, type ComponentType, type CompositeAdjustInput, type CompositeCompletionInput, type CompositeCompletionResult, type CompositeTag, ConflictError, type CreateCustomerInput, type CreatePurchaseInput, type CreditAdjustInput, type CreditBalance, type CreditInput, type CreditSignal, type CustomerBalances, type CustomerList, type CustomerPlan, type CustomerPlanDetails, type CustomerProfileInput, type CustomerRef, type DropReason, type FetchLike, ForbiddenError, type Invoice, type InvoiceDetail, type InvoiceLineItem, type InvoiceListRow, type InvoiceParty, type InvoicePlanSnapshot, type InvoiceStatus, type Logger, type Member, type MemberProfile, NetworkError, NotFoundError, type OutcomeAdjustInput, type OutcomeBalance, type OutcomeCompletionInput, type OutcomeCompletionResult, type OutcomeInput, type OutcomeSignal, type PayLink, type PaymentDetail, type PaymentRow, type Plan, type PlanComponent, PlanError, type PlanKind, type PlanRef, type PlanType, type PortalToken, type PortalTokenInput, type Purchase, type PurchaseDetail, type PurchaseStatus, RateLimitError, type RecurringGrantInput, type RecurringGrantResult, type RemovedMember, type SerializedOutcomeAttribution, type SerializedRuleApplication, type SerializedUnitUsage, type SerializedUsageLog, ServerError, type Signal, type SignalDelivery, type SignalStatus, type SignalType, type Tokens, type TrackResult, type UnitAdjustInput, type UnitBalance, type UnitInput, type UnitTrackResult, type UpdateMemberInput, type UsageBalance, type UsageLogAppliedRule, type UsageLogEntry, type UsageLogListParams, type UsageLogOutcomeAttribution, type UsageLogPage, type UsageLogPeriod, ValidationError, type WalletAdjustInput, type WalletInput, type WalletPool, type WalletSignal, signalToWire };
+export { type AddMemberInput, type AdjustResult, AllowanceError, type ApiCustomer, AuthError, type BillingCycle, type BillingMode, ClockNext, type ClockNextConfig, ClockNextError, type ClockNextErrorCode, type ComponentType, type Composite, type CompositeAdjustInput, type CompositeBalance, type CompositeCompletionInput, type CompositeCompletionResult, type CompositeItem, type CompositeTag, ConflictError, type CreateCompositeInput, type CreateCreditInput, type CreateCustomerInput, type CreateOutcomeInput, type CreatePlanInput, type CreatePurchaseInput, type CreateUnitInput, type Credit, type CreditAdjustInput, type CreditBalance, type CreditInput, type CreditSignal, type CustomerBalances, type CustomerList, type CustomerPlan, type CustomerPlanDetails, type CustomerProfileInput, type CustomerRef, type DropReason, type FetchLike, ForbiddenError, type Invoice, type InvoiceDetail, type InvoiceLineItem, type InvoiceListRow, type InvoiceParty, type InvoicePlanSnapshot, type InvoiceStatus, type Logger, type Member, type MemberProfile, type ModelBundleLine, type ModelBundleLineInput, NetworkError, NotFoundError, type Outcome, type OutcomeAdjustInput, type OutcomeBalance, type OutcomeCompletionInput, type OutcomeCompletionResult, type OutcomeInput, type OutcomeSignal, type OutcomeStep, type OutcomeStepInput, type OutcomeWithSteps, type PayLink, type PaymentDetail, type PaymentRow, type Plan, type PlanComponent, type PlanEntitlement, type PlanEntitlementInput, PlanError, type PlanKind, type PlanRef, type PlanType, type PortalToken, type PortalTokenInput, type Purchase, type PurchaseDetail, type PurchaseStatus, RateLimitError, type RecurringGrantInput, type RecurringGrantResult, type RemovedMember, type SerializedOutcomeAttribution, type SerializedRuleApplication, type SerializedUnitUsage, type SerializedUsageLog, ServerError, type Signal, type SignalDelivery, type SignalStatus, type SignalType, type Tokens, type TrackResult, type Unit, type UnitAdjustInput, type UnitBalance, type UnitInput, type UnitPricingType, type UnitTier, type UnitTrackResult, type UpdateCompositeInput, type UpdateCreditInput, type UpdateMemberInput, type UpdateOutcomeInput, type UpdatePlanInput, type UpdateUnitInput, type UsageBalance, type UsageLogAppliedRule, type UsageLogEntry, type UsageLogListParams, type UsageLogOutcomeAttribution, type UsageLogPage, type UsageLogPeriod, ValidationError, type WalletAdjustInput, type WalletInput, type WalletPool, type WalletSignal, signalToWire };