@niadra/sdk 0.1.1 → 0.7.0

package/dist/index.d.cts

@@ -1,1382 +1,1047 @@
+import { C as ConstraintsBlock, H as HardConstraint, N as NiadraError, a as ClaimRecord, b as ClaimCategory, I as InternalText, s as shingles, c as Niadra, R as Resolvers, d as ContextResponse, M as Mode, T as TurnPins, e as RawBinding, f as ContextResult, g as ModelUsage, L as Logger, S as SubjectKind, h as Handle, O as ObjectRef } from './client-DsIxZxZk.cjs';
+export { A as AGENT_MEMORY_TOOL_DEFINITIONS, i as AGENT_MEMORY_TOOL_NAMES, j as ActionEvent, k as ActionInfo, l as Actions, m as Admin, n as AgentMemoryBlock, o as AgentMemoryParams, p as AgentMemoryResult, q as AgentMemorySearchRequest, r as AgentMemorySearchResponse, t as AgentMemorySource, u as AgentNote, v as AgentNoteKind, w as AgentNoteOrigin, x as AgentNoteProposal, y as AgentNoteStatus, z as AgentNoteVisibility, B as AgentSession, D as AgentState, E as AgentStateConflict, F as AgentStateHandle, G as AgentStateMeta, J as AgentStateMetaPage, K as AgentStateReadRequest, P as AgentStateScope, Q as AgentStateWrite, U as AgentStateWriteResult, V as AgentTurnOptions, W as AnchorEvidence, X as Api, Y as ArmComparison, Z as ArmOutcomes, _ as AskedAttribute, $ as AssertionMethod, a0 as AssertionOutcome, a1 as AssertionStats, a2 as Attribute, a3 as AttributeEntry, a4 as AttributionReport, a5 as AttributionRow, a6 as AttributionTotal, a7 as Backing, a8 as BackingReport, a9 as BackingSources, aa as BatchItem, ab as BatchRequest, ac as BatchResponse, ad as BiFile, ae as BiUpload, af as BiUploadRequest, ag as BlobError, ah as BlobStore, ai as BlockSubject, aj as BoundArg, ak as BoundTools, al as BudgetBlock, am as BudgetCut, an as BudgetPack, ao as BudgetUse, ap as CacheDirectives, aq as CacheOptions, ar as CallCapture, as as CaseClosed, at as CaseOpened, au as Change, av as ChangePage, aw as ChangeSinceSeen, ax as ChannelState, ay as CheckBatchRequest, az as CheckBatchResponse, aA as CheckOptions, aB as CheckRequest, aC as CheckResult, aD as ClaimCheck, aE as ClaimCheckOptions, aF as ClaimContractSummary, aG as ClaimEvidence, aH as ClaimEvidenceRef, aI as ClaimKind, aJ as ClaimOutputs, aK as ClaimParams, aL as ClaimRelease, aM as ClaimRequest, aN as ClaimValue, aO as ClaimVerdict, aP as ClaimVia, aQ as Claimed, aR as ClientOptions, aS as Closes, aT as Commitment, aU as CommitmentDecided, aV as CommitmentDecidedDetail, aW as CommitmentMade, aX as CommitmentMadeDetail, aY as CommitmentRef, aZ as CommitmentWithdrawn, a_ as CommitmentWithdrawnDetail, a$ as CompanyRule, b0 as Conflict, b1 as ConflictCounts, b2 as ConstraintOrigin, b3 as ConstraintsRequest, b4 as ContactBudget, b5 as ContactBudgetUse, b6 as ContactClaims, b7 as ContactCount, b8 as ContactGateway, b9 as ContactKey, ba as ContactKeys, bb as ContactMade, bc as ContactMadeDetail, bd as ContactTokenParams, be as ContactTokenRefusal, bf as Content, bg as ContentMarker, bh as ContentMode, bi as ContentRelease, bj as ContentReleaseResult, bk as ContentResolver, bl as ContextFormat, bm as ContextOptions, bn as ContextPack, bo as ContextParams, bp as ContextRequest, bq as ContextSource, br as ContextStamp, bs as ContextUseEntry, bt as Conversation, bu as ConversationAction, bv as ConversationEndedItem, bw as ConversationEvent, bx as ConversationParams, by as CoordinationBlock, bz as CoordinationOverview, bA as CoordinationReport, bB as CoordinationReportPage, bC as CorrectParams, bD as CorrectionAction, bE as CorrectionRequest, bF as CounterfactualCase, bG as CounterfactualEngaged, bH as CounterfactualEngagement, bI as CounterfactualRunCreate, bJ as CounterfactualRunPage, bK as CreateAgentNoteRequest, bL as DEFAULT_CACHE, bM as DEFAULT_QUEUE, bN as DEFAULT_TIMEOUTS, bO as DEFAULT_VOICE, bP as DELETE, bQ as DataIssue, bR as DataIssuePage, bS as Declarations, bT as DeclareRequest, bU as DeclareResult, bV as DeliveryPath, bW as Detect, bX as DriftChanges, bY as Effect, bZ as EffectCount, b_ as EffectDeclared, b$ as EffectDetail, c0 as EffectKind, c1 as EffectReserve, c2 as EffectSeen, c3 as EffectSettle, c4 as EffectState, c5 as EffectStatus, c6 as Engaged, c7 as EpisodeOut, c8 as Erasure, c9 as EventItem, ca as EventKind, cb as Evidence, cc as ExperimentReport, cd as ExperimentResult, ce as ExportPackage, cf as FAIL_CLOSED, cg as FactHistory, ch as FactOut, ci as Feature, cj as Feedback, ck as FeedbackAction, cl as FeedbackParams, cm as FeedbackRequest, cn as Fetched, co as FieldCoverage, cp as FieldState, cq as ForgetTarget, cr as GatewayOptions, cs as Guard, ct as GuardLike, cu as GuardOptions, cv as Guarded, cw as HandleType, cx as Handoff, cy as HandoffContext, cz as HandoffCreate, cA as HandoffDeclared, cB as HandoffDetail, cC as HandoffItem, cD as HandoffOutcome, cE as HandoffPackage, cF as HandoffParams, cG as HeartbeatItem, cH as HistoryFilters, cI as HistoryItem, cJ as HistoryItemKind, cK as IdentifyItem, cL as IdentifyParams, cM as IdentityCalibration, cN as Include, cO as Inference, cP as InferenceCorrection, cQ as InferencePage, cR as IngestStatus, cS as InterestState, cT as InterleavingReport, cU as InterleavingRow, cV as InterleavingTotal, cW as InternalText, cX as ItemError, cY as ItemVersion, cZ as KeyIdentity, c_ as LeaseDeclared, c$ as LeaseDetail, d0 as LegalHold, d1 as LegalHoldCreate, d2 as LegalHoldRelease, d3 as LiveTurn, d4 as Lock, d5 as MAX_BATCH_ITEMS, d6 as MAX_EVENT_TEXT, d7 as MAX_MEDIA_BYTES, d8 as MediaUpload, d9 as MediaUploadRequest, da as MediaUploadResponse, db as MemorySeen, dc as NOT_FOUND, dd as Natures, de as Negation, df as NiadraAPIError, dg as NiadraAbortError, dh as NiadraAuthenticationError, di as NiadraConfigError, dj as NiadraConnectionError, dk as NiadraContactTokenError, dl as NiadraPermissionError, dm as NiadraRateLimitError, dn as NiadraReplayRefusedError, dp as NiadraTimeoutError, dq as NiadraValidationError, dr as Notification, ds as NotificationPage, dt as ObjectCoverage, du as ObjectPush, dv as ObjectPushRequest, dw as ObjectPushResponse, dx as ObjectRead, dy as ObjectSnapshotResponse, dz as ObjectTimeline, dA as ObjectTimelineParams, dB as Observation, dC as OpenItemOut, dD as OpenItemRequest, dE as OpenObject, dF as OpenParams, dG as OpenedItem, dH as Origin, dI as OutcomeLink, dJ as OutcomePage, dK as OutcomeRequest, dL as OutcomeState, dM as Owner, dN as OwnershipClaim, dO as OwnershipCount, dP as PERSONAL_DATA_TOOL_ERROR, dQ as PackGuard, dR as PackLayer, dS as PackSection, dT as PackSlot, dU as PackSlotDerived, dV as PackStamp, dW as PowerRequest, dX as PowerResult, dY as Preference, dZ as PrefetchParams, d_ as PrefetchRequest, d$ as Presented, e0 as PresentedItem, e1 as PreviousValue, e2 as Problem, e3 as ProfileMatch, e4 as ProfileMemory, e5 as PromiseRef, e6 as PromoteRequest, e7 as PromoteResponse, e8 as ProposalStatus, e9 as Provenance, ea as QueueOptions, eb as ReadingResult, ec as ReconcileRequest, ed as ReconcileResult, ee as ReconciledLine, ef as RecordedToolOptions, eg as Recurrence, eh as Refetch, ei as RefreshRelease, ej as RefreshReleased, ek as RefreshRequest, el as RefreshRequestPage, em as Refusal, en as ReleaseDetail, eo as RememberParams, ep as RememberResult, eq as Rendered, er as ReplayAssertion, es as ReplayBlocker, et as ReplayCase, eu as ReplayCaseRequest, ev as ReplayHistoryEntry, ew as ReplayResult, ex as RequestOptions, ey as Resolved, ez as Resolver, eA as Result, eB as ResultObjects, eC as ReviewRequest, eD as ReviewRequestCreate, eE as ReviewRequestPage, eF as ReviewResolution, eG as Scenario, eH as ScenarioCreate, eI as ScenarioFromReport, eJ as ScenarioPage, eK as ScenarioRun, eL as ScenarioRunCreate, eM as ScenarioRunSummary, eN as ScenarioUpdate, eO as ScenarioVerdict, eP as SdkProfile, eQ as SearchRequest, eR as SearchResponse, eS as Seen, eT as SeenTokens, eU as ShadowRequest, eV as ShadowRun, eW as Shown, eX as SlotChannelRank, eY as SlotWhy, eZ as SoftConstraint, e_ as SourceCoverage, e$ as Speaker, f0 as SpeakerRef, f1 as StateMode, f2 as StateReadRequest, f3 as StateReadResponse, f4 as StateRef, f5 as StateVerifyRequest, f6 as StateVerifyResponse, f7 as StateView, f8 as StateViewRequest, f9 as StateWrite, fa as Subject, fb as SubjectToken, fc as SubjectTokenRequest, fd as Suppression, fe as SuppressionAdded, ff as SuppressionAddedDetail, fg as SuppressionLifted, fh as SuppressionLiftedDetail, fi as SuppressionPage, fj as SuppressionSalt, fk as TOOL_DEFINITIONS, fl as TOOL_NAMES, fm as TargetModel, fn as Task, fo as TaskAction, fp as TaskEndedItem, fq as TaskEvent, fr as TaskLockDeclared, fs as TaskLockDetail, ft as TaskParams, fu as TimeWindow, fv as TimelineRequest, fw as TimelineResponse, fx as Timeouts, fy as TimerState, fz as Timestamp, fA as Timings, fB as ToolBinding, fC as ToolCapabilities, fD as ToolDefinition, fE as ToolOptions, fF as TrackEvent, fG as TraitOut, fH as TurnAgent, fI as TurnBlob, fJ as TurnBuild, fK as TurnCall, fL as TurnCompilerPins, fM as TurnConstraints, fN as TurnCoordination, fO as TurnCost, fP as TurnEffect, fQ as TurnFlag, fR as TurnFrame, fS as TurnIndexEntry, fT as TurnIndexPage, fU as TurnKind, fV as TurnObservation, fW as TurnOptions, fX as TurnOutput, fY as TurnParams, fZ as TurnProvenance, f_ as TurnRead, f$ as TurnRecord, g0 as TurnRecorder, g1 as TurnRecordingOptions, g2 as TurnRecordingSummary, g3 as TurnSearchRequest, g4 as TurnSearchResponse, g5 as TurnSummary, g6 as TurnTokens, g7 as TurnView, g8 as TurnsRequest, g9 as TurnsResponse, ga as TypeCoverage, gb as TypeFingerprintRequest, gc as TypeFingerprintResponse, gd as UnbackedValue, ge as UnmetDemand, gf as UnmetDemandPage, gg as Unwatch, gh as UploadParams, gi as ValueEvidence, gj as ValueKind, gk as ValueState, gl as Verdict, gm as Verification, gn as VerificationResult, go as VerifyCheck, gp as VerifyItem, gq as VerifyMethod, gr as VerifyParams, gs as View, gt as Visibility, gu as VoiceInfo, gv as VoiceOptions, gw as Watch, gx as WhereExpression, gy as WorkingState, gz as WriteResult, gA as checkBacking, gB as consoleLogger, gC as currentCall, gD as currentTurn, gE as guardStream, gF as guardText, gG as recipientHash, gH as renderLive, gI as renderSuffix, gJ as silentLogger, gK as tool, gL as verifyContactToken, gM as violatesGuard } from './client-DsIxZxZk.cjs';
+
 /**
- * The contract vocabulary. Every value here travels through the public API unchanged and
- * never changes meaning within `/v1`, so the SDK mirrors it as string literal unions.
+ * The constraints block rendered for one tool call (`spec/constraints.md`, sections 6 and 7): what the
+ * call's arguments can carry through the tool's binding, what they cannot (the residual), and, after the
+ * call, how much of what was sent the results honored. The server runs the same rules for
+ * `POST /v1/constraints` with a tool.
+ *
+ * - A hard constraint renders through the binding argument of its field: `in` and `eq` to the argument,
+ *   `not_in` and `ne` to its negation parameter, a comparison or `between` only to an argument that
+ *   declares it in `ops`. One value renders as itself, several as a list; `transform` changes the case of
+ *   text.
+ * - A hard constraint that lost a conflict of the block is not rendered at all.
+ * - A constraint of a category holds only for a call of that category.
+ * - An attribute renders through the argument of its family (`size` for `size.pants`) when it applies:
+ *   `always`, or `when_asked` and the person asked for it this turn.
+ * - What no argument can express is residual: the SDK filters it from the results when the tool
+ *   overfetches, and it is otherwise unenforced. `exclude` is always residual.
+ * - Advisory mode (the default) changes nothing and suggests. Apply mode adds only what the call left out,
+ *   and only a hard constraint said in this turn or this session, or an attribute the person said; it never
+ *   overrides an argument the call set (the current utterance wins, and the clash is reported as a
+ *   conflict), and never adds an inferred size.
+ * - A block for another beneficiary than the call's does not apply at all.
+ *
+ * The same rules as the Python SDK's `niadra.constraints.render`.
  */
