@clocknext/sdk 0.11.0 → 0.12.1

package/dist/index.d.cts

@@ -139,6 +139,11 @@ interface OutcomeSignal extends SignalBase {
      * Set `true` on the LAST step signal to declare the run finished — completion
      * is never inferred from step coverage. Sending it twice is a safe no-op and
      * can't bill again.
+     *
+     * This closes the RUN only. If the signal also carries a `composite`, that
+     * occurrence stays open and unbilled until you call
+     * `signals.completeComposite()` — the two completions are separate, and
+     * neither implies the other.
      */
     complete?: boolean;
     /** Optional composite this signal belongs to. See {@link CompositeTag}. */
@@ -228,9 +233,46 @@ interface SerializedUsageLog {
  * When the server has no queue configured it prices inline instead and returns
  * `queued: false` with a populated `usageLog`, validating synchronously.
  */
+/**
+ * How far a metering call actually got. See {@link TrackResult.status} — the
+ * three states differ in whether the signal can still be lost, and in whether
+ * it has been billed.
+ */
+type SignalDelivery = "buffered" | "accepted" | "recorded" | "dropped";
 interface TrackResult {
-    /** True when the signal has not been priced yet — either buffered locally
-     *  (async mode) or accepted for asynchronous processing by the server. */
+    /**
+     * How far this signal has actually got. Branch on this, not on `queued`.
+     *
+     *   `"buffered"` — held in THIS process's memory and not yet sent. Lost if
+     *                  the process exits first, so `flush()`/`close()` before it
+     *                  can. No `rawId` exists yet.
+     *   `"accepted"` — the server has written it to its durable inbox (`202`)
+     *                  and will price it shortly. It can no longer be lost, but
+     *                  it is not billed yet and `usageLog` is null. A rejection
+     *                  discovered during pricing will NOT come back to you here,
+     *                  nor on `onError`. `signals.list()` shows what got priced;
+     *                  the dashboard's signal log — owner-only, by design — is
+     *                  where an individual rejection says why.
+     *   `"recorded"` — the server priced it inline and `usageLog` is populated.
+     *   `"dropped"`  — the SDK threw it away without sending: the client is
+     *                  closed, or the local queue is full. `onDrop` fired with
+     *                  the reason. This state exists because the alternative was
+     *                  reporting `"buffered"` for a signal that was discarded —
+     *                  a success-shaped answer to a lost billable event.
+     *
+     * Note what none of these mean: "waited for a price". Even `{ wait: true }`
+     * waits only for the server to ACCEPT the signal, never for it to finish
+     * pricing — holding a request thread open for a billing round-trip is
+     * exactly the cost this design exists to avoid.
+     */
+    status: SignalDelivery;
+    /**
+     * True for both `"buffered"` and `"accepted"` — i.e. "not priced yet".
+     *
+     * Kept for compatibility, but it collapses two states with opposite failure
+     * behaviour (one is lost when the process dies, the other cannot be) into
+     * one boolean, which is why {@link TrackResult.status} exists. Prefer that.
+     */
     queued: boolean;
     /** The computed usage log. Non-null ONLY when the server priced the signal
      *  inline (`queued: false`); null on a `202` hand-off and absent while the
@@ -416,7 +458,15 @@ type BillingCycle = "MONTHLY" | "QUARTERLY" | "SEMI_ANNUAL" | "YEARLY" | "EVERY_
 type PlanType = "WALLET" | "BUNDLE";
 type PlanKind = "FLAT_PRICE" | "PAY_AS_YOU_GO" | "PAY_PER_SEAT";
 /** A plan component's meter type. */
-type ComponentType = "WALLET" | "CREDIT" | "OUTCOME" | "UNIT" | "FLAT";
+/**
+ * A plan component's kind.
+ *
+ * `PRICING_METRIC` is a COMPOSITE component — the server's wire name for it,
+ * kept verbatim because that is the string you will actually receive and must
+ * send back. It was missing here, which made a `switch` over `PlanComponent.type`
+ * look exhaustive to TypeScript while silently skipping every composite.
+ */
+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";
 /** Prepaid USD wallet. `amount` is the funded balance (required). Max one
@@ -536,6 +586,11 @@ interface PlanComponent {
     creditId: string | null;
     outcomeId: string | null;
     unitId: string | null;
+    /** The composite this component sells, on a `PRICING_METRIC` component.
+     *  Without it a plan read back could not be written back: the write shape
+     *  ({@link CompositeComponentInput}) requires this id, so a read-modify-write
+     *  silently dropped every composite component. */
+    pricingMetricId: string | null;
     targetName: string | null;
     quantity: number | null;
     amount: number | null;
@@ -550,6 +605,9 @@ interface Plan {
     cost: number;
     /** Signed adjustment applied to the plan's headline price (default 0). */
     priceAdjustment: number;
+    /** 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;
     currencyCode: string;
     isActive: boolean;
     components: PlanComponent[];
@@ -591,6 +649,8 @@ interface Purchase {
     hasCredit: boolean;
     hasOutcome: boolean;
     hasUnit: boolean;
+    /** True when the purchased plan sells at least one composite. */
+    hasComposite: boolean;
     billingCycle: BillingCycle;
     cost: number;
     currencyCode: string;
@@ -798,9 +858,16 @@ interface UpdateMemberInput {
     email?: string;
 }
 type WalletTransactionType = "CREDIT" | "DEBIT";
+/** What produced a wallet entry. `null` on rows written before the column
+ *  existed. */
+type WalletTransactionSource = "TOPUP" | "USAGE" | "SETTLE" | "ADJUSTMENT";
+/** The entitlement kinds a wallet-funded metering debit can name. */
+type WalletEntitlementKind = "CREDIT" | "OUTCOME" | "UNIT";
 interface WalletTransaction {
     id: string;
     type: WalletTransactionType;
+    /** What produced the entry. Null on rows older than the column. */
+    source: WalletTransactionSource | null;
     amount: number;
     amountUsd: number;
     currencyCode: string;
@@ -809,6 +876,19 @@ interface WalletTransaction {
     batchId: string | null;
     createdAt: string;
     createdByName: string | null;
+    /** Set only on a wallet-funded metering debit: which kind of entitlement was
+     *  consumed. Null on top-ups and manual adjustments. */
+    entitlementType: WalletEntitlementKind | null;
+    /** Id of the credit / outcome / unit consumed. Null unless
+     *  `entitlementType` is set. */
+    targetId: string | null;
+    /** Its name at the time of the debit. */
+    targetName: string | null;
+    /** The signal this debit paid for (credit / outcome). In wallet-funded mode
+     *  no invoice exists, so this is the only trail from a charge to its cause. */
+    usageLogId: string | null;
+    /** The unit event this debit paid for. */
+    unitUsageLogId: string | null;
 }
 interface WalletList {
     balanceUsd: number;
@@ -959,14 +1039,14 @@ interface Outcome {
     isActive: boolean;
     marginPercent: number;
     pricePerOutcome: number;
-    createdAt: string;
-    steps?: {
-        name: string;
-        agentKey: string;
-    }[];
 }
 /** `outcomes.get()` — adds steps plus in-flight/completed stats. */
 interface OutcomeDetail extends Outcome {
+    /** Only the DETAIL row carries these — `outcomes.list()` returns neither.
+     *  They were previously declared on {@link Outcome} itself, where
+     *  `createdAt` was typed as a required `string` that is always `undefined`
+     *  in practice. */
+    createdAt: string;
     createdByName: string | null;
     steps: {
         name: string;
@@ -1130,7 +1210,11 @@ interface UnitInput {
  * a bare `{ unitUsage }`. Branch on `queued`; never assume `unitUsage`.
  */
 interface UnitTrackResult {
-    /** True when the report was accepted but not yet priced (`202`). */
+    /** How far the report got. Never `"buffered"` — unit reports are always sent
+     *  immediately, not queued client-side. See {@link TrackResult.status}. */
+    status: Extract<SignalDelivery, "accepted" | "recorded">;
+    /** True when the report was accepted but not yet priced (`202`). Prefer
+     *  {@link UnitTrackResult.status}. */
     queued: boolean;
     /** The priced unit event. Non-null ONLY when the server priced inline. */
     unitUsage?: SerializedUnitUsage | null;
@@ -1227,10 +1311,16 @@ interface CreateCompositeInput {
  * lands. That case answers with no `status`, only a `rawId` to follow.
  */
 interface CompositeCompletionResult {
-    /** True when the ping was accepted but not yet applied (`202`). */
+    /** How far the ping got. Never `"buffered"` — completions are always sent
+     *  immediately. `"recorded"` means the occurrence was closed inline. See
+     *  {@link TrackResult.status}. */
+    delivery: Extract<SignalDelivery, "accepted" | "recorded">;
+    /** True when the ping was accepted but not yet applied (`202`). Prefer
+     *  {@link CompositeCompletionResult.delivery}. */
     queued: boolean;
     /** `COMPLETED` on the first close, `ALREADY_COMPLETED` on a replay. Absent
-     *  when the ping was queued or parked. */
+     *  when the ping was queued or parked. Distinct from `delivery`: this is the
+     *  server's verdict on the OCCURRENCE, that is how far the REQUEST got. */
     status?: "COMPLETED" | "ALREADY_COMPLETED";
     /** The composite that was closed. Null on the replay of a historical row
      *  whose occurrence can no longer be read back. */
@@ -1281,10 +1371,14 @@ interface UnitUsageList {
 }
 type ThresholdKind = "CREDIT" | "OUTCOME" | "WALLET";
 interface Webhook {
+    id: string;
     kind: ThresholdKind;
     threshold: number;
     url: string;
     isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+    createdByName: string | null;
 }
 interface UpsertWebhookInput {
     kind: ThresholdKind;
@@ -1300,7 +1394,16 @@ interface Logger {
     warn?: (...args: unknown[]) => void;
     error?: (...args: unknown[]) => void;
 }
-type DropReason = "queue_full" | "send_failed";
+/**
+ * Why a signal was dropped without being billed.
+ *
+ *   `queue_full`  — the local buffer hit `batch.maxQueueSize`; never sent.
+ *   `closed`      — tracked after `close()`; never sent.
+ *   `send_failed` — sent, and permanently rejected or unreachable. This is the
+ *                   only reason that also fires `onError`, which carries the
+ *                   error (and its `idempotencyKey`, for a safe replay).
+ */
+type DropReason = "queue_full" | "closed" | "send_failed";
 interface ClockNextConfig {
     /** The org API key (`cnk_…`). Required. */
     apiKey: string;
@@ -1391,6 +1494,15 @@ interface RequestOptions {
      * opt in explicitly.
      */
     retry?: boolean;
+    /**
+     * The idempotency key carried in this request's body, for metering calls.
+     *
+     * Copied onto any error thrown, so a caller handling a permanent failure can
+     * replay the signal with the SAME key instead of minting a fresh one — which
+     * would defeat server-side dedup and bill twice. See
+     * `ClockNextError.idempotencyKey`.
+     */
+    idempotencyKey?: string;
 }
 /**
  * The single HTTP seam. Builds the authenticated request, enforces a timeout,
@@ -1428,7 +1540,9 @@ declare class Composites {
     constructor(transport: Transport);
     /** List composites. Pass `{ active: true }` for only the ones a signal can
      *  still be tagged with — the default list INCLUDES archived ones, which
-     *  keep every row they already own. */
+     *  keep every row they already own.
+     *  `{ active: false }` returns only archived ones; omitting it returns
+     *  both. See `activeQuery` — the API itself only supports `true`. */
     list(params?: {
         active?: boolean;
     }): Promise<Composite[]>;
@@ -1444,7 +1558,9 @@ declare class Composites {
 declare class Credits {
     private readonly transport;
     constructor(transport: Transport);
-    /** List credit types. Pass `{ active: true }` to only return active ones. */
+    /** List credit types. Pass `{ active: true }` to only return active ones.
+     *  `{ active: false }` returns only archived ones; omitting it returns
+     *  both. See `activeQuery` — the API itself only supports `true`. */
     list(params?: {
         active?: boolean;
     }): Promise<Credit[]>;
@@ -1593,7 +1709,9 @@ declare class Invoices {
 declare class Outcomes {
     private readonly transport;
     constructor(transport: Transport);
-    /** List outcome types. Pass `{ active: true }` to only return active ones. */
+    /** List outcome types. Pass `{ active: true }` to only return active ones.
+     *  `{ active: false }` returns only archived ones; omitting it returns
+     *  both. See `activeQuery` — the API itself only supports `true`. */
     list(params?: {
         active?: boolean;
     }): Promise<Outcome[]>;
@@ -1633,7 +1751,9 @@ declare class Payments {
 declare class Plans {
     private readonly transport;
     constructor(transport: Transport);
-    /** List plans, oldest-first. Pass `{ active: true }` to only return active plans. */
+    /** List plans, oldest-first. Pass `{ active: true }` to only return active plans.
+     *  `{ active: false }` returns only archived ones; omitting it returns
+     *  both. See `activeQuery` — the API itself only supports `true`. */
     list(params?: {
         active?: boolean;
     }): Promise<Plan[]>;
@@ -1725,13 +1845,30 @@ declare class Flusher {
     private draining;
     private closed;
     constructor(transport: Transport, cfg: ResolvedConfig);
-    /** Buffer one signal. Drops (with onDrop) when closed or the queue is full. */
-    enqueue(item: QueuedSignal): void;
+    /**
+     * Buffer one signal. Drops (with onDrop) when closed or the queue is full.
+     * Returns whether it was actually buffered, so `track()` can report a drop
+     * honestly instead of answering "buffered" for a signal it threw away.
+     */
+    enqueue(item: QueuedSignal): boolean;
     /** Arm the interval timer if it isn't already running. */
     private arm;
+    /** Cancel the interval timer if one is armed. */
+    private clearTimer;
     /**
-     * Send everything currently buffered. Overlapping calls share the single
-     * in-progress drain, so total in-flight sends never exceed `maxConcurrency`.
+     * Send everything buffered at the moment this resolves.
+     *
+     * Overlapping calls CHAIN onto the in-flight drain rather than sharing it.
+     * Sharing looks equivalent and is not: a drain that has already passed its
+     * final `size() > 0` check cannot see a signal enqueued a moment later, so
+     * handing that same promise back would resolve `flush()` — and therefore
+     * `close()` — with the buffer non-empty. Since `close()` has already set
+     * `closed`, `arm()` will not re-arm, and the timer it did arm is `unref`'d,
+     * so the process is free to exit and that signal is simply lost. Chaining
+     * guarantees at least one full drain begins after this call.
+     *
+     * Concurrency is unaffected: drains run one after another, and each one
+     * sends at most `maxConcurrency` signals at a time.
      */
     flush(): Promise<void>;
     /** Drain the buffer in concurrency-bounded waves until it's empty. */
@@ -1765,18 +1902,31 @@ declare function signalToWire(signal: Signal): Record<string, unknown>;
  * The `signals` resource: record usage signals and read them back.
  *
  * In async mode (default), `track()` buffers the signal locally and returns
- * immediately with `{ queued: true }`. Pass `{ wait: true }` (or construct the
- * client in `sync` mode) to await the request.
+ * immediately with `{ status: "buffered" }`. Pass `{ wait: true }` (or
+ * construct the client in `sync` mode) to await the request instead.
+ *
+ * Awaiting the request does NOT mean waiting for a price, and deliberately so.
+ * The server writes every signal to a durable inbox and hands it to a worker,
+ * answering `202` — so `track()` resolves `{ status: "accepted", messageId,
+ * rawId, usageLog: null }`: impossible to lose, not yet billed. Only when the
+ * server prices inline do you get `{ status: "recorded", usageLog }`. Branch on
+ * `status`; never assume `usageLog`.
+ *
+ * Nothing here ever blocks a request thread on billing. That is the point: a
+ * meter that makes the caller wait for pricing has moved your billing system
+ * onto your product's critical path.
  *
- * Awaiting the request does NOT guarantee a priced result. The server writes
- * every signal to a durable inbox and then hands it to a worker, so it answers
- * `202` and `track()` resolves `{ queued: true, messageId, rawId, usageLog:
- * null }` — accepted and impossible to lose, but not yet billed. Only when the
- * server prices inline do you get `{ queued: false, usageLog }`. Branch on
- * `queued`; never assume `usageLog`.
+ * Because of that, a signal the server later REJECTS (unknown `agentKey`, a
+ * model the org has not enabled, no active plan) cannot come back through this
+ * promise — and does not reach `onError` either, since from here that request
+ * succeeded. Such a rejection has no programmatic channel at all: it is
+ * recorded on the workspace's signal log in the ClockNext dashboard, which is
+ * owner-only by design.
  *
- * `list()` is how you confirm one actually landed — and, ingestion being
- * asynchronous, the only way to.
+ * `list()` is the partial check available from code. It returns priced usage
+ * logs with a `status`, so it confirms a signal landed and whether pricing
+ * succeeded — but a signal refused BEFORE pricing never becomes a usage log
+ * and does not appear there.
  */
 declare class Signals {
     private readonly transport;
@@ -1843,9 +1993,13 @@ declare class Signals {
      * arrive in any order and the occurrence stays open and unbilled until you
      * say otherwise. Put it on the line before your own `return`.
      *
-     * An OUTCOME never needs this — its own `complete: true` closes its run and
-     * the matching occurrence together. Credits and units have no "done" signal
-     * of their own, so this is theirs.
+     * EVERY composite needs this, outcome-backed ones included. An outcome's own
+     * `complete: true` closes its RUN and nothing else — it does not close the
+     * composite occurrence the run was tagged into, whatever mix of credits,
+     * outcomes and units that composite wraps. (Earlier versions of this SDK
+     * documented the opposite. Believing it means the occurrence stays ONGOING
+     * forever and is never billed, so if you tag outcome signals with a
+     * `composite`, you must still call this.)
      *
      * Closing twice is safe: the second call answers `ALREADY_COMPLETED` and
      * cannot bill again. Calling it EARLY is also safe — before every entitlement
@@ -1874,7 +2028,9 @@ declare class Signals {
 declare class Units {
     private readonly transport;
     constructor(transport: Transport);
-    /** List unit types. Pass `{ active: true }` to only return active ones. */
+    /** List unit types. Pass `{ active: true }` to only return active ones.
+     *  `{ active: false }` returns only archived ones; omitting it returns
+     *  both. See `activeQuery` — the API itself only supports `true`. */
     list(params?: {
         active?: boolean;
     }): Promise<Unit[]>;
@@ -1916,7 +2072,9 @@ declare class Workspace {
     /** Identify the org + key behind the request, incl. `sandbox` | `live`. */
     me(): Promise<WorkspaceIdentity>;
     /** The org's enabled models with live prices. `{ active: true }` returns only
-     *  the models that can be metered right now. */
+     *  the models that can be metered right now.
+     *  `{ active: false }` returns only archived ones; omitting it returns
+     *  both. See `activeQuery` — the API itself only supports `true`. */
     models(params?: {
         active?: boolean;
     }): Promise<Model[]>;
@@ -1978,24 +2136,45 @@ declare class ClockNext {
 }
 
 /**
- * Typed error hierarchy. The server returns `{ ok: false, error }` with a
- * meaningful HTTP status; we map that status to a class so callers can branch
- * on the *kind* of failure (e.g. allowance exhausted ⇒ upsell; network ⇒ ignore,
- * it's queued) rather than string-matching messages.
+ * Typed error hierarchy. The server returns `{ statusCode, statusDetail, result }`
+ * with a meaningful HTTP status; we map that status to a class so callers can
+ * branch on the *kind* of failure (e.g. allowance exhausted ⇒ upsell; network ⇒
+ * ignore, it's queued) rather than string-matching messages.
  */
+/** Machine-readable failure code, when the server sends one
+ *  (`statusDetail.code`). Preferred over any message heuristic. */
+type ClockNextErrorCode = "ALLOWANCE_EXHAUSTED" | "PLAN_REJECTED" | "IDEMPOTENCY_UNRESOLVED" | (string & {});
 declare class ClockNextError extends Error {
     /** HTTP status, when the failure came from a server response. */
     readonly status?: number;
     /** Whether the SDK considers this failure worth retrying. */
     readonly retryable: boolean;
+    /**
+     * The server's machine-readable code, when it sent one. Branch on this in
+     * preference to `.message`, which is human copy and may be reworded.
+     */
+    readonly code?: ClockNextErrorCode;
+    /**
+     * The idempotency key of the request that failed, for metering calls.
+     *
+     * This is what makes a dead-letter retry safe: re-send the failed signal with
+     * this SAME key and the server deduplicates it instead of billing twice. A
+     * fresh key would double-bill, so never generate one when replaying.
+     */
+    readonly idempotencyKey?: string;
     constructor(message: string, opts?: {
         status?: number;
         retryable?: boolean;
+        code?: ClockNextErrorCode;
+        idempotencyKey?: string;
     });
 }
 /** 401 — missing / invalid / expired API key. */
 declare class AuthError extends ClockNextError {
 }
+/** 403 — the key is valid but cannot perform this operation. */
+declare class ForbiddenError extends ClockNextError {
+}
 /** 400 — malformed request / schema validation failure. */
 declare class ValidationError extends ClockNextError {
 }
@@ -2005,10 +2184,13 @@ declare class NotFoundError extends ClockNextError {
 /** 422 — no active plan, meter not in plan, model not enabled, member missing. */
 declare class PlanError extends ClockNextError {
 }
-/** 422 — insufficient credits / units / outcomes for the call. */
+/** 422 — the entitlement ran out: no credits / units / outcomes / composite
+ *  slots left. Distinct from {@link PlanError} because the fix is different —
+ *  this one is a top-up or an upsell, not a configuration change. */
 declare class AllowanceError extends ClockNextError {
 }
-/** 409 — conflict. */
+/** 409 — conflict. Almost always permanent (an archived customer); only the
+ *  idempotency-resolution conflict is transient, and only that one retries. */
 declare class ConflictError extends ClockNextError {
 }
 /** 429 — rate limited. */
@@ -2016,6 +2198,7 @@ declare class RateLimitError extends ClockNextError {
     readonly retryAfterMs?: number;
     constructor(message: string, opts?: {
         retryAfterMs?: number;
+        idempotencyKey?: string;
     });
 }
 /** 5xx — server-side error. */
@@ -2023,7 +2206,9 @@ declare class ServerError extends ClockNextError {
 }
 /** fetch threw / request timed out — request never completed. */
 declare class NetworkError extends ClockNextError {
-    constructor(message: string);
+    constructor(message: string, opts?: {
+        idempotencyKey?: string;
+    });
 }
 
-export { type AddMemberInput, AllowanceError, type ApiCustomer, AuthError, type BillingCycle, type BillingMode, ClockNext, type ClockNextConfig, ClockNextError, type ComponentType, type Composite, type CompositeCatalogueRef, type CompositeCompletionInput, type CompositeCompletionResult, type CompositeComponentInput, type CompositeTag, ConflictError, type CostPoint, type CostStats, type CreateCompositeInput, type CreateCreditInput, type CreateCustomerInput, type CreateOutcomeInput, type CreatePlanInput, type CreatePurchaseInput, type CreateUnitInput, type Credit, type CreditAdjustInput, type CreditAnalytics, type CreditBalance, type CreditComponentInput, type CreditDetail, type CreditInput, type CreditSignal, type CustomerBalances, type CustomerList, type CustomerPlan, type CustomerPlanDetails, type CustomerProfileInput, type DropReason, type FetchLike, type FlatComponentInput, type FlatUnitInput, type Invoice, type InvoiceDetail, type InvoiceLineItem, type InvoiceListRow, type InvoiceParty, type InvoicePlanSnapshot, type InvoiceStatus, type Logger, type Member, type MemberProfile, type Model, type ModelBundleEntry, NetworkError, NotFoundError, type Outcome, type OutcomeAdjustInput, type OutcomeAnalytics, type OutcomeBalance, type OutcomeComponentInput, type OutcomeDetail, type OutcomeInput, type OutcomeSignal, type OutcomeStepInput, type PayLink, type PaymentDetail, type PaymentRow, type Plan, type PlanComponent, type PlanComponentInput, type PlanDetail, PlanError, type PlanKind, type PlanRef, type PlanType, type PortalToken, type PortalTokenInput, type Purchase, type PurchaseDetail, type PurchaseStatus, RateLimitError, type RemovedMember, type SerializedOutcomeAttribution, type SerializedRuleApplication, type SerializedUnitUsage, type SerializedUsageLog, ServerError, type Signal, type SignalStatus, type SignalType, type ThresholdKind, type TieredUnitInput, type Tokens, type TrackResult, type Unit, type UnitAdjustInput, type UnitBalance, type UnitComponentInput, type UnitCustomerRow, type UnitDetail, type UnitInput, type UnitPricingType, type UnitTier, type UnitTierInput, type UnitTrackResult, type UnitUsageList, type UnitUsageRow, type UpdateCreditInput, type UpdateMemberInput, type UpdateOutcomeInput, type UpdatePlanInput, type UpdateUnitInput, type UpsertWebhookInput, type UsageBalance, type UsageList, ValidationError, type WalletComponentInput, type WalletEntryInput, type WalletInput, type WalletList, type WalletSignal, type WalletTransaction, type WalletTransactionType, type Webhook, type WorkspaceIdentity, signalToWire };
+export { type AddMemberInput, AllowanceError, type ApiCustomer, AuthError, type BillingCycle, type BillingMode, ClockNext, type ClockNextConfig, ClockNextError, type ClockNextErrorCode, type ComponentType, type Composite, type CompositeCatalogueRef, type CompositeCompletionInput, type CompositeCompletionResult, type CompositeComponentInput, type CompositeTag, ConflictError, type CostPoint, type CostStats, type CreateCompositeInput, type CreateCreditInput, type CreateCustomerInput, type CreateOutcomeInput, type CreatePlanInput, type CreatePurchaseInput, type CreateUnitInput, type Credit, type CreditAdjustInput, type CreditAnalytics, type CreditBalance, type CreditComponentInput, type CreditDetail, type CreditInput, type CreditSignal, type CustomerBalances, type CustomerList, type CustomerPlan, type CustomerPlanDetails, type CustomerProfileInput, type DropReason, type FetchLike, type FlatComponentInput, type FlatUnitInput, ForbiddenError, type Invoice, type InvoiceDetail, type InvoiceLineItem, type InvoiceListRow, type InvoiceParty, type InvoicePlanSnapshot, type InvoiceStatus, type Logger, type Member, type MemberProfile, type Model, type ModelBundleEntry, NetworkError, NotFoundError, type Outcome, type OutcomeAdjustInput, type OutcomeAnalytics, type OutcomeBalance, type OutcomeComponentInput, type OutcomeDetail, type OutcomeInput, type OutcomeSignal, type OutcomeStepInput, type PayLink, type PaymentDetail, type PaymentRow, type Plan, type PlanComponent, type PlanComponentInput, type PlanDetail, PlanError, type PlanKind, type PlanRef, type PlanType, type PortalToken, type PortalTokenInput, type Purchase, type PurchaseDetail, type PurchaseStatus, RateLimitError, type RemovedMember, type SerializedOutcomeAttribution, type SerializedRuleApplication, type SerializedUnitUsage, type SerializedUsageLog, ServerError, type Signal, type SignalDelivery, type SignalStatus, type SignalType, type ThresholdKind, type TieredUnitInput, type Tokens, type TrackResult, type Unit, type UnitAdjustInput, type UnitBalance, type UnitComponentInput, type UnitCustomerRow, type UnitDetail, type UnitInput, type UnitPricingType, type UnitTier, type UnitTierInput, type UnitTrackResult, type UnitUsageList, type UnitUsageRow, type UpdateCreditInput, type UpdateMemberInput, type UpdateOutcomeInput, type UpdatePlanInput, type UpdateUnitInput, type UpsertWebhookInput, type UsageBalance, type UsageList, ValidationError, type WalletComponentInput, type WalletEntitlementKind, type WalletEntryInput, type WalletInput, type WalletList, type WalletSignal, type WalletTransaction, type WalletTransactionSource, type WalletTransactionType, type Webhook, type WorkspaceIdentity, signalToWire };