-/** What an event records: something said, something a system reported, or something an agent did. */
-type EventKind = "message" | "system_event" | "action";
-/** Who produced a turn. */
-type Speaker = "customer" | "ai_agent" | "human_agent" | "system";
-/** `internal` events (notes between agents, system traces) never reach a customer-facing view. */
-type Visibility = "public" | "internal";
-/** Subjects are people by default; accounts and partners are organizations. */
-type SubjectKind = "person" | "account" | "partner";
+
+type Op = HardConstraint["op"];
+/** One argument of a tool's binding (`tool-bindings`): the field it carries and how. */
+interface BindingArg {
+    /** The field, `type.field`. */
+    attr: string;
+    param: string;
+    transform?: "lower" | "upper" | null;
+    /** The parameter that carries the field's negation (`not_in`, `ne`). */
+    negation?: string | null;
+    /** The comparisons the parameter accepts besides `in` and `eq`. */
+    ops?: readonly string[];
+    /** The attribute family of the field (`size`), from the type registry. */
+    family?: string | null;
+}
+interface Binding {
+    tool: string;
+    args: readonly BindingArg[];
+    /** The tool returns more than asked, so the SDK can filter the residual from its results. */
+    overfetch?: boolean;
+}
+/** The call the model made. */
+interface Call$1 {
+    args: Readonly<Record<string, unknown>>;
+    /** Whose call it is: `self` (the default), `beneficiary:<id>` or `gift`. */
+    for?: string;
+    category?: string | null;
+    /** The attributes the person asked to use this turn ("in my size": `size`). */
+    asked?: readonly string[];
+}
+interface Rendering {
+    applies: boolean;
+    /** What the call sends: its own arguments, plus what apply mode added. */
+    args: Record<string, unknown>;
+    suggested: Record<string, unknown>;
+    injected: string[];
+    hardSent: string[];
+    residual: string[];
+    postFilter: string[];
+    /** A hard constraint and the argument the call set against it. */
+    conflicts: {
+        id: string;
+        param: string;
+    }[];
+}
+/** What the results show of the hard constraints sent: "sent, verifiable, violated", never only sent. */
+interface Honored {
+    resultsChecked: number;
+    violations: number;
+    /** Results without the constrained field: without this count, conformance lies upward. */
+    unverifiable: number;
+}
+/** The block for one call of the tool `binding` describes. */
+declare function render(block: ConstraintsBlock, binding: Binding, call: Call$1, mode?: "advisory" | "apply"): Rendering;
 /**
- * How a handle identifies a subject. Scoped types (`wa_bsuid`, `system_id`, `gov_id_hmac`,
- * `org_registry_hmac`) need `scope` so the same value in two namespaces never collides.
+ * Each result item, keyed by `type.field`, is a violation when it breaks a hard constraint that was sent,
+ * and unverifiable when it breaks none but lacks the field of one.
  */
-type HandleType = "phone_e164" | "wa_id" | "wa_jid" | "wa_lid" | "wa_bsuid" | "email" | "gov_id_hmac" | "app_user_id" | "system_id" | "org_registry_hmac" | "email_domain" | "anon_id";
-/** How an `identify` call learned that several handles belong together. */
-type AssertionMethod = "explicit_identify" | "otp" | "login" | "system_import" | "same_event" | "co_occurrence" | "channel_rotation" | "accepted_suggestion" | "external_resolver" | "declared";
+declare function honored(block: ConstraintsBlock, sentIds: readonly string[], results: readonly Readonly<Record<string, unknown>>[]): Honored;
+/** Whether `value` honors `op` over `values`; text is compared folded, numbers as exact decimals. */
+declare function satisfies(op: Op, values: readonly unknown[], value: unknown): boolean;
+
 /**
- * Session verification level. `V0` is an unverified contact and `V4` the strongest proof;
- * `no_customer` marks internal work with no customer on the other side.
+ * The digest of a value a turn record carries: SHA-256 over its canonical JSON (RFC 8785).
+ *
+ * The canonical form leaves no whitespace, sorts object keys by their UTF-16 code units and writes numbers
+ * as ECMAScript does, so a producer in any language hashes the same value to the same digest. The Turn
+ * Record spec fixes it (section 6.2.1) with the vectors in `spec/vectors/turn-record-digest.v0.json`.
  */
-type Verification = "V0" | "V1" | "V2" | "V3" | "V4" | "no_customer";
-/** How a customer proved who they are in a `verify` call. */
-type VerifyMethod = "otp_whatsapp" | "otp_sms" | "login" | "kba" | "network_attestation" | "human_agent";
 /**
- * Which read tier answered a `context()` call. `holdout` means the conversation fell in the
- * control group: the pack is intentionally empty and the SDK treats it as a normal answer.
+ * `value` (JSON data: plain objects, arrays, strings, finite numbers, booleans and `null`) as its
+ * canonical JSON. A property whose value is `undefined` is left out, as `JSON.stringify` does; anything
+ * JSON cannot hold (`NaN`, a `bigint`, a `Date`) throws.
  */
-type DeliveryPath = "t0" | "t1" | "t2" | "t3" | "t4" | "holdout" | "not_modified";
+declare function canonicalJson(value: unknown): string;
 /**
- * Kinds of history items the navigation calls can filter on. A system event is never an item: it
- * changes its object's state, so filter on `object`.
+ * `value`'s digest, written `sha256:<hex>`, and the size in bytes of its canonical JSON (UTF-8). Web
+ * Crypto hashes asynchronously, so the turn capture hashes when it sends, never on the agent's path.
  */
-type HistoryItemKind = "episode" | "fact" | "open_item" | "action" | "object" | "trait";
+declare function jsonDigest(value: unknown): Promise<{
+    sha256: string;
+    size: number;
+}>;
+
 /**
- * The shape of the pack. Channel views (`voice`, `chat`) size it for the medium; `account`
- * and `partner` read an organization; `task:<name>` views serve internal agents.
+ * The four logical values of a field (`spec/object-type.md`, section 5.4): not observed is never false.
  */
-type View = "voice" | "chat" | "brief" | "full" | "custom" | "account" | "partner" | `task:${string}`;
+type Logic = "yes" | "no" | "unobserved" | "known_defect";
+/** The two logical values that say nothing about the value. */
+type UnknownLogic = "unobserved" | "known_defect";
 
 /**
- * An identifier of a subject in some channel or system: a phone number, an e-mail address,
- * a CRM id. Handles carry personal data, so the SDK only ever sends them in request bodies.
+ * niadra-expr: the language of the type registry's conditions, timers, keys and readings
+ * (`spec/object-type.md`, section 5).
+ *
+ * Small, deterministic and total: literals, names, comparison, `in`, `and`, `or`, `not`, `+`, `-` and a
+ * fixed set of functions; no loop, no I/O, and bounded text, tokens and nesting. Every value carries one of
+ * the four logical values, so a comparison with a value nobody observed is itself unobserved, never false.
+ * The server and both SDKs implement the same language and pass the same vectors
+ * (`spec/vectors/niadra-expr.v0.json`).
+ *
+ * `parse` reads the text, `compileExpression` also resolves its names against a type declaration (the
+ * registry's validation), and `evaluate` computes it over an `Environment`, the object's slots at one
+ * instant. Time is integer arithmetic, never the machine's time zone: a datetime is milliseconds since the
+ * epoch, a date the days since 1970-01-01, and the environment's UTC offset says where a day starts.
  */
-interface Handle {
-    type: HandleType;
-    /** Up to 320 characters. Phones are E.164 (`+5511987654321`). */
-    value: string;
-    /**
-     * Namespace for scoped identifiers: the WhatsApp Business account for `wa_bsuid`, the
-     * system for `system_id`, the country for `gov_id_hmac`.
-     */
-    scope?: string | null;
-    /** Defaults to `person` on the server, except for organization-only handle types. */
-    subject_kind?: SubjectKind | null;
-}
-/** A business object in a system of record, such as `invoice` / `erp` / `0823`. */
-interface ObjectRef {
-    type: string;
-    namespace: string;
-    id: string;
-}
-/** A participant of an event other than the speaker, for example the account a person acts for. */
-interface Subject {
-    kind: SubjectKind;
-    role?: string | null;
-    /** Between 1 and 16 handles. */
-    handles: Handle[];
-}
-/** Whether a source is still sending. `silent` means it stopped, so the pack may be missing recent turns. */
-interface SourceCoverage {
-    source_id: string;
-    status: "ok" | "silent" | (string & {});
-    last_event_at?: string | null;
-}
-/** RFC 9457 problem details, as returned with `application/problem+json`. */
-interface Problem {
-    type: string;
-    title: string;
-    status: number;
-    detail?: string | null;
-    /** Stable code from the versioned error catalog, such as `rate_limited` or `wrong_cell`. */
-    code: string;
-    request_id?: string | null;
-}
 
+/** The three errors of the language (`spec/object-type.md`, section 5.9). */
+type ExprErrorCode = "expr_invalid" | "expr_type" | "expr_limit";
 /**
- * Base class of every error the SDK produces. In the default fail-open mode these errors are
- * logged and returned in results rather than thrown; with `strict: true` they are thrown.
+ * `expr_invalid`: the text is not a valid expression, or names what the type does not declare;
+ * `expr_type`: a value of the wrong kind, or out of its domain, met during evaluation; `expr_limit`: a bound
+ * of the language was exceeded. The message says what, in words; only the code is part of the contract.
  */
-declare class NiadraError extends Error {
-    readonly name: string;
-}
-/** The client was built without a usable API key, or with an option the SDK cannot honour. */
-declare class NiadraConfigError extends NiadraError {
-    readonly name = "NiadraConfigError";
-}
-/** A request failed validation before it left the process. Nothing was sent. */
-declare class NiadraValidationError extends NiadraError {
-    readonly name = "NiadraValidationError";
-}
-/** The request did not finish within its time budget. */
-declare class NiadraTimeoutError extends NiadraError {
-    readonly timeoutMs: number;
-    readonly name = "NiadraTimeoutError";
-    constructor(timeoutMs: number);
-}
-/** The network call failed before an HTTP response arrived (DNS, TLS, reset connection). */
-declare class NiadraConnectionError extends NiadraError {
-    readonly name = "NiadraConnectionError";
-}
-/** The request was cancelled through the caller's `AbortSignal`. */
-declare class NiadraAbortError extends NiadraError {
-    readonly name = "NiadraAbortError";
+declare class ExprError extends NiadraError {
+    readonly code: ExprErrorCode;
+    readonly name = "ExprError";
+    constructor(code: ExprErrorCode, message: string);
+}
+/** The kind of a present value; business days and a quote exist only inside an expression. */
+type Kind = "bool" | "number" | "string" | "duration" | "date" | "datetime" | "list" | "business_days" | "quote";
+/** A named list of holidays and the weekdays that are never business days. */
+interface Calendar {
+    /** Days since 1970-01-01, as `parseDate` gives them. */
+    readonly holidays?: ReadonlySet<number>;
+    /** ISO weekdays (1 is Monday) that are never business days; Saturday and Sunday unless given. */
+    readonly weekend?: ReadonlySet<number>;
+}
+/** A whole count of business days on a calendar, to add to or subtract from a date. */
+interface BusinessDays {
+    readonly count: number;
+    readonly calendar: Calendar;
+}
+interface Unknown {
+    readonly logic: UnknownLogic;
+    readonly kind?: undefined;
+}
+interface Absent {
+    readonly logic: "no";
+    readonly kind?: undefined;
+    /** The declared name of the absence, when there is one. */
+    readonly absent?: string;
+}
+interface Bool {
+    readonly logic: "yes" | "no";
+    readonly kind: "bool";
+    readonly datum: boolean;
+}
+interface Present<K extends Kind, D> {
+    readonly logic: "yes";
+    readonly kind: K;
+    readonly datum: D;
+}
+type DateValue = Present<"date", number>;
+type DatetimeValue = Present<"datetime", number>;
+/**
+ * A value and its logical value. A known value is present (`yes`, or a boolean, `no` when false) or absent
+ * (`no` with no kind, and the declared name of the absence when there is one); an unknown one carries
+ * nothing.
+ *
+ * Data: a boolean, a number (an IEEE 754 double), a string, whole milliseconds for a duration, days since
+ * 1970-01-01 for a date, milliseconds since the epoch for a datetime, the values of a list, a count on a
+ * calendar for business days, and the slots of a quote by field.
+ */
+type Value$1 = Unknown | Absent | Bool | Present<"number", number> | Present<"string", string> | Present<"duration", number> | DateValue | DatetimeValue | Present<"list", readonly Value$1[]> | Present<"business_days", BusinessDays> | Present<"quote", Readonly<Record<string, Slot>>>;
+/**
+ * One field, computed value, time axis or input of an object as a reading sees it: the value, when a
+ * source observed it (`at`, milliseconds since the epoch), by whom, its value before the latest change, and
+ * the completeness level of a content field.
+ */
+interface Slot {
+    readonly value: Value$1;
+    readonly at?: number;
+    /** `machine`, `human` or `source:<name>`. */
+    readonly observer?: string;
+    readonly was?: Value$1;
+    readonly completeness?: string;
 }
 /**
- * The API answered with an error status. `code` comes from the problem document when the
- * server sent one; `requestId` is what Niadra support needs to find the call.
+ * What an evaluation reads (`spec/object-type.md`, section 5.11): the current instant, the object's slots
+ * (fields, computed values and time axes by name), the declared inputs by dotted path, the absence names,
+ * the company's configuration by key, the reader's quotes by source, the calendars by name, and the
+ * context names.
  */
-declare class NiadraAPIError extends NiadraError {
+interface Environment {
+    /** Milliseconds since the epoch. */
+    readonly now: number;
+    /** Minutes east of UTC, where a date's day starts; 0 unless given. */
+    readonly utcOffsetMin?: number;
+    readonly fields?: Readonly<Record<string, Slot>>;
+    readonly inputs?: Readonly<Record<string, Slot>>;
+    readonly absentNames?: ReadonlySet<string>;
+    readonly config?: Readonly<Record<string, Value$1>>;
+    readonly quotes?: Readonly<Record<string, Readonly<Record<string, Slot>>>>;
+    readonly calendars?: Readonly<Record<string, Calendar>>;
+    /** The lifecycle state; absent unless given. */
+    readonly state?: string;
+    readonly derivedStatus?: string;
+    /** 0 unless given. */
+    readonly watchCount?: number;
+    /** The read's purpose; `display` unless given. */
+    readonly purpose?: string;
+    /** The object's best position presented in the conversation. */
+    readonly presentedRank?: number;
+}
+/** `true` or `false`: `yes` or `no`, of kind `bool`. */
+declare const boolean: (flag: boolean) => Value$1;
+/** A value nobody observed, or one whose source is known to get it wrong. */
+declare const unknown: (logic: UnknownLogic) => Value$1;
+/** An absence: the source affirmed there is no value, under a declared name when it gives one. */
+declare const absent: (name?: string) => Value$1;
+interface NameNode {
+    readonly node: "name";
+    readonly parts: readonly [string, ...string[]];
+}
+type Comparison = "==" | "!=" | "<" | "<=" | ">" | ">=" | "in";
+/** A call, with each function's arguments in their fixed form (`spec/object-type.md`, section 5.7). */
+type Call = {
+    readonly node: "call";
+    readonly fn: "now";
+} | {
+    readonly node: "call";
+    readonly fn: "age" | "observer" | "changed";
+    readonly ref: NameNode;
+} | {
+    readonly node: "call";
+    readonly fn: "was" | "count";
+    readonly arg: Node;
+} | {
+    readonly node: "call";
+    readonly fn: "business_days";
+    readonly count: Node;
+    readonly calendar: string;
+} | {
+    readonly node: "call";
+    readonly fn: "quote";
+    readonly source: string;
+} | {
+    readonly node: "call";
+    readonly fn: "presented_in_top";
+    readonly top: number;
+} | {
+    readonly node: "call";
+    readonly fn: "sha256";
+    readonly args: readonly Node[];
+};
+/** The syntax tree of an expression (`spec/object-type.md`, section 5.3), as `parse` gives it. */
+type Node = {
+    readonly node: "literal";
+    readonly value: Value$1;
+} | {
+    readonly node: "logical";
+    readonly logic: Logic;
+} | NameNode | {
+    readonly node: "member";
+    readonly target: Node;
     readonly name: string;
-    readonly status: number;
-    readonly code: string;
-    readonly requestId: string | null;
-    readonly problem: Problem | null;
-    /** How long the server asked callers to wait, from `Retry-After`, when it said so. */
-    readonly retryAfterMs: number | null;
-    constructor(status: number, problem: Problem | null, requestId: string | null, retryAfterMs?: number | null);
-}
-/** 401: the key is missing, malformed, rotated or revoked. */
-declare class NiadraAuthenticationError extends NiadraAPIError {
-    readonly name = "NiadraAuthenticationError";
-}
-/** 403: the key is valid but lacks the scope, or its source was cut off. */
-declare class NiadraPermissionError extends NiadraAPIError {
-    readonly name = "NiadraPermissionError";
-}
-/** 429: over the rate limit. Batches wait `retryAfterMs` before trying again. */
-declare class NiadraRateLimitError extends NiadraAPIError {
-    readonly name = "NiadraRateLimitError";
-}
-
-/** The read side: `POST /v1/context` and the history navigation calls. */
+} | Call | {
+    readonly node: "list";
+    readonly items: readonly Node[];
+} | {
+    readonly node: "not";
+    readonly operand: Node;
+} | {
+    readonly node: "boolean";
+    readonly op: "and" | "or";
+    readonly operands: readonly Node[];
+} | {
+    readonly node: "compare";
+    readonly op: Comparison;
+    readonly left: Node;
+    readonly right: Node;
+} | {
+    readonly node: "arith";
+    readonly op: "+" | "-";
+    readonly left: Node;
+    readonly right: Node;
+};
+/** Names a type may not give a field, a value, a time axis or an absence (`spec/object-type.md`, section 5.5). */
+declare const RESERVED: ReadonlySet<string>;
+/** The syntax tree of an expression, or `ExprError` (`expr_invalid`, `expr_limit`). */
+declare function parse(text: string): Node;
+/**
+ * The value of a parsed expression over an environment, or `ExprError` (`expr_type`, `expr_limit`). A
+ * business-day count or a quote is a step, never a result.
+ */
+declare function evaluate(node: Node, env: Environment): Value$1;
+/** A `YYYY-MM-DD` date as days since 1970-01-01; a `RangeError` for anything else. */
+declare function parseDate(text: string): number;
+/** A day since 1970-01-01 as `YYYY-MM-DD`. */
+declare function formatDate(days: number): string;
+/**
+ * An RFC 3339 time with its offset as milliseconds since the epoch; digits below the millisecond are
+ * dropped. A `RangeError` for anything else, a time without an offset included.
+ */
+declare function parseDatetime(text: string): number;
+/** The canonical form of an instant: UTC, with milliseconds (`2026-09-29T12:00:00.000Z`). */
+declare function formatDatetime(ms: number): string;
+/**
+ * What a type declares, as the names of its expressions resolve: its fields with their kind (`null` when
+ * the declaration fixes none), the fields with completeness levels, computed values, time axes, absence
+ * names, inputs, states, and sources with their kind (`pull`, `quote`...).
+ */
+interface Scope {
+    readonly fields?: Readonly<Record<string, Kind | null>>;
+    readonly completeness?: ReadonlySet<string>;
+    readonly values?: ReadonlySet<string>;
+    readonly axes?: ReadonlySet<string>;
+    readonly absentNames?: ReadonlySet<string>;
+    readonly inputs?: ReadonlySet<string>;
+    readonly states?: ReadonlySet<string>;
+    readonly sources?: Readonly<Record<string, string>>;
+}
+/** What an entry of a type expects its expression to give: anything, a condition, or a time. */
+type Expect = "any" | "condition" | "time";
+/**
+ * Parses and resolves an expression of a type declaration (`spec/object-type.md`, section 5.12);
+ * `expr_invalid` names what is wrong.
+ */
+declare function compileExpression(text: string, scope: Scope, expect?: Expect): Node;
+/** A duration literal (`30s`, `10min`, `24h`, `7d`) in milliseconds, as the declarations write them. */
+declare function durationMs(text: string): number;
 
-/** The model that will read the pack, so the server can aim at its prompt-cache floor. */
-interface TargetModel {
-    provider: string;
-    model: string;
-}
-/** Body of `POST /v1/context`. Exactly one of `subject` or `object` is required. */
-interface ContextRequest {
-    subject?: Handle | null;
-    object?: ObjectRef | null;
-    /** The account or partner the person acts for. */
-    about?: Handle | null;
-    view?: View;
-    verification?: Verification;
-    conversation_id?: string | null;
-    task_id?: string | null;
-    query?: string | null;
-    delta?: boolean;
-    target?: TargetModel | null;
-    known_etag?: string | null;
-}
-interface VerificationResult {
-    requested: Verification;
-    effective: Verification;
-    /** Why `effective` is lower than `requested`: `source_ceiling` or `not_proven`. */
-    reason?: string | null;
-}
-/** A recent turn from another channel that the compiled pack has not absorbed yet. */
-interface LiveTurn {
-    at: string;
-    channel: string;
-    kind: EventKind;
-    speaker: string;
-    text: string;
-    source_id: string;
-}
-/** Where a prompt-cache breakpoint may go, and whether caching this pack is worth it. */
-interface CacheDirectives {
-    /** Character offsets into `text` where a cache breakpoint may be placed. */
-    breakpoints: number[];
-    ttl_seconds?: number | null;
-    floor_tokens?: number | null;
-    cacheable: boolean;
-    /** Stable cache salt for self-hosted inference engines. */
-    salt: string;
-}
-/** Body of a `POST /v1/context` response. */
-interface ContextResponse {
-    /** `true` when `known_etag` still matches; `text` is then omitted. */
-    not_modified: boolean;
-    text?: string | null;
-    variables: Record<string, string>;
-    version: string;
-    etag: string;
-    manifest_hash?: string | null;
-    as_of?: string | null;
-    lag_seconds?: number | null;
-    coverage: SourceCoverage[];
-    verification: VerificationResult;
-    /** How many items policy or verification kept out of the pack. */
-    withheld: number;
-    live: LiveTurn[];
-    live_complete: boolean;
-    delta?: string | null;
-    cache?: CacheDirectives | null;
-    timing: Record<string, number>;
-    path: DeliveryPath;
-    degraded: boolean;
-}
-interface HistoryFilters {
-    since?: string | null;
-    until?: string | null;
-    channels?: string[];
-    categories?: string[];
-    item_kinds?: HistoryItemKind[];
-    outcome?: string | null;
-    object?: ObjectRef | null;
-}
-/** Body of `POST /v1/history/search`. */
-interface SearchRequest {
-    subject: Handle;
-    about?: Handle | null;
-    /** Between 1 and 2,000 characters. */
-    query: string;
-    filters?: HistoryFilters;
-    /** Token budget for the answer, between 50 and 4,000. Defaults to 800. */
-    max_tokens?: number;
-    verification?: Verification;
-    conversation_id?: string | null;
-    task_id?: string | null;
-}
-interface HistoryItem {
-    id: string;
-    kind: string;
-    text: string;
-    at: string;
-    channel?: string | null;
-    source_id?: string | null;
-    outcome?: string | null;
-    confidence?: number | null;
-    origin_event_id?: string | null;
-}
-/** How often the same kind of issue came back, computed by the same rule as the recurring-complaint pattern. */
-interface Recurrence {
-    category: string;
-    occurrences: number;
-    window_days: number;
-    last_at?: string | null;
-    last_outcome?: string | null;
-    last_resolution?: string | null;
-}
-interface SearchResponse {
-    items: HistoryItem[];
-    recurrence?: Recurrence | null;
-    withheld: number;
-    as_of?: string | null;
-    tokens_used: number;
-    /** `text_only` when semantic search was unavailable and only keyword matching ran. */
-    degraded?: string | null;
-}
-/** Body of `POST /v1/history/timeline`. */
-interface TimelineRequest {
-    subject: Handle;
-    about?: Handle | null;
-    filters?: HistoryFilters;
-    cursor?: string | null;
-    /** Between 1 and 100. Defaults to 20. */
-    limit?: number;
-    verification?: Verification;
-    conversation_id?: string | null;
+type expr_BusinessDays = BusinessDays;
+type expr_Calendar = Calendar;
+type expr_Environment = Environment;
+type expr_Expect = Expect;
+type expr_ExprError = ExprError;
+declare const expr_ExprError: typeof ExprError;
+type expr_ExprErrorCode = ExprErrorCode;
+type expr_Kind = Kind;
+type expr_Node = Node;
+declare const expr_RESERVED: typeof RESERVED;
+type expr_Scope = Scope;
+type expr_Slot = Slot;
+declare const expr_absent: typeof absent;
+declare const expr_boolean: typeof boolean;
+declare const expr_compileExpression: typeof compileExpression;
+declare const expr_durationMs: typeof durationMs;
+declare const expr_evaluate: typeof evaluate;
+declare const expr_formatDate: typeof formatDate;
+declare const expr_formatDatetime: typeof formatDatetime;
+declare const expr_parse: typeof parse;
+declare const expr_parseDate: typeof parseDate;
+declare const expr_parseDatetime: typeof parseDatetime;
+declare const expr_unknown: typeof unknown;
+declare namespace expr {
+  export { type expr_BusinessDays as BusinessDays, type expr_Calendar as Calendar, type expr_Environment as Environment, type expr_Expect as Expect, expr_ExprError as ExprError, type expr_ExprErrorCode as ExprErrorCode, type expr_Kind as Kind, type expr_Node as Node, expr_RESERVED as RESERVED, type expr_Scope as Scope, type expr_Slot as Slot, type Value$1 as Value, expr_absent as absent, expr_boolean as boolean, expr_compileExpression as compileExpression, expr_durationMs as durationMs, expr_evaluate as evaluate, expr_formatDate as formatDate, expr_formatDatetime as formatDatetime, expr_parse as parse, expr_parseDate as parseDate, expr_parseDatetime as parseDatetime, expr_unknown as unknown };
 }
+
 /**
- * Body of `POST /v1/history/open`. A conversation id may be a phone number or an e-mail, and the
- * customer is personal data, so neither goes in a URL.
+ * Decimals for the amounts the parser reads: `R$ 511,06` is 51106 hundredths, never a float, so every SDK
+ * writes and compares the same `"511.06"`. Arithmetic and the written form keep 28 significant digits, as
+ * the default context of Python's `decimal` does.
  */
-interface OpenItemRequest {
-    item_id: string;
-    /** The customer the item must belong to; any other item answers 404. */
-    subject?: Handle | null;
-    verification?: Verification;
-    conversation_id?: string | null;
-}
-interface TimelineResponse {
-    items: HistoryItem[];
-    next_cursor?: string | null;
-    withheld: number;
-    as_of?: string | null;
-}
-/** A commitment recorded in an episode, made by the company or by the customer. */
-interface Commitment {
-    by: "company" | "customer";
-    what: string;
-    due_at?: string | null;
-    status: string;
-}
-/** One history item opened in full: structured summary, outcome and commitments. */
-interface OpenedItem {
-    id: string;
-    kind: "episode" | "object";
-    summary: string;
-    requested?: string | null;
-    promises: Commitment[];
-    outcome?: string | null;
-    resolution?: string | null;
-    derived: HistoryItem[];
-    timeline: HistoryItem[];
-    /** The server no longer sends a transcript excerpt; the field stays for code that reads it. */
-    excerpt?: string | null;
-    as_of?: string | null;
-}
-/** The derived state of a business object, from `GET /v1/objects/{type}/{namespace}/{id}`. */
-interface ObjectState {
-    ref: ObjectRef;
-    state: Record<string, unknown>;
-    as_of: string;
-    source_id: string;
-    record_ref?: string | null;
-    open_items: HistoryItem[];
-}
-/** System events and agent actions about one object, newest first; never conversation content. */
-interface ObjectTimeline {
-    ref: ObjectRef;
-    items: HistoryItem[];
-    next_cursor?: string | null;
-    as_of?: string | null;
-}
-/** A function-calling tool definition in the JSON Schema shape most model APIs accept. */
-interface ToolDefinition {
-    type: "function";
-    function: {
-        name: string;
-        description: string;
-        parameters: Record<string, unknown>;
-    };
+/** `digits / 10 ** scale`; a negative scale multiplies. */
+interface Decimal {
+    readonly digits: bigint;
+    readonly scale: number;
 }
 
-/** Arguments of `context()`. Pass exactly one of `subject` or `object`. */
-interface ContextParams {
-    /** The customer, by any handle the server knows. */
-    subject?: Handle;
-    /** A business object, such as an invoice, when the task is about the object rather than a person. */
-    object?: ObjectRef | string;
-    /** The account or partner the person acts for. Requires an active link between the two. */
-    about?: Handle;
-    /** Defaults to `chat`. */
-    view?: View;
-    /**
-     * The level proven in this conversation. The server may answer with a lower effective level
-     * when the source's ceiling is lower; see `response.verification`.
-     */
-    verification?: Verification;
-    /** Enables the per-conversation cache and the server's pinning of the pack. */
-    conversation_id?: string;
-    /** For internal agents: the task plays the role of the conversation. */
-    task_id?: string;
-    /** What the turn is about, so selection can favour relevant history. Up to 2,000 characters. */
-    query?: string;
-    /** Ask only for what changed since this source last read the subject. */
-    delta?: boolean;
-    /** The model that will read the pack, so the server can size it for that model's prompt cache. */
-    target?: TargetModel;
-}
-/** Per-call options shared by every read method. */
-interface RequestOptions {
-    /** Overrides the method's default time budget, in milliseconds. */
-    timeout?: number | undefined;
-    /** Cancels the wait. A request shared with other callers keeps running for them. */
-    signal?: AbortSignal | undefined;
-    /** Extra headers, such as a W3C `traceparent`. */
-    headers?: Record<string, string> | undefined;
-}
-interface ContextOptions extends RequestOptions {
-    /** Pass `false` to skip the per-conversation cache for this call. */
-    cache?: boolean | undefined;
-}
 /**
- * Where a `context()` result came from.
+ * Offsets, words and sentences of an output, as every part of the claim checker reads them.
  *
- * - `network`: a response the server just sent (or confirmed unchanged).
- * - `cache`: a pack younger than the cache TTL; no request was made.
- * - `stale`: an older pack returned at once while a background request refreshes it.
- * - `fallback`: the request failed and this is the last good pack for the conversation.
- * - `none`: nothing was available; `text` is empty and `error` says why.
+ * Offsets are Unicode code points (the claim contract spec, section 2). The checker reads a text as one
+ * UTF-16 unit per code point (`units`), so every index a regular expression returns is a code point offset.
+ * Its patterns read `\w`, `\d`, `\s` and `\b` as Python's `re` does on text (`pattern`): the SDKs and the
+ * server's reference checker find the same numbers in the same places.
  */
-type ContextSource = "network" | "cache" | "stale" | "fallback" | "none";
-/** What `context()` resolves to. Always usable: on failure `text` is an empty string. */
-interface ContextResult {
-    /** The pack, ready for the system prompt. Empty when there is nothing to inject. */
-    text: string;
-    /**
-     * The parts that change turn by turn and belong at the end of the prompt, after the
-     * conversation: the delta and the live turns from other channels. Empty when there are none.
-     */
-    suffix: string;
-    /** Named values from the pack, for templates that place them individually. */
-    variables: Record<string, string>;
-    source: ContextSource;
-    /** The response this result was built from; `null` when `source` is `none`. */
-    response: ContextResponse | null;
-    /** What went wrong, when `source` is `fallback` or `none`. */
-    error: NiadraError | null;
-}
+/** A start and an end, in code points, end excluded. */
+type Span = readonly [number, number];
+
 /**
- * Renders the delta and the live turns for the end of the prompt. Kept outside the pinned
- * pack so that the prompt prefix stays byte-identical across turns and the model provider's
- * prompt cache keeps hitting. Returns an empty string when there is nothing to add.
+ * Numbers written in words, in Portuguese, English and Spanish, from zero to the millions: "quinze", "dois
+ * mil e quinhentos", "twenty-five", "doscientos treinta". The parser reads them only right before a unit, a
+ * currency or a percent word ("quinze dias úteis", "trezentos reais"): a number word alone is never a number,
+ * because "um", "one" and "un" are also articles.
  */
-declare function renderSuffix(response: ContextResponse): string;
+
+type Language = "pt" | "en" | "es";
+
 /**
- * Renders the live turns (recent turns from other channels that the pack has not absorbed
- * yet) as one tagged block, or an empty string when there are none. `complete="false"` tells
- * the model the list may be missing turns because the server could not read all of them.
+ * The numbers of an output, read by rules (the claim contract spec, section 5): each one with its class,
+ * its normalized value and its span, in Portuguese, English or Spanish.
+ *
+ * Every number of the text lands in at most one mention, found in this order, and a later step never takes
+ * what an earlier one took:
+ *
+ * 1. labels by shape: a case number, a postal code, a tax id, a phone, a time of day;
+ * 2. labels by the word before them: an order, a protocol, a statute's article, a size, a list position;
+ * 3. dates: ISO, numeric (day first in `pt` and `es`, month first in `en`), with month names, a month of a
+ *    year, "dia 20";
+ * 4. amounts with what follows or precedes them: money (a currency before or after, a scale like "mil"),
+ *    percent, duration, dose, quantity, installments ("10x"); written in digits, or in words right before
+ *    the unit; two of them joined by "a", "to", "-" (or "e", "and", "y" after "entre", "between") make a
+ *    range;
+ * 5. codes that mix letters and digits, and ordinals: labels;
+ * 6. the rest: a number with two decimals is money; an integer before a word is a count; five digits or
+ *    more, a leading zero or a year are labels; anything else is not read.
+ *
+ * A label is never a claim and is never rewritten.
  */
-declare function renderLive(response: ContextResponse): string;
+
+declare const LANGUAGES: readonly Language[];
+/** What a number measures; a `label` names something instead. */
+type MentionClass = "money" | "percent" | "date" | "duration" | "quantity" | "count" | "dosage" | "label";
+/** A number's normalized value (the claim contract spec, section 5.3), as vectors and turn records write it. */
+type Value = Readonly<Partial<Record<"amount" | "min" | "max" | "unit" | "date" | "date_from" | "date_to", string>>>;
+interface MentionFields {
+    amount?: Decimal;
+    low?: Decimal;
+    high?: Decimal;
+    unit?: string | null;
+    date?: string;
+    dateFrom?: string;
+    dateTo?: string;
+    written?: "digits" | "words";
+}
+/** A number of an output: its class, its span in code points and its value. */
+declare class Mention {
+    readonly cls: MentionClass;
+    readonly start: number;
+    readonly end: number;
+    /** Decimals as `decimalText` writes them. */
+    readonly amount: string | null;
+    readonly low: string | null;
+    readonly high: string | null;
+    readonly unit: string | null;
+    readonly date: string | null;
+    readonly dateFrom: string | null;
+    readonly dateTo: string | null;
+    readonly written: "digits" | "words";
+    constructor(cls: MentionClass, start: number, end: number, fields?: MentionFields);
+    /** The normalized value; a label has none. */
+    value(): Value | null;
+    get isRange(): boolean;
+}
+/** The numbers of `text` in the language `lang`, in the order they appear; offsets are code points. */
+declare function mentions(text: string, lang: Language): readonly Mention[];
 
 /**
- * The write side: items of `POST /v1/batch`. A batch mixes item types, and one bad item never
- * fails the batch; the server answers 207 with one error per rejected item.
+ * A number's role, from the words around it (the claim contract spec, section 6): the same R$ 511,06 is a
+ * full price, a discounted one or a price per person by what the sentence says next to it.
+ *
+ * A role's term counts within `WINDOW` words of the number, in the same sentence, and belongs to the nearest
+ * number of the same class (to both when two are as near). The nearest term gives the role, and at the same
+ * distance a term of the number's own beats one it shares; two terms of different roles still tied leave the
+ * number without one, `ambiguous`, which is never approved.
  */
 
-/** Longest text the server accepts in `content.text` or `content.transcript`. */
-declare const MAX_EVENT_TEXT = 200000;
-/** Largest batch the server accepts. */
-declare const MAX_BATCH_ITEMS = 500;
-/** Largest file `POST /v1/media/uploads` reserves room for: 500 MiB. */
-declare const MAX_MEDIA_BYTES: number;
-interface SpeakerRef {
-    role: Speaker;
-    /** Agent or attendant id inside the source. */
-    id?: string | null;
-}
-interface Content {
-    type?: "text" | "audio" | "image" | "file";
-    text?: string | null;
-    /** Reference returned by `/v1/media/uploads`; the media itself never travels in the event. */
-    media_ref?: string | null;
-    /** Lowercase hex SHA-256 of the media. */
-    media_sha256?: string | null;
-    transcript?: string | null;
-    /** Speech-to-text confidence between 0 and 1. Low-confidence agent turns are not measured. */
-    stt_confidence?: number | null;
-}
-interface VoiceInfo {
-    ani?: string | null;
-    dnis?: string | null;
-    trunk?: string | null;
-    network_attestation?: "A" | "B" | "C" | null;
-    answered_at?: string | null;
-    ended_at?: string | null;
-    end_reason?: string | null;
-    recording_ref?: string | null;
-    turn_offset_ms?: number | null;
-}
+/** Words between a number and a term of its role, at most. */
+declare const WINDOW = 6;
+interface Role {
+    readonly name: string | null;
+    readonly status: "matched" | "ambiguous" | "none";
+}
+/** The role of each of `numbers` (a category's mentions, in order), by the terms of `roles`. */
+declare function rolesOf(text: string, numbers: readonly Mention[], roles: Readonly<Record<string, readonly string[]>>): Role[];
+
 /**
- * The open item an action fulfils. Pass either `item_id`, or `object` together with the
- * canonical `operation`; the server rejects any other combination.
+ * The claim check (the claim contract spec, sections 4 to 8): the claims each category detects in an
+ * output, their nature, the verdict against what the turn holds, and the action the contract takes for the
+ * output's context.
+ *
+ * Detection: numbers of the category's classes (in a sentence with one of its terms, when it lists terms)
+ * that the output asserts (a hedged number, `hedges.ts`, is no claim), each occurrence of a term (when it
+ * lists terms and no classes), statute and precedent citations, and the sentences of named document
+ * sections. Nature, for a number: `quoted` inside quotation marks; `computed`
+ * when the turn holds a value of the same role, or the same value; `model` otherwise. Verdicts that stand
+ * (`matched`, `quoted_found`, `anchored`) take no action; `not_checked` is counted; every other one takes the
+ * category's action for the context, and `unsupported` the action its natures give to what the model said.
+ * A rewrite happens only when it is unequivocal (a stale copy of one field whose fresh value differs), and
+ * is a warning otherwise. Nothing is ever rewritten in an immutable output, and a block there sends the
+ * whole output to a person, untouched.
  */
-interface Closes {
-    item_id?: string | null;
-    object?: ObjectRef | null;
-    operation?: string | null;
-}
-interface ActionInfo {
-    /** Canonical operation, such as `credit` or `reschedule`. */
-    operation: string;
-    /** What happened, up to 2,000 characters. */
-    result?: string | null;
-    purpose?: string | null;
-    closes?: Closes | null;
-    corrects_action_id?: string | null;
+
+type Verdict = ClaimRecord["verdict"];
+/** What happened to a claim, as the turn record writes it. */
+type Action = ClaimRecord["action"];
+type Nature = NonNullable<ClaimRecord["nature"]>;
+/** A value with provenance the turn holds: a field of a tool's result or of a state read. */
+interface TurnValue {
+    readonly cls: MentionClass;
+    /** As `Mention.value()` writes it. */
+    readonly value: Value;
+    readonly role?: string | null;
+    /** True unless said otherwise. */
+    readonly fresh?: boolean;
+    readonly objectType?: string | null;
+    /** The field or computed value it is. */
+    readonly name?: string | null;
+    readonly callId?: string | null;
+    readonly ref?: string | null;
+    readonly declaredGaps?: readonly string[];
+}
+/** A passage an output cites, as the tool or the agent emitted it: where, what it quotes, from what. */
+interface Anchor {
+    readonly start: number;
+    readonly end: number;
+    readonly quote: string;
+    readonly document: string;
+}
+/** What the turn holds to check an output against. */
+interface Turn {
+    readonly values?: readonly TurnValue[];
+    /** The tools called in the turn. */
+    readonly tools?: readonly string[];
+    /** The documents in hand, by id: what quotes and anchors are checked against. */
+    readonly documents?: Readonly<Record<string, string>>;
+    readonly anchors?: readonly Anchor[];
+    /** The output's named sections, as spans, when it is a document. */
+    readonly sections?: Readonly<Record<string, readonly Span[]>>;
+}
+/** One claim a category found, its verdict and what happened to it. */
+interface Finding {
+    readonly category: string;
+    readonly start: number;
+    readonly end: number;
+    readonly verdict: Verdict;
+    readonly action: Action;
+    /** For a number. */
+    readonly cls: MentionClass | null;
+    readonly nature: Nature | null;
+    readonly role: string | null;
+    readonly value: Value | null;
+    readonly evidence: TurnValue | Anchor | null;
+}
+/** The text the check reads, in its language and context (`chat`, `proposal`, `contestacao`). */
+interface Output {
+    readonly text: string;
+    readonly lang: Language;
+    readonly context: string;
+    readonly immutable: boolean;
+    readonly agent?: string | null;
 }
 /**
- * Which context the agent's prompt carried and when it went in. Set on the agent's own turns
- * and actions, so measurement can tell a context that arrived after the agent spoke from one
- * it had and did not use.
+ * The same number: equal amounts (or ends of a range), or the same date; a unit only counts when both have
+ * one, so "511,06" is the R$ 511,06 of a tool's result.
  */
-interface ContextStamp {
-    /** The etag of the pack in the prompt; absent when the prompt carried no pack. */
-    etag?: string | null;
-    injected_at: string;
-}
+declare function sameValue(a: Value, b: Value): boolean;
 /**
- * What the model provider reported for the call behind an agent's turn. `wrap()` reads it from every
- * call it sees; without `wrap()`, pass it with the turn: `agent(text, { usage: response })` takes an
- * OpenAI or Anthropic response or a `ModelUsage`.
+ * `quoted` inside quotation marks; `computed` when the turn holds a value of the number's class with its
+ * role or its value; `model` otherwise.
  */
-interface ModelUsage {
-    /** Who served the call, lowercase: `openai`, `anthropic`, a router or a cloud. */
-    provider: string;
-    /** The model the provider says answered, such as `gpt-4.1-2025-04-14`. */
-    model: string;
-    /** Every input token, cached ones included. */
-    prompt_tokens: number;
-    /** Input tokens read from the provider's prompt cache. */
-    cached_tokens?: number;
-    /** Input tokens written to the cache (Anthropic's cache creation). */
-    cache_write_tokens?: number;
-}
-/** A message, a system event or an agent action, exactly as sent on the wire. */
-interface EventItem {
-    type: "event";
-    kind: EventKind;
-    idempotency_key: string;
-    channel: string;
-    conversation_id?: string | null;
-    conversation_aliases?: string[];
-    task_id?: string | null;
-    handles?: Handle[];
-    subjects?: Subject[];
-    object_refs?: ObjectRef[];
-    speaker: SpeakerRef;
-    direction?: "inbound" | "outbound" | null;
-    content?: Content | null;
-    occurred_at: string;
-    visibility?: Visibility;
-    verification_hint?: Verification | null;
-    /** System events only, such as `invoice.credited`. */
-    canonical_type?: string | null;
-    /** Structured fields of a system event. */
-    fields?: Record<string, unknown>;
-    action?: ActionInfo | null;
-    corrects_event_id?: string | null;
-    voice?: VoiceInfo | null;
-    context_stamp?: ContextStamp | null;
-    /** The model call behind an `ai_agent` message: tokens and prompt cache. */
-    usage?: ModelUsage | null;
-}
-/** States that several handles belong to the same subject. */
-interface IdentifyItem {
-    type: "identify";
-    idempotency_key: string;
-    /** Between 2 and 16 handles. */
-    handles: Handle[];
-    method: AssertionMethod;
-    subject_kind: SubjectKind;
-    conversation_id?: string | null;
-    occurred_at: string;
-}
-/** Raises the verification level of one conversation or task. The server never infers it. */
-interface VerifyItem {
-    type: "verify";
-    idempotency_key: string;
-    method: VerifyMethod;
-    level: Verification;
-    conversation_id?: string | null;
-    task_id?: string | null;
-    handle: Handle;
-    valid_until?: string | null;
-    occurred_at: string;
-}
-interface ConversationEndedItem {
-    type: "conversation.ended";
-    idempotency_key: string;
-    conversation_id: string;
-    occurred_at: string;
-}
-interface TaskEndedItem {
-    type: "task.ended";
-    idempotency_key: string;
-    task_id: string;
-    occurred_at: string;
-}
-/** A transfer to a human or another agent. */
-interface HandoffItem {
-    type: "handoff";
-    idempotency_key: string;
-    conversation_id: string;
-    target: "human" | "agent";
-    target_source?: string | null;
-    reason?: string | null;
-    mode: "warm" | "cold";
-    occurred_at: string;
-}
-/** Periodic counter the SDK sends so the server can tell a quiet source from a broken one. */
-interface HeartbeatItem {
-    type: "heartbeat";
-    window_start: string;
-    sent: number;
-}
-type BatchItem = EventItem | IdentifyItem | VerifyItem | ConversationEndedItem | TaskEndedItem | HandoffItem | HeartbeatItem;
-interface BatchRequest {
-    items: BatchItem[];
-}
-interface ItemError {
-    /** Position of the rejected item in the batch that was sent. */
-    index: number;
-    code: string;
-    detail?: string | null;
-}
-interface BatchResponse {
-    accepted: number;
-    duplicates: number;
-    errors: ItemError[];
-}
-/** Body of `POST /v1/media/uploads`. */
-interface MediaUploadRequest {
-    content_type: string;
-    /** Between 1 byte and 500 MiB. */
-    size_bytes: number;
-    /** Lowercase hex SHA-256 of the bytes. */
-    sha256: string;
-    /** Whose media it is. Stored under that person, so erasing them erases it too. */
-    subject?: Handle | null;
-}
-/** Where to send the bytes: a short-lived signed URL, and the reference events carry afterwards. */
-interface MediaUploadResponse {
-    media_ref: string;
-    upload_url: string;
-    /** Send exactly these headers with the bytes; the store refuses anything else. */
-    upload_headers?: Record<string, string>;
-    expires_at: string;
-}
-type FeedbackAction = "retract_fact" | "correct_fact" | "resolve_open_item" | "conversation_outcome";
-/** Body of `POST /v1/feedback`. The server records it as a `feedback.<action>` system event. */
-interface FeedbackRequest {
-    idempotency_key: string;
-    subject: Handle;
-    action: FeedbackAction;
-    fact_id?: string | null;
-    open_item_id?: string | null;
-    conversation_id?: string | null;
-    /** Up to 2,000 characters. */
-    value?: string | null;
-    /** Up to 500 characters. */
-    reason?: string | null;
-}
+declare function natureOf(text: string, mention: Mention, role: Role, values: readonly TurnValue[]): Nature;
+/** Every claim of `output` that a category detects, in the contract's order and then the text's. */
+declare function check(categories: readonly ClaimCategory[], output: Output, turn?: Turn): Finding[];
+/** The categories that detect anything in `output`: what a phrase of the negative corpus must never trigger. */
+declare function detected(categories: readonly ClaimCategory[], output: Output): string[];
 
 /**
- * Turns what callers pass to `track()`, `identify()` and friends into batch items, applying the
- * same shape rules the server enforces. Catching a malformed event here means it is dropped
- * with a log line instead of occupying the queue and coming back as a 207 error.
+ * Hedges (the claim contract spec, section 5.4): a number the output says it cannot confirm, says as a value
+ * that no longer holds, or doubts, is not asserted, and no category detects it. "Não consigo confirmar se o
+ * frete de R$ 24,90 ainda vale" states no price.
+ *
+ * A number's clause is its sentence cut at clause breaks: a comma, semicolon or colon before a space, a
+ * parenthesis, a dash, and the clause words ("mas", "but", "porque"). A break inside a number does not count.
+ * A number is hedged when:
+ *
+ * 1. a denial stands before it in its clause ("não consigo confirmar", "I can't confirm", "whether");
+ * 2. it is the number of its clause nearest to a past marker ("o valor anterior", "previously listed"), on
+ *    either side, within `WINDOW` words, with no word of the present between them ("now", "agora");
+ * 3. it is the number of its clause nearest before a doubt ("pode ter mudado", "has changed"), within
+ *    `WINDOW` words;
+ * 4. its clause follows one that is only an opener ("Antes, ele estava em R$ 1.240,00");
+ * 5. its clause holds a past word ("foi", "was", "on file"), and a later clause of its sentence holds a
+ *    denial followed by a word of continuity ("mas não consigo confirmar se esse total continua igual");
+ * 6. a negation stands right before it ("$689.00 per month, not $612.00").
+ *
+ * A hedge that governs something else leaves the number asserted: "O total é R$ 500, mas não consigo
+ * confirmar o prazo" states R$ 500. The words match whole words of the folded text, in sequence, with both
+ * apostrophes alike, and never inside a number.
  */
 
-/** An ISO 8601 string or a `Date`. */
-type Timestamp = string | Date;
-/** Fields shared by everything `track()` records. */
-interface EventBase {
-    /** Where it happened, such as `whatsapp`, `voice`, `app` or `erp`. */
-    channel: string;
-    /** Provider message id, when there is one; otherwise the SDK mints a UUIDv7. */
-    idempotency_key?: string;
-    conversation_id?: string | null;
-    /** Other ids the same conversation has in other systems. Up to 8. */
-    conversation_aliases?: string[];
-    task_id?: string | null;
-    /** Up to 16. An event needs at least one handle, subject or object. */
-    handles?: Handle[];
-    /** Up to 8. */
-    subjects?: Subject[];
-    /** Up to 16. Accepts `type:namespace:id` strings. */
-    object_refs?: (ObjectRef | string)[];
-    /** Defaults to now. */
-    occurred_at?: Timestamp;
-    visibility?: Visibility;
-    verification_hint?: Verification | null;
-    corrects_event_id?: string | null;
-    voice?: VoiceInfo | null;
-    /**
-     * Which context the agent acted on, for the agent's own turns and actions. Conversations and
-     * tasks set it from `markInjected()`.
-     */
-    context_stamp?: ContextStamp | null;
-}
-/** An event for `track()`. `kind` defaults to `message`. */
-interface TrackEvent extends EventBase {
-    kind?: EventKind;
-    /** Who produced it. A bare role is shorthand for `{ role }`. */
-    speaker: SpeakerRef | Speaker;
-    /** Defaults to `inbound` for customer messages and `outbound` for agent messages. */
-    direction?: "inbound" | "outbound" | null;
-    content?: Content | null;
-    /** Shorthand for `content: { type: "text", text }`. Cannot be combined with `content`. */
-    text?: string;
-    /** Required for `system_event`, such as `invoice.credited`. */
-    canonical_type?: string | null;
-    fields?: Record<string, unknown>;
-    /** Required for `action`, and only valid there. */
-    action?: ActionInfo | null;
-    /** What the provider reported for the model call behind an `ai_agent` message; only valid there. */
-    usage?: ModelUsage | null;
-}
-/** An agent action for `action()`: what an agent did in a system of record. */
-interface ActionEvent extends EventBase {
-    /** Canonical operation, such as `credit` or `reschedule`. */
-    operation: string;
-    /** What happened, up to 2,000 characters. */
-    result?: string | null;
-    purpose?: string | null;
-    /** The open item this action fulfils, which the server then marks resolved. */
-    closes?: Closes | null;
-    corrects_action_id?: string | null;
-    /** Defaults to `ai_agent`. */
-    speaker?: SpeakerRef | Speaker;
-}
-interface IdentifyParams {
-    /** Between 2 and 16 handles that belong to the same subject. */
-    handles: Handle[];
-    /** Defaults to `explicit_identify`. */
-    method?: AssertionMethod;
-    /** Defaults to `person`. */
-    subject_kind?: SubjectKind;
-    conversation_id?: string | null;
-    occurred_at?: Timestamp;
-    idempotency_key?: string;
-}
-interface VerifyParams {
-    /** The handle whose possession was proven. */
-    handle: Handle;
-    method: VerifyMethod;
-    /** The level reached. It applies to this conversation or task only. */
-    level: Verification;
-    conversation_id?: string | null;
-    task_id?: string | null;
-    /** When the proof stops counting. */
-    valid_until?: Timestamp | null;
-    occurred_at?: Timestamp;
-    idempotency_key?: string;
-}
-interface HandoffParams {
-    conversation_id: string;
-    target: "human" | "agent";
-    /** The source that takes over, when it is integrated with Niadra. */
-    target_source?: string | null;
-    reason?: string | null;
-    /** `warm` when the receiver gets a briefing. Defaults to `warm`. */
-    mode?: "warm" | "cold";
-    occurred_at?: Timestamp;
-    idempotency_key?: string;
-}
-/** Arguments of `feedback()`: a correction of what Niadra derived about a subject. */
-interface FeedbackParams {
-    subject: Handle;
-    /**
-     * `retract_fact` or `correct_fact` (with `fact_id`, and `value` for the right one),
-     * `resolve_open_item` (with `open_item_id`) or `conversation_outcome` (with `conversation_id`
-     * and `value`).
-     */
-    action: FeedbackAction;
-    fact_id?: string | null;
-    open_item_id?: string | null;
-    conversation_id?: string | null;
-    /** Up to 2,000 characters. */
-    value?: string | null;
-    /** Why, up to 500 characters. */
-    reason?: string | null;
-    idempotency_key?: string;
-}
+/** The numbers of `numbers` (the output's mentions that are not labels) the output does not assert. */
+declare function hedged(text: string, numbers: readonly Mention[]): ReadonlySet<Mention>;
 
 /**
- * Where the SDK reports what it swallowed in fail-open mode. Messages carry status codes,
- * error codes and request ids, never handles, message text or other personal data.
+ * The text anchor (the claim contract spec, section 9): how closely a quoted passage matches the document
+ * it cites.
+ *
+ * Both texts are normalized the same way: lower case, no accents, every run of anything but letters and
+ * digits one space, trimmed. The score is `1 - d / len(quote)`, where `d` is the fewest insertions, deletions
+ * and substitutions that turn the quote into some passage of the document (any start, any end), and an anchor
+ * holds at 0.90 or above. The distance runs as Myers' bit-parallel algorithm, linear in the document's length.
  */
-interface Logger {
-    debug(message: string, ...details: unknown[]): void;
-    warn(message: string, ...details: unknown[]): void;
-    error(message: string, ...details: unknown[]): void;
-}
-/** Warnings and errors go to the console; debug output is off unless you pass your own logger. */
-declare const consoleLogger: Logger;
-declare const silentLogger: Logger;
+/** An anchor holds at this score or above; a contract may ask for more, never less. */
+declare const MIN_ANCHOR_MATCH = 0.9;
+declare function normalize$1(text: string): string;
+/** The edit distance between `pattern` and the passage of `text` nearest to it. */
+declare function distance(pattern: string, text: string): number;
+/** 1 when the normalized quote is a passage of the normalized document; 0 for an empty quote. */
+declare function score(quote: string, document: string): number;
 
-/** When context first went into the prompt, and when the agent first spoke. */
-interface Timings {
-    contextInjectedAt: Date | null;
-    firstAgentTurnAt: Date | null;
-}
+/**
+ * The claim contract's reference checker (`spec/claim-contract.md`), pure and without a model: the number and
+ * role parser, the hedges (a number the output does not assert), the category detection, the natures, verdicts
+ * and actions, and the text anchor. It passes the same conformance vectors as the server's and the Python
+ * SDK's (`spec/vectors/claim-*.v0.json`).
+ */
 
-/** The outcome of a call that may fail without throwing. Exactly one of the two fields is set. */
-type Result<T> = {
-    data: T;
-    error: null;
-} | {
-    data: null;
-    error: NiadraError;
-};
-/** Everything a tool call is bound to besides its arguments. None of it is visible to the model. */
-interface ToolBinding {
-    about?: Handle;
-    verification?: Verification;
-    conversation_id?: string;
-    task_id?: string;
-    /** Use the voice time budget for the calls these tools make. */
-    voice?: boolean;
+type index_Action = Action;
+type index_Anchor = Anchor;
+type index_Finding = Finding;
+declare const index_InternalText: typeof InternalText;
+declare const index_LANGUAGES: typeof LANGUAGES;
+type index_Language = Language;
+declare const index_MIN_ANCHOR_MATCH: typeof MIN_ANCHOR_MATCH;
+type index_Mention = Mention;
+declare const index_Mention: typeof Mention;
+type index_MentionClass = MentionClass;
+type index_Nature = Nature;
+type index_Output = Output;
+type index_Role = Role;
+type index_Span = Span;
+type index_Turn = Turn;
+type index_TurnValue = TurnValue;
+type index_Value = Value;
+type index_Verdict = Verdict;
+declare const index_WINDOW: typeof WINDOW;
+declare const index_check: typeof check;
+declare const index_detected: typeof detected;
+declare const index_distance: typeof distance;
+declare const index_hedged: typeof hedged;
+declare const index_mentions: typeof mentions;
+declare const index_natureOf: typeof natureOf;
+declare const index_rolesOf: typeof rolesOf;
+declare const index_sameValue: typeof sameValue;
+declare const index_score: typeof score;
+declare const index_shingles: typeof shingles;
+declare namespace index {
+  export { type index_Action as Action, type index_Anchor as Anchor, type index_Finding as Finding, index_InternalText as InternalText, index_LANGUAGES as LANGUAGES, type index_Language as Language, index_MIN_ANCHOR_MATCH as MIN_ANCHOR_MATCH, index_Mention as Mention, type index_MentionClass as MentionClass, type index_Nature as Nature, type index_Output as Output, type index_Role as Role, type index_Span as Span, type index_Turn as Turn, type index_TurnValue as TurnValue, type index_Value as Value, type index_Verdict as Verdict, index_WINDOW as WINDOW, index_check as check, index_detected as detected, index_distance as distance, index_hedged as hedged, index_mentions as mentions, index_natureOf as natureOf, normalize$1 as normalize, index_rolesOf as rolesOf, index_sameValue as sameValue, index_score as score, index_shingles as shingles };
 }
+
 /**
- * The navigation kit as function-calling tools, bound to one customer.
+ * A type derived from the company's own PostgreSQL schema (the object type spec, section 8), inside the
+ * company's boundary: the catalog is read, never a row, and neither the catalog nor the proposal leaves.
  *
- * The definitions have no parameter for the customer: the handle lives in this object, outside
- * the model's reach. A prompt injection that says "now look up customer X" has no argument to
- * put X in. The model chooses what to ask, never whom it is about.
+ * `derive()` turns one table's catalog into a proposed type, with the fingerprint of what it read and the
+ * review a person must do before the proposal goes up as a configuration change: triggers are code, and a
+ * CHECK that is not a list of values is not read. `changes()` is the drift report `niadra types derive
+ * --check` sends with the fingerprint: counts, and the names the declaration already holds, never the schema.
+ * It passes the spec's vectors (`spec/vectors/type-derive.v0.json`), as the Python SDK does.
  */
-interface BoundTools {
-    /** Tool definitions in the `{ type: "function", function: { name, description, parameters } }` shape. */
-    readonly definitions: ToolDefinition[];
-    /** Whether `name` is one of these tools, for dispatchers that route several toolsets. */
-    has(name: string): boolean;
-    /**
-     * Runs one tool call and returns the text to send back to the model as the tool result.
-     * `args` may be the JSON string most model APIs return, or an already parsed object.
-     * Failures come back as a short JSON error the model can read and move past; with
-     * `strict: true` they are thrown instead.
-     */
-    call(name: string, args: string | Record<string, unknown>): Promise<string>;
+type Json$2 = Record<string, unknown>;
+/** A column as the catalog read lists it. */
+interface CatalogColumn {
+    name: string;
+    type: string;
+    not_null: boolean;
+    enum?: string;
+}
+/** One table's catalog: its columns, keys, checks, enumerations and triggers, never a row. */
+interface Catalog {
+    catalog: string;
+    table: string;
+    columns: CatalogColumn[];
+    primary_key: string[];
+    checks: string[];
+    enums: {
+        name: string;
+        labels: string[];
+    }[];
+    foreign_keys: {
+        columns: string[];
+        references: string;
+        referenced_columns: string[];
+    }[];
+    triggers: {
+        name: string;
+        definition: string;
+        enabled: boolean;
+    }[];
+}
+interface DeriveOptions {
+    /** The type's name; the table's by default. */
+    type?: string;
+    /** The system the type mirrors; `postgresql` by default. */
+    system?: string;
+    /** `subject` (the default) or `shared`: an agent's working state is never derived. */
+    ownership?: string;
+}
+/** A proposed type (it validates against `object-type.v0`), its catalog's fingerprint, and the review. */
+interface Derived {
+    type: Json$2;
+    fingerprint: string;
+    review: Json$2[];
+}
+/** The counts `--check` sends with the fingerprint, and the declared fields they touch. */
+interface Changes {
+    fields_added: number;
+    fields_removed: number;
+    fields_retyped: number;
+    states_added: number;
+    states_removed: number;
+    relations_added: number;
+    relations_removed: number;
+    key_changed: boolean;
+    fields: string[];
+}
+/** A catalog or an option the derivation refuses, named by `code`. */
+declare class DeriveError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
 }
-declare const TOOL_NAMES: {
-    readonly search: "search_customer_history";
-    readonly timeline: "get_customer_timeline";
-    readonly open: "open_history_item";
-};
-declare const TOOL_DEFINITIONS: readonly ToolDefinition[];
+/** The catalog in the order the fingerprint hashes (section 8.2), every order by UTF-16 code units. */
+declare function normalize(catalog: Catalog): Catalog;
+/** `sha256:<hex>` over the canonical JSON of the normalized catalog (section 8.3). */
+declare function fingerprint(catalog: Catalog): Promise<string>;
+/**
+ * A catalog name as a name of the type (section 8.5): A to Z lowercased, every other code point outside
+ * `[a-z0-9_]` one `_`, `c_` before a name that does not start with a letter, cut at `limit`, and `_` after a
+ * reserved word.
+ */
+declare function toName(raw: string, limit?: number): string;
+/** The proposed type of one table (section 8.4). */
+declare function derive(catalog: Catalog, options?: DeriveOptions): Promise<Derived>;
+/**
+ * What differs between the declaration and the type the live catalog derives (section 8.8): counts, and the
+ * declared fields the difference touches. Never a new name, a value or a definition.
+ */
+declare function changes(declared: Json$2, live: Json$2): Changes;
+/**
+ * The column and the values of a CHECK that holds a column to a list, as `pg_get_constraintdef` writes it
+ * (section 8.6): `CHECK ((status = ANY (ARRAY['open'::text, 'paid'::text])))`, the same with a cast of the
+ * column and of the array, or `CHECK ((status = 'open'::text))`. Anything else is null.
+ */
+declare function listCheck(definition: string): [string, unknown[]] | null;
 
-interface ConversationParams {
-    /** The customer on the other side. */
-    subject: Handle;
-    /** Where the conversation happens, such as `whatsapp` or `voice`. */
-    channel: string;
-    /** Your id for the thread. A UUIDv7 is minted when omitted. */
-    conversation_id?: string;
-    /** Defaults to `voice` when the channel is `voice`, otherwise `chat`. */
-    view?: View;
-    /** The level already proven when the conversation starts. Defaults to `V0`. */
-    verification?: Verification;
-    /** The account or partner the customer acts for. */
-    about?: Handle;
-    target?: TargetModel;
-}
-/** Optional details of one captured turn. */
-interface TurnOptions {
-    /** The provider's message id, which makes retries of the same turn harmless. */
-    idempotency_key?: string;
-    occurred_at?: Timestamp;
-    /** The agent or attendant id inside your system. */
-    speaker_id?: string;
-    visibility?: Visibility;
-    /** Marks the text as a speech-to-text transcript with this confidence, between 0 and 1. */
-    stt_confidence?: number;
-    voice?: VoiceInfo;
-    /** Overrides the stamp an agent turn would carry from `markInjected()`. */
-    context_stamp?: ContextStamp;
-    /**
-     * Agent turns only: what the model provider reported for the call behind the answer, as the
-     * provider's response (OpenAI or Anthropic) or a `ModelUsage`. `wrap()` passes it for you. A
-     * response without usage is left out; the turn is recorded either way.
-     */
-    usage?: ModelUsage | object | null;
-}
-type ConversationEvent = Omit<TrackEvent, "channel" | "conversation_id"> & {
-    channel?: string;
-};
-type ConversationAction = Omit<ActionEvent, "channel" | "conversation_id"> & {
-    channel?: string;
-};
-interface ConversationHooks {
-    endConversation(id: string): Promise<WriteResult>;
+type derive$1_Catalog = Catalog;
+type derive$1_CatalogColumn = CatalogColumn;
+type derive$1_Changes = Changes;
+type derive$1_DeriveError = DeriveError;
+declare const derive$1_DeriveError: typeof DeriveError;
+type derive$1_DeriveOptions = DeriveOptions;
+type derive$1_Derived = Derived;
+declare const derive$1_changes: typeof changes;
+declare const derive$1_derive: typeof derive;
+declare const derive$1_fingerprint: typeof fingerprint;
+declare const derive$1_listCheck: typeof listCheck;
+declare const derive$1_normalize: typeof normalize;
+declare const derive$1_toName: typeof toName;
+declare namespace derive$1 {
+  export { type derive$1_Catalog as Catalog, type derive$1_CatalogColumn as CatalogColumn, type derive$1_Changes as Changes, derive$1_DeriveError as DeriveError, type derive$1_DeriveOptions as DeriveOptions, type derive$1_Derived as Derived, derive$1_changes as changes, derive$1_derive as derive, derive$1_fingerprint as fingerprint, derive$1_listCheck as listCheck, derive$1_normalize as normalize, derive$1_toName as toName };
 }
+
 /**
- * One customer conversation.
- *
- * The server pins the pack to the conversation: every turn gets the same bytes, so the prompt
- * prefix stays byte-identical and the model provider's prompt cache keeps hitting. After the
- * first pack, each read also asks for the delta, what changed since this agent last looked
- * (a new open item, an action another agent took). The server sends each delta once, so the
- * conversation keeps them, in order, in `suffix`, with the live turns, for the end of the
- * prompt. A successful `verify()` starts over from the pack the server pins for the new level.
+ * The canonical destination of a handle and its key per reader (`spec/suppression-list.md`, sections 3
+ * and 4).
  *
- * Call `markInjected()` when the pack goes into the prompt; the agent's later turns and actions
- * carry that moment and the pack's etag as `context_stamp`. `wrap()` does it for you.
+ * A phone number, a WhatsApp id and an e-mail address each have one canonical form, `phone:+<E.164>` or
+ * `email:<address>`. The suppression list keys it with each reader's salt, and the contact token carries it
+ * keyed with the gateway's key as `rcpt` (`spec/contact-token.md`, section 4.1), so a reader matches the
+ * destination it is about to contact without the list ever carrying a handle.
  *
- * @example
- * const convo = niadra.conversation({ subject: handles.waId("5511987654321"), channel: "whatsapp" });
- * convo.customer(inbound.text, { idempotency_key: inbound.id });
- * const ctx = await convo.context();
- * convo.markInjected(ctx);
- * const reply = await llm(ctx.text, history, ctx.suffix);
- * convo.agent(reply);
+ * The same rules as the Python SDK's `niadra.coordination.destination`.
  */
-declare class Conversation {
-    private readonly client;
-    private readonly params;
-    private readonly hooks;
-    readonly id: string;
-    readonly channel: string;
-    readonly subject: Handle;
-    private level;
-    private readonly view;
-    private readonly state;
-    private ending;
-    constructor(client: Niadra, params: ConversationParams, hooks: ConversationHooks);
-    /** The level in force for this conversation, raised by a successful `verify()`. */
-    get verification(): Verification;
-    /**
-     * When context first went into the prompt, and when the agent first spoke. Context injected
-     * after the agent's first turn is the "late context" signal the usage measurement reports.
-     */
-    get timings(): Timings;
-    /** What the agent's next turn and action carry: the last `markInjected()`, or `null`. */
-    get contextStamp(): ContextStamp | null;
-    /** The last result `context()` returned for this conversation. */
-    get lastContext(): ContextResult | null;
-    /** Where `wrap()` reports what it swallowed: the client's logger. */
-    get logger(): Logger;
-    /**
-     * The pack for this turn: the pinned `text`, and a `suffix` with every delta since the pin
-     * and the current live turns. A read with `query` is compiled for that query and never
-     * pinned, so it leaves the conversation's deltas alone.
-     */
-    context(options?: ContextOptions & {
-        query?: string;
-    }): Promise<ContextResult>;
-    /**
-     * Records that `context` (by default the last one this conversation returned) went into the
-     * prompt. Call it each time you build the prompt; `timings.contextInjectedAt` keeps the first.
-     */
-    markInjected(context?: ContextResult | null, at?: Date): void;
-    /** Captures what the customer said. */
-    customer(text: string, options?: TurnOptions): string | null;
-    /** Captures what the AI agent said, stamped with the context its prompt carried. */
-    agent(text: string, options?: TurnOptions): string | null;
-    /** Captures what a human attendant said, for example after a handoff. */
-    human(text: string, options?: TurnOptions): string | null;
-    /** Records any event in this conversation. The customer's handle is attached unless you pass your own. */
-    track(event: ConversationEvent): string | null;
-    /** Records an action the agent took during this conversation, stamped like its turns. */
-    action(event: ConversationAction): string | null;
-    /**
-     * Records that the customer proved who they are, and raises the level for later reads.
-     * `handle` defaults to the conversation's subject.
-     */
-    verify(params: {
-        method: VerifyMethod;
-        level: Verification;
-        handle?: Handle;
-    }): Promise<WriteResult>;
-    /** Records a transfer to a human or another agent. */
-    handoff(params: {
-        target: "human" | "agent";
-        target_source?: string;
-        reason?: string;
-        mode?: "warm" | "cold";
-    }): Promise<WriteResult>;
-    /**
-     * The navigation kit bound to this customer and conversation. The verification level is
-     * read at each call, so tools created before a `verify()` pick up the new level.
-     */
-    tools(): BoundTools;
-    /** Emits `conversation.ended` and drops the conversation's cached packs. Safe to call twice. */
-    end(): Promise<WriteResult>;
-    private bind;
-    private turn;
-}
-
-/** Arguments of `uploadMedia()`. */
-interface UploadParams {
-    /** The file itself. It is read into memory once, to hash it and send it. */
-    data: Uint8Array | ArrayBuffer | Blob;
-    /** Such as `audio/wav` or `image/png`. Storage checks it against the signed URL. */
-    content_type: string;
-    /**
-     * Whose file it is, whenever you know. It is then stored under that person, so erasing them
-     * erases it, even if no event ever references it.
-     */
-    subject?: Handle;
-}
-/** A file handed to Niadra. Put `media_ref` and `media_sha256` in the event's `content`. */
-interface MediaUpload {
-    media_ref: string;
-    media_sha256: string;
-    content_type: string;
-    size_bytes: number;
-    expires_at: string | null;
-}
 
-/** Paging of `objectTimeline()`. */
-interface ObjectTimelineParams {
-    /** `next_cursor` from the previous page. */
-    cursor?: string;
-    /** Between 1 and 100. Defaults to 20. */
-    limit?: number;
+/**
+ * A handle with no canonical destination: `invalid_handle` when the value is not a handle of its type,
+ * `unsupported_type` when the list does not cover the type.
+ */
+declare class NiadraDestinationError extends NiadraError {
+    readonly code: "invalid_handle" | "unsupported_type";
+    readonly name = "NiadraDestinationError";
+    constructor(code: "invalid_handle" | "unsupported_type");
 }
+/**
+ * The canonical form of a handle of `type` (`phone_e164`, `wa_id`, `wa_jid` or `email`), such as
+ * `phone:+5511987654321` for `"(11) 98765-4321"`. Throws `NiadraDestinationError`.
+ */
+declare function canonicalDestination(type: string, value: string): string;
+/**
+ * A canonical destination keyed with a reader's salt, in base64url as `GET /v1/suppressions/salt` gives it:
+ * the base64url of HMAC-SHA256 over its UTF-8 bytes, 43 characters. Web Crypto signs asynchronously.
+ */
+declare function suppressionKey(salt: string, canonical: string): Promise<string>;
 
 /**
- * Per-method time budgets in milliseconds. They are the SDK's own and deliberately short:
- * managed agent platforms allow 7 to 10 seconds per turn and self-hosted frameworks allow no
- * limit at all, so a slow memory call must never become a slow agent.
+ * The exposure token (`spec/exposure-token.md`): `nx1.<id>.<position>.<verifier>`, the short string a card
+ * carries so that the order line the store's app copies it into names the list the agent showed and the
+ * card's place in it.
+ *
+ * The token carries no personal data. Its verifier catches a token copied wrong or cut short; it is not a
+ * signature. Building one is synchronous, so a card can carry it as it renders: the SHA-256 of the verifier
+ * is computed here, since Web Crypto only hashes asynchronously.
+ *
+ * The same rules as the Python SDK's `niadra.exposure`.
  */
-interface Timeouts {
-    /** `context()` for every view except `voice`. */
-    context: number;
-    /** `context()` with `view: "voice"`, where the budget is a fraction of a spoken turn. */
-    contextVoice: number;
-    /** `search()`, `timeline()` and `open()`. */
-    navigation: number;
-    /** Navigation calls made through a voice conversation or voice-bound tools. */
-    navigationVoice: number;
-    /**
-     * The whole of a write the caller waits for: `identify()`, `verify()`, `handoff()`,
-     * `feedback()` and the reservation in `uploadMedia()`, retries included. Also each attempt
-     * of a background batch, which never holds a caller.
-     */
-    write: number;
-    /** `subjectToken()`, usually called once when a session starts. */
-    token: number;
-    /** The whole of sending media bytes to storage in `uploadMedia()`, retries included. */
-    upload: number;
-}
-declare const DEFAULT_TIMEOUTS: Timeouts;
-/** How `context()` reuses packs inside a conversation. */
-interface CacheOptions {
-    /** A pack younger than this is returned without any request. */
-    ttlMs: number;
-    /**
-     * After `ttlMs`, the cached pack is still returned at once for this long while a single
-     * background request refreshes it.
-     */
-    staleWhileRevalidateMs: number;
-    /**
-     * Oldest pack the SDK will fall back to when a request fails. Older packs are dropped
-     * rather than shown to a model as if they were current.
-     */
-    maxStaleMs: number;
-    /** Least recently used packs are evicted past this many conversations. */
-    maxEntries: number;
-}
-declare const DEFAULT_CACHE: CacheOptions;
-/** How `track()` and the other write methods batch events on their way to `POST /v1/batch`. */
-interface QueueOptions {
-    /** Send as soon as this many items are waiting. */
-    flushAt: number;
-    /** Send whatever is waiting at least this often. */
-    flushIntervalMs: number;
-    /**
-     * Send a conversation turn (a message with a `conversation_id`) at most this long after it was
-     * queued, with whatever else is waiting. It is what the other agents read in `live`.
-     */
-    turnFlushIntervalMs: number;
-    /** Items per request. The server accepts up to 500. */
-    maxBatchSize: number;
-    /** Items held in memory before new ones are dropped. Keeps a long outage from exhausting memory. */
-    maxQueueSize: number;
-    /** Attempts per batch, including the first. 4xx answers other than 408, 421 and 429 are never retried. */
-    maxAttempts: number;
-    /** First backoff delay; each retry doubles it, with full jitter, up to `maxRetryDelayMs`. */
-    retryDelayMs: number;
-    maxRetryDelayMs: number;
-}
-declare const DEFAULT_QUEUE: QueueOptions;
-interface ClientOptions {
-    /**
-     * A source key, `nia_sk_<live|test>_<region>_<space>_<key_id>_<secret>`. Defaults to the
-     * `NIADRA_API_KEY` environment variable where one exists. Without a key the client is a
-     * no-op: every method resolves with an empty result and nothing is sent.
-     */
-    apiKey?: string | undefined;
-    /**
-     * Overrides the address derived from the key, for the local emulator or a private endpoint.
-     * Defaults to `NIADRA_BASE_URL`, then to `https://<space>.<region>.api.niadra.com`.
-     */
-    baseURL?: string | undefined;
-    timeouts?: Partial<Timeouts>;
-    /** Pass `false` to send every `context()` call to the server. */
-    cache?: Partial<CacheOptions> | false;
-    queue?: Partial<QueueOptions>;
-    /**
-     * Throw errors instead of logging them and resolving with an empty result. Meant for tests
-     * and development, where a silent failure hides a broken integration.
-     */
-    strict?: boolean;
-    /** Flush queued events when a Node process is about to exit. Defaults to `true`. */
-    flushOnExit?: boolean;
-    /** A `fetch` implementation. Defaults to the global one. */
-    fetch?: typeof fetch;
-    logger?: Logger;
-    /** Extra headers sent with every request. */
-    defaultHeaders?: Record<string, string>;
-}
 
-interface TaskParams {
-    /** Your id for the task. A UUIDv7 is minted when omitted. */
-    task_id?: string;
-    /** The internal agent or system doing the work, such as `billing-agent`. */
-    channel: string;
-    /** The person the task is about. Pass this, `object`, or both. */
-    subject?: Handle;
-    /** The business object the task is about, as an `ObjectRef` or `type:namespace:id`. */
-    object?: ObjectRef | string;
-    about?: Handle;
-    /** A task view such as `task:billing`. Defaults to `brief`. */
-    view?: View;
-    verification?: Verification;
-    target?: TargetModel;
+/** Why a reader refuses a token: the first check of `spec/exposure-token.md`, section 4, that fails. */
+type ExposureTokenRefusal = "malformed" | "unsupported_version" | "bad_position" | "bad_verifier";
+/** A token a reader refuses, with the code of the first check it fails. */
+declare class NiadraExposureTokenError extends NiadraError {
+    readonly code: ExposureTokenRefusal;
+    readonly name = "NiadraExposureTokenError";
+    constructor(code: ExposureTokenRefusal);
 }
-type TaskEvent = Omit<TrackEvent, "channel" | "task_id"> & {
-    channel?: string;
-};
-type TaskAction = Omit<ActionEvent, "channel" | "task_id"> & {
-    channel?: string;
+/**
+ * The token of the card at `position` (1-based, up to 9999) of the exposure `exposureId`, a UUID: 33
+ * characters for the first card, at most 36.
+ */
+declare function exposureToken(exposureId: string, position: number): string;
+/** The exposure id, written as a UUID, and the position a token names. Throws `NiadraExposureTokenError`. */
+declare function parseExposureToken(token: string): {
+    exposureId: string;
+    position: number;
 };
-interface TaskHooks {
-    endTask(id: string): Promise<WriteResult>;
-    /** `verify()` for a task, which may have no subject to default the handle to. */
-    verifyTask(params: Omit<VerifyParams, "handle"> & {
-        handle: Handle | undefined;
-    }): Promise<WriteResult>;
-}
+
 /**
- * One unit of work by an internal agent: a collection run, a ticket triage, a refund. The task
- * plays the role a conversation plays for customer-facing agents: the server pins its pack,
- * deltas arrive and are kept the same way, it scopes the context cache, groups the events for
- * billing and closes with `task.ended`. Without `end()`, the server closes the task after 10
- * minutes of inactivity.
+ * Where the turn in progress lives: an `AsyncLocalStorage`, which follows promises, `await` and timers, so a
+ * tool called anywhere inside a turn lands in it, and two sub-agents started with `Promise.all` each keep
+ * their own.
+ *
+ * The SDK builds for every runtime and never imports `node:async_hooks` itself. It takes the class from
+ * `process.getBuiltinModule("node:async_hooks")` where that exists (Node 20.16 and later, Bun, Deno); a
+ * runtime without it passes the class to `useAsyncLocalStorage()`, as Cloudflare Workers do with the
+ * `nodejs_als` flag. Where there is none, `currentTurn()` is `undefined` and adapters pass the turn they
+ * opened explicitly: capture keeps working, only the implicit lookup is missing.
  */
-declare class Task {
-    private readonly client;
-    private readonly params;
-    private readonly hooks;
-    readonly id: string;
-    private readonly object;
-    private level;
-    private readonly state;
-    private ending;
-    constructor(client: Niadra, params: TaskParams, hooks: TaskHooks);
-    /** When context first went into the prompt, and when the agent first acted. */
-    get timings(): Timings;
-    /** What the agent's next turn and action carry: the last `markInjected()`, or `null`. */
-    get contextStamp(): ContextStamp | null;
-    /** The last result `context()` returned for this task. */
-    get lastContext(): ContextResult | null;
-    /** Where `wrap()` reports what it swallowed: the client's logger. */
-    get logger(): Logger;
-    /**
-     * Context for the task, centered on its object when it has one, otherwise on its subject.
-     * Resolves with an empty result, never rejects, unless the client is strict.
-     */
-    context(options?: ContextOptions & {
-        query?: string;
-    }): Promise<ContextResult>;
-    /** Records that `context` (by default the last one this task returned) went into the prompt. */
-    markInjected(context?: ContextResult | null, at?: Date): void;
-    /** Captures what the agent answered, stamped with the context its prompt carried. */
-    agent(text: string, options?: TurnOptions): string | null;
-    /**
-     * Records that the person the task is about proved who they are, and reads at the new level
-     * from then on. `handle` defaults to the task's subject.
-     */
-    verify(params: {
-        method: VerifyMethod;
-        level: Verification;
-        handle?: Handle;
-    }): Promise<WriteResult>;
-    /** Records an event in this task, attaching the task's subject and object unless you pass your own. */
-    track(event: TaskEvent): string | null;
-    /** Records an action taken in a system of record, such as `credit` on an invoice, stamped like its turns. */
-    action(event: TaskAction): string | null;
-    /**
-     * The navigation kit bound to the task's subject, or `null` for a task about an object only.
-     * The verification level is read at each call, so tools created before a `verify()` pick up
-     * the new level.
-     */
-    tools(): BoundTools | null;
-    /** Emits `task.ended` and drops the task's cached packs. Safe to call twice. */
-    end(): Promise<WriteResult>;
-    private bind;
-}
+interface AsyncStore<T> {
+    getStore(): T | undefined;
+    run<R>(store: T, fn: () => R): R;
+    enterWith(store: T): void;
+}
+type StoreClass = new <T>() => AsyncStore<T>;
+/** The `AsyncLocalStorage` class to hold turns with, on a runtime where the SDK cannot find one itself. */
+declare function useAsyncLocalStorage(storage: StoreClass): void;
 
 /**
- * Body of `POST /v1/subject-tokens`. The token binds one customer to a session so that an MCP
- * connection, or any client you hand it to, can read that customer and no other.
+ * The resolver worker: the space's refresh requests, served inside the company's boundary.
+ *
+ * Niadra never calls a company system. When a value must be read again (a claim waits on it, a timer is due,
+ * someone watches the object), Niadra queues a refresh request with the budget it admitted. The worker leases
+ * the waiting requests (`GET /v1/state/refresh-requests`, 60 s), reads each object with the company's resolver
+ * of its type (`niadra.resolvers`), at the resolver's rate and behind its circuit breaker, and pushes what it
+ * read (`POST /v1/objects/push`) with the request's id, which settles it.
+ *
+ * A watch fires only on a value its source confirmed: its `watch_revalidation` requests go first, and the
+ * answer decides every due watch of the object, even when the value did not change. A request the worker
+ * cannot answer, the object gone from the source (`NOT_FOUND`) or the resolver failing, is released at once
+ * (`POST .../release`), so a watch falls back to its type's rule without waiting out the leases. A request of a
+ * type with no resolver, or whose resolver's circuit is open, is left to its lease, for a worker that can read
+ * it. A worker that leases regularly is what tells Niadra a company worker is there to revalidate.
+ *
+ * ```ts
+ * const worker = new ResolverWorker(niadra);
+ * await worker.run(abortController.signal);
+ * ```
  */
-interface SubjectTokenRequest {
-    subject: Handle;
-    about?: Handle | null;
-    conversation_id?: string | null;
-    task_id?: string | null;
-    verification?: Verification;
-}
-/** A signed token valid for 15 minutes. Treat it as a credential: it reads this customer's memory. */
-interface SubjectToken {
-    token: string;
-    expires_at: string;
+
+declare class ResolverWorker {
+    private readonly niadra;
+    private readonly options;
+    pushed: number;
+    skipped: number;
+    released: number;
+    private readonly missing;
+    constructor(niadra: Niadra, options?: {
+        limit?: number;
+        pollMs?: number;
+        budgetMs?: number;
+        resolvers?: Resolvers;
+    });
+    private get resolvers();
+    /** Leases the waiting requests, resolves them and pushes what was read. Resolves with how many were pushed. */
+    runOnce(): Promise<number>;
+    /** Gives back a request the worker cannot answer; one that failed to go back waits out its lease. */
+    private release;
+    /** Serves requests until `signal` aborts, pausing when none wait, and longer while Niadra does not answer. */
+    run(signal?: AbortSignal): Promise<void>;
 }
 
-/** What `identify()`, `verify()`, `handoff()` and the `end()` helpers resolve to. */
-type WriteResult = {
-    ok: true;
-    idempotency_key: string;
-    error: null;
-} | {
-    ok: false;
-    idempotency_key: string | null;
-    error: NiadraError;
-};
-/** Scope of `open()`: the same verification and conversation the rest of the session uses. */
-interface OpenParams {
-    verification?: Verification;
-    conversation_id?: string;
-    /** Kept for callers of 0.1.0; the server never read it on this route, so it is not sent. */
-    task_id?: string;
-    /**
-     * The customer the item must belong to: the server opens it only when it is theirs, and answers
-     * 404 otherwise. `tools()` passes the bound customer.
-     */
-    subject?: Handle;
+/**
+ * Replay inside the company's boundary (`spec/replay.md`): Niadra keeps the scenarios and decides the verdict;
+ * the company's CI runs the agent again on recorded turns.
+ *
+ * ```ts
+ * const run = await new Replayer(niadra, buildAgent, { build: Niadra.build({ prompts: { core: "v17" }, model: MODEL }) })
+ *   .run(["sc_quote_after_price_change"], { runs: 5, vary: ["prompts"] });
+ * if (run.verdict === "regression") process.exit(1);
+ * ```
+ *
+ * For each turn of each scenario the runner asks for the case (`POST /v1/replay/cases`) with the build it runs,
+ * checks the pins itself, fetches every recorded value it needs (by pointer through `niadra.content`, or
+ * `read`) and checks its digest. It then runs the agent N times: `buildAgent()` makes a fresh agent, called
+ * with a `ReplayInput`. Inside the run, tools wrapped with `niadra.tool()` answer from the record when their
+ * arguments match a recorded call; nothing the agent sends, declares or checks leaves for Niadra, and a read
+ * returns the pack of the time. The assertions are evaluated on the replayed record, which stays here, and the
+ * results go to `POST /v1/scenario-runs`, which answers with the statistical verdict.
+ */
+
+type Json$1 = Record<string, unknown>;
+/** What a replayed agent receives: the turn's input (masked), the conversation before it, the pack of the time. */
+interface ReplayInput {
+    turnId: string;
+    kind: string;
+    text: string | null;
+    history: Json$1[];
+    context: ContextResponse | null;
+    record: Json$1;
+    /** The execution's number, from 1. */
+    run: number;
+    paraphrase: boolean;
+}
+/** Answers one input: the text the agent emitted (or nothing), or a promise of it. */
+type ReplayAgent = (input: ReplayInput) => unknown;
+/**
+ * A run as Niadra judged it: `verdict` is the worst of its scenarios' (`pass`, `flaky`, `infrastructure_error`,
+ * `pin_mismatch`, `regression`), and `scenarios` holds each one's verdict with the statistics of each
+ * assertion. A report Niadra refused for a pin that does not match is `refused`, with no `runId`.
+ */
+interface ReplayRun {
+    runId: string;
+    status: string;
+    verdict: string | null;
+    scenarios: Json$1[];
+}
+interface RunOptions {
+    runs?: number;
+    mode?: Mode;
+    vary?: string[];
+    /** A paraphrase of the input for run `n`: intermittent results must hold with other words too. */
+    paraphrase?: (text: string, run: number) => string;
+}
+/** The pins that differ (the replay spec, 4.2): every pin outside `vary` the recording requires, or both builds carry. */
+declare function pinDifferences(recorded: Json$1, running: Json$1, required: readonly string[], vary: readonly string[]): Json$1[];
+/** Runs scenarios: see the module. `read(pointer)` reads values kept by pointer, by default the client's content resolver. */
+declare class Replayer {
+    private readonly niadra;
+    private readonly agentFactory;
+    private readonly options;
+    private readonly build;
+    constructor(niadra: Niadra, agentFactory: () => ReplayAgent, options?: {
+        build?: TurnPins;
+        read?: (pointer: string) => Promise<string>;
+    });
+    /** Runs each turn of the scenarios `runs` times and resolves with the run and its verdict. */
+    run(scenarioIds: readonly string[], options?: RunOptions): Promise<ReplayRun>;
+    private scenario;
+    private caseOf;
+    private execute;
 }
+
 /**
- * The Niadra client.
+ * The tool counterfactual (`spec/counterfactual.md`): does one element of the constraints block change what a
+ * tool returns, beyond the tool's own noise? Run in the company's CI, inside its boundary.
  *
- * Reads (`context`, `search`, `timeline`, `open`) run on the agent's hot path with short time
- * budgets of their own. Writes (`track` and friends) go through an in-memory queue and never
- * block the caller. By default every method is fail-open: an outage, a timeout or a bad
- * argument is logged and the method resolves with an empty result, so the agent keeps
- * working without memory rather than not working at all. Pass `strict: true` to throw instead.
+ * ```ts
+ * const run = await new Counterfactual(niadra, { search_products: searchProducts }).run(turnIds, {
+ *   tool: "search_products",
+ *   element: "hard",
+ * });
+ * console.log(run.report.effect, run.report.limits);
+ * ```
  *
- * Create one client per process and share it; it holds the queue, the cache and the
- * connection pool.
+ * For each recorded call of the tool whose arguments or post filter carried the element (the call recorded the
+ * block it `applied`, and the block is in the record), the runner renders the call again without the element and
+ * calls the tool three times at the same moment: the recorded arguments twice (the base, whose two lists measure
+ * the tool's own noise) and the variant once. A tool marked safe to run again (`tool(..., { dryRun: true })`, or
+ * `safe`) runs as it is; any other runs as its dry run (the binding's `capabilities.dry_run_param`), and one
+ * with no dry run is never called (`no_dry_run`). It compares the lists after the post filter (exclusions, when
+ * the binding overfetches) with `overlapAtK`, finds where the items the person engaged with went, and sends
+ * only positions and overlaps to `POST /v1/measure/counterfactual-runs`, which answers with the report.
  *
- * @example
- * const niadra = new Niadra({ apiKey: process.env.NIADRA_API_KEY });
- * const ctx = await niadra.context({ subject: handles.phone("+5511987654321"), conversation_id: "wa-8812" });
+ * The records come through the replay case route, so only turns that can be replayed are read. The element is
+ * `constraints` (the whole block), `hard`, `size` (its attributes) or `exclude`. The binding comes from
+ * `bindings`, the tool's own `binding` or the SDK profile; a result's objects are read with the binding's
+ * `results`, or else with the tool's `provenance`. It behaves as the Python SDK's `Counterfactual`.
  */
-declare class Niadra {
-    /** `false` when the client was built without a usable key and sends nothing. */
-    readonly enabled: boolean;
-    private readonly core;
-    private readonly timeouts;
-    private readonly strict;
-    /** Where the client reports what it swallows in fail-open mode. */
-    readonly logger: Logger;
-    private readonly disabledReason;
-    private unregisterExit;
-    constructor(options?: ClientOptions);
-    private setup;
-    /**
-     * The customer's context pack, to place in the system prompt before calling the model.
-     *
-     * Inside a conversation (`conversation_id` or `task_id`), packs are cached: a recent one is
-     * returned without a request, an older one is returned at once while a single background
-     * request refreshes it, and when a request fails the last good pack is returned instead.
-     * A 401 or 403 is not an outage: it drops the cached packs, so revoking a key also stops
-     * what the process had already cached from reaching the model.
-     *
-     * A plain read and a `delta` read of one conversation share the cached pack. The server
-     * sends each delta once, and so does the cache, even one a background refresh brought in;
-     * `conversation()` and `task()` keep them across turns.
-     *
-     * Never rejects unless `strict` is set. On failure `text` is empty and `error` is set.
-     */
-    context(params: ContextParams, options?: ContextOptions): Promise<ContextResult>;
-    /**
-     * Searches the customer's history by keywords and meaning, with filters by period, channel,
-     * topic and kind. The answer includes how often the same kind of issue came back.
-     */
-    search(params: SearchRequest, options?: RequestOptions): Promise<Result<SearchResponse>>;
-    /** The customer's history, newest first, one line per item, paginated by cursor. */
-    timeline(params: TimelineRequest, options?: RequestOptions): Promise<Result<TimelineResponse>>;
-    /**
-     * Opens one history item from `search()` or `timeline()`: summary, request, commitments,
-     * outcome and resolution. Sent as `POST /v1/history/open`: the conversation id and `subject` go
-     * in the body, never in a URL.
-     */
-    open(id: string, params?: OpenParams, options?: RequestOptions): Promise<Result<OpenedItem>>;
-    /**
-     * The derived state of a business object: what its systems of record reported last, `as_of`
-     * when, and its open items, under this source's purpose.
-     *
-     * @example
-     * const { data: invoice } = await niadra.objectState("invoice:erp:0823");
-     */
-    objectState(object: ObjectRef | string, options?: RequestOptions): Promise<Result<ObjectState>>;
-    /**
-     * System events and agent actions about one object, newest first, one line each and never
-     * conversation content. Pass `next_cursor` back as `cursor` to go on.
-     */
-    objectTimeline(object: ObjectRef | string, params?: ObjectTimelineParams, options?: RequestOptions): Promise<Result<ObjectTimeline>>;
-    /**
-     * The navigation kit as function-calling tools with the customer bound outside the model's
-     * reach. Hand `definitions` to any model API and pass its tool calls to `call()`.
-     *
-     * @example
-     * const kit = niadra.tools(handles.phone("+5511987654321"), { conversation_id: "wa-8812" });
-     * const output = await kit.call(toolCall.function.name, toolCall.function.arguments);
-     */
-    tools(subject: Handle, binding?: ToolBinding): BoundTools;
-    /**
-     * Mints a signed, 15-minute token that binds one customer to a session. Your backend calls
-     * this and hands the token to the MCP connection, so tools served over MCP can only ever
-     * read that customer. Resolves with `data: null` on failure.
-     */
-    subjectToken(params: SubjectTokenRequest, options?: RequestOptions): Promise<Result<SubjectToken>>;
-    /**
-     * Records a message, a system event or an agent action. Returns at once with the event's
-     * idempotency key, or `null` when the event was dropped: invalid, unserializable, the queue
-     * full or the client disabled. Delivery happens in the background; `flush()` waits for it.
-     */
-    track(event: TrackEvent): string | null;
-    /**
-     * Records what an agent did in a system of record, such as a credit or a reschedule.
-     * With `closes`, the action also resolves the open item it fulfils.
-     */
-    action(event: ActionEvent): string | null;
-    /**
-     * States that several handles belong to the same subject. Sent right away rather than on the
-     * next batch, so the next `context()` call already sees the merged profile.
-     */
-    identify(params: IdentifyParams): Promise<WriteResult>;
-    /**
-     * Raises the verification level of one conversation or task after the customer proved who
-     * they are. Sent right away, and drops the conversation's cached packs, because a pack
-     * compiled for the old level may be missing what the new level allows.
-     */
-    verify(params: VerifyParams): Promise<WriteResult>;
-    /**
-     * Corrects what Niadra derived about a subject: retracts or corrects a fact, resolves an open
-     * item, or records how a conversation ended. Sent right away; the server records it as an
-     * event, so the correction is audited like any other. A rejected correction resolves with
-     * `ok: false`.
-     */
-    feedback(params: FeedbackParams): Promise<WriteResult>;
-    /**
-     * Hands a file to Niadra, such as a call recording, and returns the reference its event
-     * carries. Media never travels inside an event: this reserves an upload, sends the bytes
-     * straight to storage over a short-lived signed URL, and resolves with `media_ref` and
-     * `media_sha256` for the event's `content`.
-     *
-     * @example
-     * const { data } = await niadra.uploadMedia({ data: recording, content_type: "audio/wav" });
-     * if (data) convo.track({ speaker: "customer", content: { type: "audio", media_ref: data.media_ref, media_sha256: data.media_sha256 } });
-     */
-    uploadMedia(params: UploadParams, options?: {
-        signal?: AbortSignal;
-    }): Promise<Result<MediaUpload>>;
-    /** Records a transfer to a human or another agent. Sent right away, so the receiver can read context at once. */
-    handoff(params: HandoffParams): Promise<WriteResult>;
-    /**
-     * A helper for one customer conversation: pins the pack across turns, captures turns and
-     * emits `conversation.ended` when you call `end()`.
-     */
-    conversation(params: ConversationParams): Conversation;
-    /** A helper for one internal-agent task: binds `task_id` to reads and writes and emits `task.ended`. */
-    task(params: TaskParams): Task;
-    /**
-     * Sends every queued event and resolves when done. Call it before a serverless function
-     * returns, or pass it to `waitUntil()` on edge runtimes. Rejects only with `strict` set.
-     */
-    flush(): Promise<void>;
-    /**
-     * Flushes, stops the background timer and releases the exit hook. Events tracked after
-     * this are dropped. Call it from your own SIGTERM handler in long-running services.
-     */
-    shutdown(): Promise<void>;
-    private verifyWith;
-    /** Throws under `strict`; otherwise logs what failed, never with content, and returns the error. */
-    private swallow;
-    private voiceBudget;
-    private readSpec;
-    private navigate;
-    private fetchContext;
-    /**
-     * One request for a key, shared by every caller that needs it meanwhile. It sends the
-     * cached ETag, so an unchanged pack costs a `not_modified` answer instead of the full text.
-     * The caller's signal is deliberately not passed down: other callers may be waiting too.
-     */
-    private revalidate;
-    private contextFailure;
-    /**
-     * 401 means the key itself is no longer valid, so every cached pack goes. 403 is specific to
-     * what was asked, so only that pack goes.
-     */
-    private observeAuth;
-    private forgetScope;
-    private disabledError;
-    private enqueue;
-    private sendNow;
-    private endScope;
-    private sendBatch;
+
+type Element = "constraints" | "hard" | "size" | "exclude";
+type Json = Record<string, unknown>;
+type ToolFunction = (args: any) => unknown;
+/**
+ * Depth-weighted average overlap of `a` and `b` down to `min(k, the longer list's length)`, with
+ * `w(d) = 1 / log2(d + 1)`. An item repeated within a list counts once, at its first position. Two equal
+ * lists overlap 1, and so do two empty lists; a list against an empty one overlaps 0.
+ */
+declare function overlapAtK(a: readonly string[], b: readonly string[], k: number): number;
+/** What the run sent and what Niadra answered, with the calls the element did not touch and the turns unread. */
+interface CounterfactualRun {
+    report: Json;
+    cases: Json[];
+    untouched: number;
+    unread: number;
+}
+interface CounterfactualOptions {
+    /** Reads values kept by pointer; by default the client's content resolver. */
+    read?: (pointer: string) => Promise<string>;
+    /** A tool's binding, by tool name. */
+    bindings?: Readonly<Record<string, RawBinding>>;
+    /** Tools that may run again as they are. */
+    safe?: readonly string[];
+}
+interface CounterfactualRunOptions {
+    tool: string;
+    element: Element;
+    scenarioIds?: readonly string[];
+    k?: number;
+    label?: string;
+}
+/**
+ * The tool counterfactual. `tools` maps each tool's name to the company's function, called with the recorded
+ * arguments (one object).
+ */
+declare class Counterfactual {
+    private readonly niadra;
+    private readonly tools;
+    private readonly options;
+    constructor(niadra: Niadra, tools: Readonly<Record<string, ToolFunction>>, options?: CounterfactualOptions);
+    /** Runs every recorded call of the tool the element touched; rejects when no call carried it. */
+    run(turnIds: readonly string[], options: CounterfactualRunOptions): Promise<CounterfactualRun>;
+    private case;
+    private value;
+    private served;
+    private families;
 }
 
 /**
@@ -1530,6 +1195,6 @@ declare function baseURLFromKey(key: ParsedApiKey): string;
  */
 declare function uuidv7(now?: number): string;
 
-declare const VERSION = "0.1.1";
+declare const VERSION = "0.7.0";
 
-export { type ActionEvent, type ActionInfo, type AssertionMethod, type BatchItem, type BatchRequest, type BatchResponse, type BoundTools, type CacheDirectives, type CacheOptions, type ClientOptions, type Closes, type Commitment, type Content, type ContextOptions, type ContextParams, type ContextRequest, type ContextResponse, type ContextResult, type ContextSource, type ContextStamp, Conversation, type ConversationAction, type ConversationEndedItem, type ConversationEvent, type ConversationParams, DEFAULT_CACHE, DEFAULT_QUEUE, DEFAULT_TIMEOUTS, type DeliveryPath, type EventItem, type EventKind, type FeedbackAction, type FeedbackParams, type FeedbackRequest, type Handle, type HandleType, type HandoffItem, type HandoffParams, type HeartbeatItem, type HistoryFilters, type HistoryItem, type HistoryItemKind, type IdentifyItem, type IdentifyParams, type ItemError, type LiveTurn, type Logger, MAX_BATCH_ITEMS, MAX_EVENT_TEXT, MAX_MEDIA_BYTES, type MediaUpload, type MediaUploadRequest, type MediaUploadResponse, type ModelUsage, Niadra, NiadraAPIError, NiadraAbortError, NiadraAuthenticationError, NiadraConfigError, NiadraConnectionError, NiadraError, NiadraPermissionError, NiadraRateLimitError, NiadraTimeoutError, NiadraValidationError, type ObjectRef, type ObjectState, type ObjectTimeline, type ObjectTimelineParams, type OpenItemRequest, type OpenParams, type OpenedItem, type ParsedApiKey, type Problem, type QueueOptions, type Recurrence, type RequestOptions, type Result, type SearchRequest, type SearchResponse, type SessionSource, type SourceCoverage, type Speaker, type SpeakerRef, type Subject, type SubjectKind, type SubjectToken, type SubjectTokenRequest, TOOL_DEFINITIONS, TOOL_NAMES, type TargetModel, Task, type TaskAction, type TaskEndedItem, type TaskEvent, type TaskParams, type TimelineRequest, type TimelineResponse, type Timeouts, type Timestamp, type Timings, type ToolBinding, type ToolDefinition, type TrackEvent, type TurnOptions, type UploadParams, VERSION, type Verification, type VerificationResult, type VerifyItem, type VerifyMethod, type VerifyParams, type View, type Visibility, type VoiceInfo, type WrapSession, type WriteResult, baseURLFromKey, consoleLogger, handles, injectContext, modelUsage, parseApiKey, providerOf, renderLive, renderSuffix, silentLogger, toObjectRef, tokenCounts, uuidv7, wrap };
+export { ClaimCategory, ClaimRecord, type Binding as ConstraintBinding, type BindingArg as ConstraintBindingArg, type Call$1 as ConstraintCall, type Rendering as ConstraintRendering, ConstraintsBlock, type Honored as ConstraintsHonored, ContextResponse, ContextResult, Counterfactual, type Element as CounterfactualElement, type CounterfactualOptions, type CounterfactualRun, type CounterfactualRunOptions, type ExposureTokenRefusal, Handle, HardConstraint, Logger, type Logic, ModelUsage, Niadra, NiadraDestinationError, NiadraError, NiadraExposureTokenError, ObjectRef, type ParsedApiKey, type ReplayAgent, type ReplayInput, Mode as ReplayMode, type RunOptions as ReplayOptions, type ReplayRun, Replayer, ResolverWorker, Resolvers, type SessionSource, SubjectKind, TurnPins, VERSION, type WrapSession, baseURLFromKey, canonicalDestination, canonicalJson, index as claims, exposureToken, expr, handles, honored as honoredConstraints, injectContext, derive$1 as introspect, jsonDigest, modelUsage, overlapAtK, parseApiKey, parseExposureToken, pinDifferences, providerOf, render as renderConstraints, satisfies as satisfiesConstraint, suppressionKey, toObjectRef, tokenCounts, useAsyncLocalStorage, uuidv7, wrap };