SDK and CLI reference

class Delegus {
  new (opts?: DelegusOptions): Delegus
  transport: Transport
  // The RP's own public base URL (for Proof binding and the MCP tool URI); not a secret.
  publicBaseUrl: string | null
  // GET /me: what this client's API key resolves to (subject, role, settings).
  me(): Promise<JsonObject>
  // GET /healthz: true when Delegus reports every backing service reachable.
  health(): Promise<{ ok: boolean; env?: string; did?: string; }>
  apiKeys: { list: (subject?: string) => Promise<JsonObject>; create: (label?: string, subject?: string) => Promise<JsonObject>; revoke: (keyId: string, subject?: string) => Promise<JsonObject>; }
  // Express-style middleware for an ordinary HTTP API (http.ts): every request is checked against the caller's
  // Grant and Proof, bound to the exact method and URL, with the Action built from the body, path and query
  // through a route map. Mount before the routes it protects.
  http(opts?: HttpMiddlewareOptions): ReturnType<typeof createHttpMiddleware>
  mcp(opts?: McpOptions): McpMiddleware
  // POST /verify. Returns the signed Receipt for ALLOW and DENY alike.
  // 
  // The API answers with the receipt of the relying party's own profile, so by
  // default (`protocol: "auto"`) the SDK reads `receipt_version` from inside the
  // signed receipt payload (never from an unsigned member) and checks the
  // response accordingly:
  //   - delegus-receipt-v1: the v0.2 path, after checking the receipt
  //     signature under the service's published keys (the same key source and
  //     rules as v2: EdDSA, the receipt's kid, a `#receipt-<n>` key of the
  //     service DID; did:web:delegus.ai in production) and that the response
  //     body is exactly the signed payload;
  //   - delegus-receipt-v2: the v0.3-rc1 checks in full (parseVerifyResponseV3):
  //     the signature under the service's published keys, the body equal to
  //     the payload, `authority_commitment` opened to `authority` (and, when
  //     pinned, `capability_key_commitment` with `capability_key_opening`),
  //     `relies_on`, `requires` and `opening`;
  //   - anything else, or no readable receipt: ResponseIntegrityError.
  // Either way, after the signature check the receipt must be about this
  // request: its signed grant_hash and proof_hash must be sha256 over the
  // Grant and Proof sent (and, on v2, request_hash over the Action when present).
  // `requires` is sent as given; a v1 receipt in answer to it fails closed.
  // 
  // `protocol: "v0.2"` and `protocol: "v0.3"` pin one profile; a receipt of the
  // other one throws ResponseIntegrityError naming the pin and what came back.
  // Every failure is fail closed: do not act on the request.
  verify(req: VerifyRequestV3): Promise<VerifyResponseV3>
  // POST /verify. Returns the signed Receipt for ALLOW and DENY alike.
  // 
  // The API answers with the receipt of the relying party's own profile, so by
  // default (`protocol: "auto"`) the SDK reads `receipt_version` from inside the
  // signed receipt payload (never from an unsigned member) and checks the
  // response accordingly:
  //   - delegus-receipt-v1: the v0.2 path, after checking the receipt
  //     signature under the service's published keys (the same key source and
  //     rules as v2: EdDSA, the receipt's kid, a `#receipt-<n>` key of the
  //     service DID; did:web:delegus.ai in production) and that the response
  //     body is exactly the signed payload;
  //   - delegus-receipt-v2: the v0.3-rc1 checks in full (parseVerifyResponseV3):
  //     the signature under the service's published keys, the body equal to
  //     the payload, `authority_commitment` opened to `authority` (and, when
  //     pinned, `capability_key_commitment` with `capability_key_opening`),
  //     `relies_on`, `requires` and `opening`;
  //   - anything else, or no readable receipt: ResponseIntegrityError.
  // Either way, after the signature check the receipt must be about this
  // request: its signed grant_hash and proof_hash must be sha256 over the
  // Grant and Proof sent (and, on v2, request_hash over the Action when present).
  // `requires` is sent as given; a v1 receipt in answer to it fails closed.
  // 
  // `protocol: "v0.2"` and `protocol: "v0.3"` pin one profile; a receipt of the
  // other one throws ResponseIntegrityError naming the pin and what came back.
  // Every failure is fail closed: do not act on the request.
  verify(req: VerifyRequestV2): Promise<Receipt>
  // POST /verify. Returns the signed Receipt for ALLOW and DENY alike.
  // 
  // The API answers with the receipt of the relying party's own profile, so by
  // default (`protocol: "auto"`) the SDK reads `receipt_version` from inside the
  // signed receipt payload (never from an unsigned member) and checks the
  // response accordingly:
  //   - delegus-receipt-v1: the v0.2 path, after checking the receipt
  //     signature under the service's published keys (the same key source and
  //     rules as v2: EdDSA, the receipt's kid, a `#receipt-<n>` key of the
  //     service DID; did:web:delegus.ai in production) and that the response
  //     body is exactly the signed payload;
  //   - delegus-receipt-v2: the v0.3-rc1 checks in full (parseVerifyResponseV3):
  //     the signature under the service's published keys, the body equal to
  //     the payload, `authority_commitment` opened to `authority` (and, when
  //     pinned, `capability_key_commitment` with `capability_key_opening`),
  //     `relies_on`, `requires` and `opening`;
  //   - anything else, or no readable receipt: ResponseIntegrityError.
  // Either way, after the signature check the receipt must be about this
  // request: its signed grant_hash and proof_hash must be sha256 over the
  // Grant and Proof sent (and, on v2, request_hash over the Action when present).
  // `requires` is sent as given; a v1 receipt in answer to it fails closed.
  // 
  // `protocol: "v0.2"` and `protocol: "v0.3"` pin one profile; a receipt of the
  // other one throws ResponseIntegrityError naming the pin and what came back.
  // Every failure is fail closed: do not act on the request.
  verify(req: VerifyRequestAuto): Promise<VerifyResult>
  // POST /verify. Returns the signed Receipt for ALLOW and DENY alike.
  // 
  // The API answers with the receipt of the relying party's own profile, so by
  // default (`protocol: "auto"`) the SDK reads `receipt_version` from inside the
  // signed receipt payload (never from an unsigned member) and checks the
  // response accordingly:
  //   - delegus-receipt-v1: the v0.2 path, after checking the receipt
  //     signature under the service's published keys (the same key source and
  //     rules as v2: EdDSA, the receipt's kid, a `#receipt-<n>` key of the
  //     service DID; did:web:delegus.ai in production) and that the response
  //     body is exactly the signed payload;
  //   - delegus-receipt-v2: the v0.3-rc1 checks in full (parseVerifyResponseV3):
  //     the signature under the service's published keys, the body equal to
  //     the payload, `authority_commitment` opened to `authority` (and, when
  //     pinned, `capability_key_commitment` with `capability_key_opening`),
  //     `relies_on`, `requires` and `opening`;
  //   - anything else, or no readable receipt: ResponseIntegrityError.
  // Either way, after the signature check the receipt must be about this
  // request: its signed grant_hash and proof_hash must be sha256 over the
  // Grant and Proof sent (and, on v2, request_hash over the Action when present).
  // `requires` is sent as given; a v1 receipt in answer to it fails closed.
  // 
  // `protocol: "v0.2"` and `protocol: "v0.3"` pin one profile; a receipt of the
  // other one throws ResponseIntegrityError naming the pin and what came back.
  // Every failure is fail closed: do not act on the request.
  verify(req: AnyVerifyRequest): Promise<VerifyResult>
  // OpenID AuthZEN Access Evaluation over /verify (for PEPs such as MCP servers):
  // subject {type:"agent", id, properties:{grant, proof}}, action {name, properties}, resource {type, id}.
  // `decision` is true only for ALLOW; `context.reason` is the Delegus reason, `context.receipt` the signed receipt.
  evaluate(req: { subject: { type: string; id: string; properties?: JsonObject; }; action: { name: string; properties?: JsonObject; }; resource: { type: string; id: string; properties?: JsonObject; }; context?: JsonObject; }): Promise<{ decision: boolean; context: JsonObject; }>
  outcomes: { report: (receiptId: string, event: OutcomeEvent) => Promise<JsonObject>; }
  decisions: { get: (receiptId: string) => Promise<DecisionRecord>; chain: (receiptId: string) => Promise<ChainInput>; list: (opts?: ListOptions & { rp?: string; keyId?: string; decision?: "ALLOW" | "DENY"; reason?: string; principal?: string; grantId?: string; }) => Promise<Page<JsonObject>>; }
  // GET /decisions/export as NDJSON rows (decision summary + full receipt + outcome ledger); one page, cursor in `next_cursor`.
  decisionsExport(opts?: ListOptions & { rp?: string; keyId?: string; decision?: "ALLOW" | "DENY"; reason?: string; principal?: string; grantId?: string; }): Promise<Page<JsonObject>>
  // GET /decisions/{receipt_id}/disclosure (v0.3-rc1 §R.5): the disclosure
  // package for a v2 receipt, for its relying party or principal only (404 for
  // anyone else, and for a receipt with nothing to disclose). It carries the
  // openings of the receipt's commitments, the consumption snapshot when the
  // receipt pins one, and per dependency entry what reproduces it (the prior
  // receipt and its opening only for a caller entitled to that receipt). Pass it
  // as `disclosure` to receipts.verifyV2Entitled; nothing is verified here.
  disclosure(receiptId: string): Promise<DisclosurePackage>
  // GET /decisions/stats: decisions and outcomes rolled up per Principal.
  decisionsStats(opts?: { since?: string; until?: string; rp?: string; principal?: string; }): Promise<JsonObject>
  // The Principal directory (§2.1 trust network): who is registered and verified, since when, with which keys. Any live key.
  principals: { list: (opts?: { kind?: "managed" | "hosted"; state?: "verified" | "unverified"; orgId?: string; limit?: number; cursor?: string; }) => Promise<Page<JsonObject>>; get: (did: string) => Promise<JsonObject>; }
  grants: { list: (opts?: ListOptions & { principal?: string; agent?: string; state?: "active" | "revoked"; }) => Promise<Page<JsonObject>>; }
  // GET /usage: verifies per UTC day (`byKey` adds a per-API-key breakdown).
  usage(opts?: { since?: string; until?: string; rp?: string; principal?: string; keyId?: string; byKey?: boolean; }): Promise<JsonObject>
  // GET /audit: newest first; own actions for a subject key, the org and its members for an org key, everything for admin.
  audit(opts?: ListOptions & { actor?: string; action?: string; target?: string; }): Promise<Page<JsonObject>>
  orgs: { create: (opts: { slug: string; name: string; }) => Promise<Org>; selfServe: (opts: { slug: string; name: string; adminEmail: string; clientIp?: string; }) => Promise<SelfServeBundle>; selfServeStarter: (rpDid: string) => Promise<SelfServeStarter>; selfServeFirstReceipt: (rpDid: string) => Promise<Receipt>; entitlement: (orgId: string) => Promise<Entitlement>; setEntitlement: (orgId: string, e: EntitlementRequest) => Promise<Entitlement>; get: (orgId: string) => Promise<Org & { members: JsonObject[]; }>; addMember: (orgId: string, did: string) => Promise<JsonObject>; apiKeys: { list: (orgId: string) => Promise<JsonObject>; create: (orgId: string, role: "read" | "admin", label?: string) => Promise<JsonObject>; revoke: (orgId: string, keyId: string) => Promise<JsonObject>; }; principal: (did: string) => Principal; }
  // Principal onboarding (admin token, or an org:admin key, which onboards into its own org). `org` here is the managed-Principal DID path `did:web:<domain>:org:<slug>`; the customer account is `orgs`.
  org: { create: (opts: { slug: string; signer?: Signer; keyId?: string; orgId?: string; }) => Promise<CreatedOrg>; register: (opts: { did: string; kid?: string; signer?: Signer; orgId?: string; }) => Promise<{ principal: Principal; apiKey: string; verification: JsonObject; didDocumentResolved: boolean; }>; }
  relyingParties: { create: (opts: { slug?: string; did?: string; name?: string; proofWindowSeconds?: number; orgId?: string; profile?: "delegus-base-v1" | "delegus-base-v3" | "delegus-base-v4-draft"; }) => Promise<{ did: string; apiKey: string; client: Delegus; }>; get: (did: string) => Promise<JsonObject>; update: (did: string, patch: { name?: string; proofWindowSeconds?: number; verifyRateLimitPerMinute?: number; }) => Promise<JsonObject>; }
  checkpoints: { get: (day?: string | "latest") => Promise<JsonObject>; leaves: (day: string) => Promise<string[]>; verify: (day?: string | "latest", keys?: Readonly<Record<string, Uint8Array<ArrayBufferLike>>> | undefined) => Promise<{ ok: boolean; day: string; root: string; treeSize: number; detail?: string; checkpoint?: Checkpoint; }>; contains: (day: string, receiptIds: readonly string[]) => Promise<{ present: string[]; missing: string[]; }>; }
  evidence: { get: (hash: string) => Promise<Uint8Array | null>; }
  // The service DID document's keys by kid (receipt and status-list keys). Only
  // methods of the document's own DID count (`<doc.id>#…`, controller absent or
  // `doc.id`), so a receipt's kid is bound to that DID; which fragment may sign
  // what (`#receipt-<n>`, `#status-<n>`) is checked at verification. Against the
  // production API the document must be `did:web:delegus.ai`.
  serviceKeys(): Promise<TrustedKeys>
  receipts: { verify: (receiptJws: string, keys: Readonly<Record<string, Uint8Array<ArrayBufferLike>>>, did?: string) => ReceiptVerification; verifyV2Public: (receiptJws: string, opts?: { body?: Record<string, unknown>; keys?: Readonly<Record<string, Uint8Array<ArrayBufferLike>>>; did?: string; }) => Promise<PublicVerificationV2>; verifyV2Entitled: (receiptJws: string, opts?: Omit<Parameters<typeof verifyReceiptV2Entitled>[0], "receipt" | "keys"> & { keys?: Readonly<Record<string, Uint8Array<ArrayBufferLike>>>; }) => Promise<EntitledVerificationV2>; inclusion: (receiptId: string, keys?: Readonly<Record<string, Uint8Array<ArrayBufferLike>>> | undefined) => Promise<{ ok: boolean; pending?: boolean; day: string; root?: string; detail?: string; }>; reverify: (input: { receipt: Receipt | string | Record<string, unknown>; grant: string; proof: string; action: unknown; keys?: Readonly<Record<string, Uint8Array<ArrayBufferLike>>>; proofWindowSeconds?: number; requires?: DependencyDeclaration[]; evidence?: ReadonlyMap<string, Uint8Array>; consumptionSnapshot?: ConsumptionSnapshot; }) => Promise<ReverifyResult>; }
}

function isVerifyResponseV3(r: VerifyResult): r is VerifyResponseV3

const PRODUCTION_API: "https://api.delegus.ai"

const PRODUCTION_SERVICE_DID: "did:web:delegus.ai"

const VERIFY_DEFAULT_PROTOCOL: VerifyProtocol

interface CreatedOrg {
  principal: Principal
  did: string
  kid: string
  apiKey: string
  signer: Signer
}

interface DecisionRecord {
  receipt: Receipt
  outcomes: JsonObject[]
  // The matched Capability in plaintext; opens `authority_commitment` under `authority_opening`.
  authority?: Capability | undefined
  // Opens `authority_commitment` (43-char base64url).
  authority_opening?: string | undefined
  // Opens `evidence.consumption.capability_key_commitment` (43-char base64url).
  capability_key_opening?: string | undefined
}

interface DelegusOptions {
  // RP or Principal API key (`dk_rp_…` / `dk_principal_…`).
  apiKey?: string | undefined
  // Delegus admin token, for onboarding calls.
  adminToken?: string | undefined
  // Self-serve provision key (console only): POST /orgs/self-serve, the starter calls, and org entitlements.
  provisionKey?: string | undefined
  // API origin; default production.
  baseUrl?: string | undefined
  // The origin Agents address this RP at (§4.3). RPs behind proxies MUST set
  // it so htu binding checks see the URL the Agent targeted.
  publicBaseUrl?: string | undefined
  fetch?: FetchLike | undefined
  timeoutMs?: number | undefined
}

interface DisclosurePackage {
  receipt_id: string
  // The consumption snapshot the receipt pins by hash (budgeted Capabilities).
  consumption_snapshot?: JsonObject | undefined
  // Per dependency entry: the pinned results plus what reproduces them (receipt and opening only when the caller is entitled to the prior receipt).
  relies_on?: DisclosureEntry[] | undefined
  // The matched Capability in plaintext; opens `authority_commitment` under `authority_opening`.
  authority?: Capability | undefined
  // Opens `authority_commitment` (43-char base64url).
  authority_opening?: string | undefined
  // Opens `evidence.consumption.capability_key_commitment` (43-char base64url).
  capability_key_opening?: string | undefined
}

interface Entitlement {
  org_id: string
  // Whether a row exists. With enforcement on, no row means no plan.
  stored: boolean
  production: "allowed" | "blocked" | null
  production_until: string | null
  check_cap: number | null
  cap_since: string | null
  reason: "trial" | "paid" | "past_due_grace" | "canceled" | "comp" | "none" | null
  as_of: string | null
  updated_at: string | null
  // Production checks counted since cap_since (at most check_cap); null without a cap.
  production_checks_since_cap: number | null
  // A staff, self-test or canary tenant that never needs a plan.
  comp: boolean
  // What the gate would decide for the next production check now.
  effective: "allowed" | "blocked"
  // Why it would be refused; null when allowed.
  effective_detail: string | null
  // Whether this deployment refuses (true) or only logs (false) a blocked production check.
  enforced: boolean
  // PUT only: whether this push was stored.
  applied?: boolean | undefined
}

interface EntitlementRequest {
  production: "allowed" | "blocked"
  // Production checks stop at this instant; null for no end.
  production_until: string | null
  // At most this many production checks since cap_since; null for no cap.
  check_cap: number | null
  cap_since: string | null
  reason: "trial" | "paid" | "past_due_grace" | "canceled" | "comp" | "none"
  // The console's change time: an older push never overwrites a newer one.
  as_of: string
}

interface ListOptions {
  limit?: number | undefined
  cursor?: string | undefined
  since?: string | undefined
  until?: string | undefined
}

interface Org {
  org_id: string
  slug: string
  name: string
  created_at: string
}

interface OutcomeEvent {
  type: "fulfilled" | "cancelled" | "dispute_opened" | "dispute_resolved" | "chargeback_received" | "chargeback_reversed" | "loss_reported"
  occurred_at: string
  evidence_ref?: string | undefined
  note?: string | undefined
  correction_of?: string | undefined
  resolution?: "agent_at_fault" | "agent_not_at_fault" | "indeterminate" | undefined
  loss_amount?: number | undefined
  currency?: string | undefined
  reporter_signature?: string | undefined
}

interface Page {
  items: T[]
  // Pass back as `cursor` for the next page; null on the last page.
  next_cursor: string | null
}

interface ReceiptOpenings {
  // The matched Capability in plaintext; opens `authority_commitment` under `authority_opening`.
  authority?: Capability | undefined
  // Opens `authority_commitment` (43-char base64url).
  authority_opening?: string | undefined
  // Opens `evidence.consumption.capability_key_commitment` (43-char base64url).
  capability_key_opening?: string | undefined
}

interface SelfServeBundle {
  org: Org
  // org:admin key — keep server-side; never show the customer.
  org_admin_key: string
  relying_party: { did: string; name: string; profile: string; proof_window_seconds: number; }
  // The customer's first verify key (dk_rp_…), shown once.
  rp_verify_key: string
  starter: SelfServeStarter
}

interface SelfServeStarter {
  grant: string
  proof: string
  action: JsonObject
  grant_id: string
  // When the Proof leaves the RP's proof window; ask for a fresh starter after this.
  expires_at: string
  verify_url: string
  verify_curl: string
}

interface VerifyRequest {
  grant: string
  proof: string
  action: unknown
  // The request the RP received. When given, the SDK checks the Proof's
  // htm/htu against it before calling Delegus (§4.3) and throws
  // ProofBindingError on mismatch. `path` is joined to `publicBaseUrl`.
  request?: { method: string; url?: string; path?: string; chain?: string[]; } | undefined
}

interface VerifyRequestAuto {
  protocol?: "auto" | undefined
  requires?: DependencyDeclaration[] | undefined
  grant: string
  proof: string
  action: unknown
  // The request the RP received. When given, the SDK checks the Proof's
  // htm/htu against it before calling Delegus (§4.3) and throws
  // ProofBindingError on mismatch. `path` is joined to `publicBaseUrl`.
  request?: { method: string; url?: string; path?: string; chain?: string[]; } | undefined
}

interface VerifyRequestV2 {
  protocol: "v0.2"
  grant: string
  proof: string
  action: unknown
  // The request the RP received. When given, the SDK checks the Proof's
  // htm/htu against it before calling Delegus (§4.3) and throws
  // ProofBindingError on mismatch. `path` is joined to `publicBaseUrl`.
  request?: { method: string; url?: string; path?: string; chain?: string[]; } | undefined
}

interface VerifyRequestV3 {
  protocol: "v0.3"
  // The prior decisions this action must rest on (§5.1): 1–8 distinct { fingerprint, mode }; the actor's `relies_on` must cover each (D1).
  requires?: DependencyDeclaration[] | undefined
  grant: string
  proof: string
  action: unknown
  // The request the RP received. When given, the SDK checks the Proof's
  // htm/htu against it before calling Delegus (§4.3) and throws
  // ProofBindingError on mismatch. `path` is joined to `publicBaseUrl`.
  request?: { method: string; url?: string; path?: string; chain?: string[]; } | undefined
}

type AnyVerifyRequest = VerifyRequestV3 | VerifyRequestV2 | VerifyRequestAuto

type VerifyProtocol = "v0.3" | "v0.2" | "auto"

type VerifyResult = Receipt | VerifyResponseV3

class Principal {
  new (opts: PrincipalOptions): Principal
  did: string
  kid: string | null
  signer: Signer | null
  grant: { create: (req: GrantRequest) => Promise<IssuedGrant>; revoke: (grantId: string) => Promise<{ grant_id: string; revoked_at: string; }>; }
  keys: { retire: (kid: string) => Promise<{ kid: string; state: "retired" | "compromised"; }>; compromise: (kid: string) => Promise<void>; }
  // Run domain verification now and return the state and instructions.
  verifyDomain(): Promise<JsonObject>
  status(): Promise<JsonObject>
}

const V3_CAPABILITY_ACTIONS = {
  // Returns a string representation of an array.
  toString(): string
  // Returns a string representation of an array. The elements are converted to string using their toLocaleString methods.
  toLocaleString(): string
  // Combines two or more arrays.
  concat(...items: ConcatArray<"commerce:quote" | "commerce:accept" | "commerce:fulfil">[]): ("commerce:quote" | "commerce:accept" | "commerce:fulfil")[]
  // Adds all the elements of an array separated by the specified separator string.
  join(separator?: string): string
  // Returns a section of an array.
  slice(start?: number, end?: number): ("commerce:quote" | "commerce:accept" | "commerce:fulfil")[]
  // Returns the index of the first occurrence of a value in an array.
  indexOf(searchElement: "commerce:quote" | "commerce:accept" | "commerce:fulfil", fromIndex?: number): number
  // Returns the index of the last occurrence of a specified value in an array.
  lastIndexOf(searchElement: "commerce:quote" | "commerce:accept" | "commerce:fulfil", fromIndex?: number): number
  // Determines whether all the members of an array satisfy the specified test.
  every<S extends "commerce:quote" | "commerce:accept" | "commerce:fulfil">(predicate: (value: "commerce:quote" | "commerce:accept" | "commerce:fulfil", index: number, array: readonly ("commerce:quote" | "commerce:accept" | "commerce:fulfil")[]) => value is S, thisArg?: any): this is readonly S[]
  // Determines whether the specified callback function returns true for any element of an array.
  some(predicate: (value: "commerce:quote" | "commerce:accept" | "commerce:fulfil", index: number, array: readonly ("commerce:quote" | "commerce:accept" | "commerce:fulfil")[]) => unknown, thisArg?: any): boolean
  // Performs the specified action for each element in an array.
  forEach(callbackfn: (value: "commerce:quote" | "commerce:accept" | "commerce:fulfil", index: number, array: readonly ("commerce:quote" | "commerce:accept" | "commerce:fulfil")[]) => void, thisArg?: any): void
  // Calls a defined callback function on each element of an array, and returns an array that contains the results.
  map<U>(callbackfn: (value: "commerce:quote" | "commerce:accept" | "commerce:fulfil", index: number, array: readonly ("commerce:quote" | "commerce:accept" | "commerce:fulfil")[]) => U, thisArg?: any): U[]
  // Returns the elements of an array that meet the condition specified in a callback function.
  filter<S extends "commerce:quote" | "commerce:accept" | "commerce:fulfil">(predicate: (value: "commerce:quote" | "commerce:accept" | "commerce:fulfil", index: number, array: readonly ("commerce:quote" | "commerce:accept" | "commerce:fulfil")[]) => value is S, thisArg?: any): S[]
  // Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
  reduce(callbackfn: (previousValue: "commerce:quote" | "commerce:accept" | "commerce:fulfil", currentValue: "commerce:quote" | "commerce:accept" | "commerce:fulfil", currentIndex: number, array: readonly ("commerce:quote" | "commerce:accept" | "commerce:fulfil")[]) => "commerce:quote" | "commerce:accept" | "commerce:fulfil"): "commerce:quote" | "commerce:accept" | "commerce:fulfil"
  // Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
  reduceRight(callbackfn: (previousValue: "commerce:quote" | "commerce:accept" | "commerce:fulfil", currentValue: "commerce:quote" | "commerce:accept" | "commerce:fulfil", currentIndex: number, array: readonly ("commerce:quote" | "commerce:accept" | "commerce:fulfil")[]) => "commerce:quote" | "commerce:accept" | "commerce:fulfil"): "commerce:quote" | "commerce:accept" | "commerce:fulfil"
  // Returns the value of the first element in the array where predicate is true, and undefined
  // otherwise.
  find<S extends "commerce:quote" | "commerce:accept" | "commerce:fulfil">(predicate: (value: "commerce:quote" | "commerce:accept" | "commerce:fulfil", index: number, obj: readonly ("commerce:quote" | "commerce:accept" | "commerce:fulfil")[]) => value is S, thisArg?: any): S | undefined
  // Returns the index of the first element in the array where predicate is true, and -1
  // otherwise.
  findIndex(predicate: (value: "commerce:quote" | "commerce:accept" | "commerce:fulfil", index: number, obj: readonly ("commerce:quote" | "commerce:accept" | "commerce:fulfil")[]) => unknown, thisArg?: any): number
  // Returns an iterable of key, value pairs for every entry in the array
  entries(): ArrayIterator<[number, "commerce:quote" | "commerce:accept" | "commerce:fulfil"]>
  // Returns an iterable of keys in the array
  keys(): ArrayIterator<number>
  // Returns an iterable of values in the array
  values(): ArrayIterator<"commerce:quote" | "commerce:accept" | "commerce:fulfil">
  // Determines whether an array includes a certain element, returning true or false as appropriate.
  includes(searchElement: "commerce:quote" | "commerce:accept" | "commerce:fulfil", fromIndex?: number): boolean
  // Calls a defined callback function on each element of an array. Then, flattens the result into
  // a new array.
  // This is identical to a map followed by flat with depth 1.
  flatMap<U, This = undefined>(callback: (this: This, value: "commerce:quote" | "commerce:accept" | "commerce:fulfil", index: number, array: ("commerce:quote" | "commerce:accept" | "commerce:fulfil")[]) => U | readonly U[], thisArg?: This | undefined): U[]
  // Returns a new array with all sub-array elements concatenated into it recursively up to the
  // specified depth.
  flat<A, D extends number = 1>(this: A, depth?: D | undefined): FlatArray<A, D>[]
  // Returns the item located at the specified index.
  at(index: number): "commerce:quote" | "commerce:accept" | "commerce:fulfil" | undefined
  // Iterator of values in the array.
  __@iterator@208(): ArrayIterator<"commerce:quote" | "commerce:accept" | "commerce:fulfil">
  // Is an object whose properties have the value 'true'
  // when they will be absent when used in a 'with' statement.
  __@unscopables@592: { readonly [x: number]: boolean | undefined; readonly length?: boolean | undefined; toString?: boolean | undefined; toLocaleString?: boolean | undefined; concat?: boolean | undefined; join?: boolean | undefined; slice?: boolean | undefined; indexOf?: boolean | undefined; lastIndexOf?: boolean | undefined; every?: boolean | undefined; some?: boolean | undefined; forEach?: boolean | undefined; map?: boolean | undefined; filter?: boolean | undefined; reduce?: boolean | undefined; reduceRight?: boolean | undefined; find?: boolean | undefined; findIndex?: boolean | undefined; entries?: boolean | undefined; keys?: boolean | undefined; values?: boolean | undefined; includes?: boolean | undefined; flatMap?: boolean | undefined; flat?: boolean | undefined; at?: boolean | undefined; [Symbol.iterator]?: boolean | undefined; readonly [Symbol.unscopables]?: boolean | undefined; }
}

interface AgentInventoryEntry {
  did: string
  principal: string
  created_at: string
  disabled_at: string | null
}

interface Capability {
  action: "commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call"
  constraints: JsonObject
  resources?: string[] | undefined
}

interface GrantRequest {
  // Agent DID (did:key).
  agent: string
  // 1–16 Capabilities (§3.3).
  authority: Capability[]
  // RFC 3339 UTC; default now (whole seconds).
  validFrom?: string | undefined
  // RFC 3339 UTC; default validFrom + 30 days; at most 90 days after validFrom.
  validUntil?: string | undefined
  // RP DIDs; absent = any registered RP.
  audience?: string[] | undefined
  // Refuse (PersonalDataError, before any request) when lintAuthority() finds
  // an email address, a phone number or a card number in the authority's
  // strings. Default false: the Grant is issued and the findings come back in
  // `warnings`. Resources should be opaque ids; receipts may keep them for years.
  refusePersonalData?: boolean | undefined
  // Default true: declare the authority, audience and validity at allocation and record the Grant's hash after signing (never the bytes). false: allocate only.
  declare?: boolean | undefined
}

interface IssuedGrant {
  id: string
  // The Grant compact JWS to hand to the Agent.
  jws: string
  credentialStatus: JsonObject
  validFrom: string
  validUntil: string
  // Present only when lintAuthority() found something that looks like personal data in the authority.
  warnings?: LintFinding[] | undefined
}

interface PrincipalOptions {
  did: string
  // `did:web:…#key-n` of `signer`; required to create Grants.
  kid?: string | undefined
  signer?: Signer | undefined
  apiKey: string
  transport: Transport
  now?: (() => number) | undefined
  // `apiKey` is an org:admin key of the Principal's org: name the Principal on every call (`?principal=<did>`). Grants cannot be created this way.
  viaOrgKey?: boolean | undefined
}

class Agent {
  new (signer: Signer): Agent
  did: string
  kid: string
  signer: Signer
  sign(req: ProofRequest): Promise<string>
  // The two request headers the RP forwards to /verify (§4.4).
  headers(req: ProofRequest): Promise<{ "Delegus-Grant": string; "Delegus-Proof": string; "Delegus-Grant-Chain"?: string; }>
  // Add this agent to a company's agent list with an enrolment token the company gave its builder (named-agents.md).
  // The request is also signed with this agent's key, so a token can only ever list the key that signs. The agent
  // arrives pending: it can be named in sentences, and given authority, only after an admin approves it.
  register(req: { delegus: DelegusEndpoint; token: string; name: string; description?: string; }): Promise<JsonObject>
  // A vendor's agent joins a customer's agent list with the one-time connect code the customer created and shared. It
  // arrives pending, labelled with the vendor, until the customer approves it; the vendor gets no power to issue grants.
  connect(req: { delegus: DelegusEndpoint; code: string; name: string; vendor: string; description?: string; }): Promise<JsonObject>
  createChild(req: { parent: string; parentChain?: string[]; agent: string; authority: unknown[]; audience: string[]; validFrom?: string; validUntil?: string; depth?: number; delegus: DelegusEndpoint; }): Promise<{ jws: string; id: string; chain: string[]; }>
  // The Delegus-Grant / Delegus-Proof headers for one HTTP request to a Delegus-guarded API (http.ts): the Proof
  // binds the method and the canonical URL; the Action is built exactly as the server builds it, through the
  // server's route map when given (`routes` = the compiled map from compileRouteMap, or the JSON it serves at
  // /delegus-routes.json), else `api:call` on the URL.
  httpHeaders(req: { grant: string; method: string; url: string; rpDid: string; body?: unknown; routes?: CompiledRoutes | unknown; iat?: number; jti?: string; chain?: string[]; op?: string; }): Promise<{ "Delegus-Grant": string; "Delegus-Proof": string; "Delegus-Grant-Chain"?: string; }>
  mcpHeaders(req: { grant: string; endpoint: string; tool: string; rpDid: string; iat?: number; jti?: string; chain?: string[]; op?: string; args?: unknown; map?: ToolMap; }): Promise<{ "Delegus-Grant": string; "Delegus-Proof": string; }>
  // New Agent with an in-memory Ed25519 key (dev default).
  static create(): Agent
}

interface DelegusEndpoint {
  baseUrl: string
  serviceDid: string
  fetch?: { (input: RequestInfo | URL, init?: RequestInit): Promise<Response>; (input: string | URL | Request, init?: RequestInit): Promise<Response>; } | undefined
}

interface ProofRequest {
  // The Grant compact JWS (its `id` is taken from it) or a bare Grant id.
  grant: string
  // The RP DID the Proof is for (`aud`).
  audience: string
  // The HTTP request the Agent is about to make.
  method: string
  url: string
  // The Action, built with `actions.*` from the same wire fields the RP will use.
  action: unknown
  // Override the clock (seconds since epoch); default now.
  iat?: number | undefined
  // Override the nonce (22–64 base64url chars); default 16 random bytes.
  jti?: string | undefined
}

const actions = {
  // `commerce:purchase`: amount in minor units (integer), ISO 4217 currency.
  purchase(fields: { resource: string; amount: number; currency: string; }): Action
  // `api:call`: uppercase HTTP method, absolute http(s) resource URI.
  apiCall(fields: { method: string; resource: string; }): Action
}

const actionsV3 = {
  // `commerce:purchase`: the actor commits its Principal to buy.
  purchase(fields: Amounted): ActionV3
  // `commerce:quote`: the actor offers, for its Principal, to sell at this price.
  quote(fields: Amounted): ActionV3
  // `commerce:accept`: the actor accepts an order for its Principal at this price.
  accept(fields: Amounted): ActionV3
  // `commerce:fulfil`: the actor commits its Principal to deliver the named resource.
  fulfil(fields: { resource: string; } & DependencyFields): ActionV3
  // `api:call`: uppercase HTTP method, absolute http(s) resource URI.
  apiCall(fields: { method: string; resource: string; } & DependencyFields): ActionV3
  // Add `relies_on` to an Action built elsewhere (it must not already declare one, and must carry no transaction handle).
  withDependencies(action: Action | ActionV3, deps: DependencyFields): ActionV3
}

interface DependencyFields {
  // 1–8 distinct { fingerprint, mode } entries; there is no default mode.
  relies_on?: DependencyDeclaration[] | undefined
}

class MemorySigner {
  new (seed: Uint8Array): MemorySigner
  // Raw 32-byte Ed25519 public key.
  publicKey: Uint8Array<ArrayBufferLike>
  // PureEdDSA over exactly `data`; 64 bytes.
  sign(data: Uint8Array): Uint8Array
  toJwk(): Ed25519Jwk
  static generate(): MemorySigner
  static fromSeed(seed: Uint8Array): MemorySigner
  static fromJwk(jwk: unknown): MemorySigner
}

function didKeyOf(s: Signer): string

function publicKeyMultibase(s: Signer): string

interface Ed25519Jwk {
  kty: "OKP"
  crv: "Ed25519"
  x: string
  d: string
}

interface Signer {
  // Raw 32-byte Ed25519 public key.
  publicKey: Uint8Array<ArrayBufferLike>
  // PureEdDSA over exactly `data`; 64 bytes.
  sign(data: Uint8Array): Uint8Array | Promise<Uint8Array>
}

class DelegusApiError {
  new (status: number, code: string, message: string): DelegusApiError
  name: string
  status: number
  code: string
  message: string
  stack?: string | undefined
  cause?: unknown
}

class DelegusError {
  new (message?: string): DelegusError
  new (message?: string, options?: ErrorOptions): DelegusError
  name: string
  message: string
  stack?: string | undefined
  cause?: unknown
}

class PersonalDataError {
  new (findings: ReadonlyArray<{ path: string; kind: string; }>): PersonalDataError
  name: "PersonalDataError"
  findings: readonly { path: string; kind: string; }[]
  message: string
  stack?: string | undefined
  cause?: unknown
}

class PlanRequiredError {
  new (status: number, code: string, message: string): PlanRequiredError
  name: string
  status: number
  code: string
  message: string
  stack?: string | undefined
  cause?: unknown
}

class ProofBindingError {
  new (expected: { method: string; url: string; }, proof: { htm: string; htu: string; }): ProofBindingError
  name: "ProofBindingError"
  expected: { method: string; url: string; }
  proof: { htm: string; htu: string; }
  message: string
  stack?: string | undefined
  cause?: unknown
}

class Transport {
  new (opts: TransportOptions): Transport
  baseUrl: string
  json(method: string, path: string, opts?: { token?: string | null; body?: unknown; headers?: Record<string, string>; }): Promise<JsonValue>
  // A request whose body is text (NDJSON, CSV, plain); errors are the API's JSON errors.
  raw(method: string, path: string, opts?: { token?: string | null; }): Promise<{ status: number; text: string; headers: Headers; }>
  bytes(path: string): Promise<Uint8Array | null>
}

type FetchLike = (input: string, init: RequestInit) => Promise<Response>

class ResponseIntegrityError {
  new (message?: string): ResponseIntegrityError
  new (message?: string, options?: ErrorOptions): ResponseIntegrityError
  name: string
  message: string
  stack?: string | undefined
  cause?: unknown
}

function checkAuthorityOpening(commitment: string, opening: string, authority: unknown): boolean

function checkCapabilityKeyOpening(commitment: string, opening: string, authority: unknown): boolean

function decisionDisagreement(body: Pick<ReceiptV2Body, "decision" | "reason" | "protocol" | "trust">): string | null

function dependencyOn(response: Pick<VerifyResponseV3, typeof F_OPENING>, mode: DependencyMode): DependencyDeclaration

function isReliesOnEntries(v: unknown): v is ReliesOnEntry[]

function parseReceiptV2Body(payload: unknown): ReceiptV2Body | null

function parseVerifyResponseV3(response: unknown, sent: SentV3, trust: ReceiptTrust): VerifyResponseV3

function receiptBindingMismatch(payload: Record<string, unknown>, sent: { grant?: string; proof?: string; }): string | null

function reliesOnHash(entries: unknown): Sha256Ref

function requiresHash(requires: unknown): Sha256Ref

function splitV2Response(response: unknown): SplitResponseV2 | string

function validateRequires(requires: unknown): DependencyDeclaration[]

function verifyReceiptV2Entitled(input: { receipt: string; body?: Record<string, unknown>; keys: TrustedKeys; did?: string; authority?: unknown; reliesOn?: unknown; requires?: unknown; authorityOpening?: unknown; capabilityKeyOpening?: unknown; disclosure?: unknown; priors?: readonly PriorReceipt[]; }): EntitledVerificationV2

function verifyReceiptV2Public(input: { receipt: string; body?: Record<string, unknown>; keys: TrustedKeys; did?: string; }): PublicVerificationV2

function verifyReceiptV2Signature(receiptJws: unknown, keys: TrustedKeys, did?: string): ReceiptV2Signature

interface DependencyOpening {
  fingerprint: `sha256:${string}`
  nonce: string
}

interface DependencyVerification {
  index: number
  fingerprint: string
  mode: string
  // reproduced: every applicable part reproduced (D5 attested);
  // partial: nothing failed but something was not reproducible;
  // failed: something failed; not_supplied: no material at all for this entry.
  result: "not_supplied" | "reproduced" | "partial" | "failed"
  checks: Record<DependencyPart, { status: PartStatus; detail: string; }>
  // The prior receipt's id, when its receipt was supplied and verifies.
  receipt_id?: string | undefined
}

interface DisclosureEntry {
  fingerprint: string
  mode: string
  checks: Record<string, unknown>
  transaction_equal: boolean | null
  receipt_hash?: string | undefined
  status_credential?: string | undefined
  status_list_index?: string | undefined
  evidence_nonce?: string | undefined
  receipt?: string | undefined
  opening?: string | undefined
}

interface EntitledVerificationV2 {
  level: "entitled"
  // `authority_commitment` opened with `authority_opening` to the plaintext Capability.
  authority: PlaintextComparison
  // `evidence.consumption.capability_key_commitment` opened with `capability_key_opening` to sha256(JCS(authority)).
  capability_key: PlaintextComparison
  relies_on: PlaintextComparison
  requires: PlaintextComparison
  dependencies: DependencyVerification[]
  // Supplied priors or disclosure entries that name no relies_on entry of this receipt, or contradict themselves.
  unmatched: { source: "priors" | "disclosure"; index: number; detail: string; }[]
  receipt_id: string | null
  decision: string | null
  reason: string | null
  ok: boolean
  checks: V2Check[]
}

interface PlaintextComparison {
  result: PlaintextResult
  pinned: string | null
  computed: string | null
  detail?: string | undefined
}

interface PriorReceipt {
  // The prior receipt's compact JWS, exactly as issued.
  receipt: string
  // Its opening nonce (43-char base64url).
  nonce: string
  // The fingerprint the opening came with, if known; checked too.
  fingerprint?: string | undefined
}

interface PublicVerificationV2 {
  ok: boolean
  level: "public"
  receipt_id: string | null
  decision: string | null
  reason: string | null
  checks: V2Check[]
}

interface ReceiptTrust {
  keys: Readonly<Record<string, Uint8Array<ArrayBufferLike>>>
  // The service DID; the receipt's kid must be a `#receipt-<n>` key of it.
  did?: string | undefined
}

interface SentV3 {
  action?: unknown
  requires?: readonly DependencyDeclaration[] | undefined
  // The Grant compact JWS sent; when given, the receipt's grant_hash must be sha256 over its UTF-8.
  grant?: string | undefined
  // The Proof compact JWS sent; when given, the receipt's proof_hash must be sha256 over its UTF-8.
  proof?: string | undefined
}

interface SplitResponseV2 {
  jws: string
  parsed: ParsedJws
  // The members that must equal the signed payload.
  body: Record<string, unknown>
  authority?: unknown
  authorityOpening?: unknown
  capabilityKeyOpening?: unknown
  reliesOn?: unknown
  opening?: unknown
}

interface V2Check {
  check: string
  ok: boolean
  detail: string
}

type DependencyPart = "D2" | "D3" | "D4" | "D5" | "D6" | "D7" | "receipt_hash" | "evidence_commitment"

type PartStatus = "reproduced" | "failed" | "attested" | "not_reproducible" | "skipped"

type PlaintextResult = "match" | "mismatch" | "not_supplied" | "not_in_receipt" | "invalid"

type ReceiptV2 = Omit<Receipt, V2Omit> & V2Fields

type ReceiptV2Body = Omit<ReceiptBody, V2Omit> & V2Fields

type ReceiptV2Signature = { ok: true; body: ReceiptV2Body; kid: string; } | { ok: false; detail: string; }

type ReliesOnEntry = DependencyEntryResult

type VerifyResponseV3 = Omit<Receipt, V2Omit> & V2Fields & { authority?: Capability; authority_opening?: string; capability_key_opening?: string; relies_on?: ReliesOnEntry[]; opening?: DependencyOpening; }

const PROFILE_V3: "delegus-base-v3"

const RECEIPT_VERSION_V2: "delegus-receipt-v2"

function createMcpMiddleware(client: Delegus, opts?: McpOptions): McpMiddleware

function encodeToolName(name: string): string

function fetchToolMap(endpoint: string, opts?: { fetch?: typeof fetch; expectHash?: string; }): Promise<FetchedToolMap | null>

function toolUri(publicBaseUrl: string, path: string, toolName: string): string | null

const ARGUMENTS_UNMAPPABLE: "ARGUMENTS_UNMAPPABLE"

const MCP_DEFAULT_PROTOCOL: VerifyProtocol

const MCP_DELEGUS_ERROR_CODE: -32040

const TOOL_MAP_FILE: "delegus-tools.json"

interface FetchedToolMap {
  map: ToolMap
  hash: string
  url: string
}

interface McpCallSeen {
  tool: string
  // The JSON-RPC id of the call (null for a notification).
  id: string | number | null
  // The Action sent to Delegus, once built.
  action?: unknown
  decision?: "ALLOW" | "DENY" | undefined
  reason?: string | null | undefined
  receipt?: McpReceipt | undefined
  // Whether the tool is enforced (false: unlisted under `tools`, passed unchecked).
  enforced: boolean
}

interface McpDecision {
  decision: "ALLOW" | "DENY"
  reason: string | null
  tool: string
  receipt?: McpReceipt | undefined
  receiptId?: string | undefined
  // On a DENY decided in the middleware because /verify failed or its response did not check: what went wrong (for operators, never sent to the caller).
  error?: string | undefined
}

interface McpOptions {
  // Which tools to enforce: an allow-list or a predicate. Absent = enforce every tool. Unlisted tools pass through UNVERIFIED.
  tools?: string[] | ((name: string) => boolean) | undefined
  // Called with the outcome of every enforced tools/call (for logging / metrics).
  onDecision?: ((d: McpDecision) => void) | undefined
  // The relying-party DID to advertise in the discovery header on missing credentials. Absent = resolved once via GET /me.
  relyingParty?: string | undefined
  // "auto" (default, MCP_DEFAULT_PROTOCOL), or a pin: "v0.2" or "v0.3". Passed through to verify().
  protocol?: VerifyProtocol | undefined
  // With "auto" or "v0.3": the prior decisions every enforced tools/call must rest on (§5.1); checked when the middleware is created. A v0.2 relying party refuses them (fail closed).
  requires?: DependencyDeclaration[] | undefined
  // The MCP tool map (tool-map.ts): how a tool's arguments become the Action's resource and amount. The
  // parsed JSON object; validated when the middleware is created (a ToolMapError names the tool and field).
  // Tools without an entry keep the bare tool-URI Action. The map is served at `<path>/delegus-tools.json`
  // and named in the `Delegus-Tools` header, so agents build the same Action.
  map?: unknown
}

interface McpRequest {
  method?: string | undefined
  url?: string | undefined
  path?: string | undefined
  headers: Record<string, string | string[] | undefined>
  body?: unknown
  // Set on ALLOW: the Delegus receipt (v0.3: the checked response) and the Action that authorized this tools/call.
  delegus?: { receipt: McpReceipt; action: unknown; } | undefined
  // Set for every single tools/call with a string tool name: what the middleware saw and decided.
  delegusCall?: McpCallSeen | undefined
}

interface McpResponse {
  statusCode?: number | undefined
  setHeader(name: string, value: string): void
  end(body?: string): void
}

type McpMiddleware = (req: McpRequest, res: McpResponse, next: McpNext) => Promise<void>

type McpNext = () => void

type McpProtocol = "v0.3" | "v0.2" | "auto"

type McpReceipt = Receipt | VerifyResponseV3

class ToolMapError {
  new (message: string, tool?: string | null, field?: string | null): ToolMapError
  tool: string | null
  field: string | null
  name: string
  message: string
  stack?: string | undefined
  cause?: unknown
}

function encodeSegment(s: string): string

function isDotSegment(segment: string): boolean

function mcpAction(map: ToolMap, tool: string, toolUri: string, args: unknown): ToolMapResult | null

function resolvePointer(doc: unknown, pointer: string): unknown

function toMinorUnits(value: unknown, unit: "minor" | "major", decimals?: number): number | string

function toolMapHash(map: ToolMap): Sha256Ref

function toolMapWarnings(map: ToolMap): string[]

const TOOL_MAP_ACTIONS = {
  // Returns a string representation of an array.
  toString(): string
  // Returns a string representation of an array. The elements are converted to string using their toLocaleString methods.
  toLocaleString(): string
  // Combines two or more arrays.
  concat(...items: ConcatArray<"commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call">[]): ("commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call")[]
  // Adds all the elements of an array separated by the specified separator string.
  join(separator?: string): string
  // Returns a section of an array.
  slice(start?: number, end?: number): ("commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call")[]
  // Returns the index of the first occurrence of a value in an array.
  indexOf(searchElement: "commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call", fromIndex?: number): number
  // Returns the index of the last occurrence of a specified value in an array.
  lastIndexOf(searchElement: "commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call", fromIndex?: number): number
  // Determines whether all the members of an array satisfy the specified test.
  every<S extends "commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call">(predicate: (value: "commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call", index: number, array: readonly ("commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call")[]) => value is S, thisArg?: any): this is readonly S[]
  // Determines whether the specified callback function returns true for any element of an array.
  some(predicate: (value: "commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call", index: number, array: readonly ("commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call")[]) => unknown, thisArg?: any): boolean
  // Performs the specified action for each element in an array.
  forEach(callbackfn: (value: "commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call", index: number, array: readonly ("commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call")[]) => void, thisArg?: any): void
  // Calls a defined callback function on each element of an array, and returns an array that contains the results.
  map<U>(callbackfn: (value: "commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call", index: number, array: readonly ("commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call")[]) => U, thisArg?: any): U[]
  // Returns the elements of an array that meet the condition specified in a callback function.
  filter<S extends "commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call">(predicate: (value: "commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call", index: number, array: readonly ("commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call")[]) => value is S, thisArg?: any): S[]
  // Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
  reduce(callbackfn: (previousValue: "commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call", currentValue: "commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call", currentIndex: number, array: readonly ("commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call")[]) => "commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call"): "commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call"
  // Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
  reduceRight(callbackfn: (previousValue: "commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call", currentValue: "commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call", currentIndex: number, array: readonly ("commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call")[]) => "commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call"): "commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call"
  // Returns the value of the first element in the array where predicate is true, and undefined
  // otherwise.
  find<S extends "commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call">(predicate: (value: "commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call", index: number, obj: readonly ("commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call")[]) => value is S, thisArg?: any): S | undefined
  // Returns the index of the first element in the array where predicate is true, and -1
  // otherwise.
  findIndex(predicate: (value: "commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call", index: number, obj: readonly ("commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call")[]) => unknown, thisArg?: any): number
  // Returns an iterable of key, value pairs for every entry in the array
  entries(): ArrayIterator<[number, "commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call"]>
  // Returns an iterable of keys in the array
  keys(): ArrayIterator<number>
  // Returns an iterable of values in the array
  values(): ArrayIterator<"commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call">
  // Determines whether an array includes a certain element, returning true or false as appropriate.
  includes(searchElement: "commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call", fromIndex?: number): boolean
  // Calls a defined callback function on each element of an array. Then, flattens the result into
  // a new array.
  // This is identical to a map followed by flat with depth 1.
  flatMap<U, This = undefined>(callback: (this: This, value: "commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call", index: number, array: ("commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call")[]) => U | readonly U[], thisArg?: This | undefined): U[]
  // Returns a new array with all sub-array elements concatenated into it recursively up to the
  // specified depth.
  flat<A, D extends number = 1>(this: A, depth?: D | undefined): FlatArray<A, D>[]
  // Returns the item located at the specified index.
  at(index: number): "commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call" | undefined
  // Iterator of values in the array.
  __@iterator@208(): ArrayIterator<"commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call">
  // Is an object whose properties have the value 'true'
  // when they will be absent when used in a 'with' statement.
  __@unscopables@592: { readonly [x: number]: boolean | undefined; readonly length?: boolean | undefined; toString?: boolean | undefined; toLocaleString?: boolean | undefined; concat?: boolean | undefined; join?: boolean | undefined; slice?: boolean | undefined; indexOf?: boolean | undefined; lastIndexOf?: boolean | undefined; every?: boolean | undefined; some?: boolean | undefined; forEach?: boolean | undefined; map?: boolean | undefined; filter?: boolean | undefined; reduce?: boolean | undefined; reduceRight?: boolean | undefined; find?: boolean | undefined; findIndex?: boolean | undefined; entries?: boolean | undefined; keys?: boolean | undefined; values?: boolean | undefined; includes?: boolean | undefined; flatMap?: boolean | undefined; flat?: boolean | undefined; at?: boolean | undefined; [Symbol.iterator]?: boolean | undefined; readonly [Symbol.unscopables]?: boolean | undefined; }
}

const TOOL_MAP_VERSION: 1

interface ToolMap {
  version: 1
  tools: Record<string, ToolMapEntry>
}

interface ToolMapAmount {
  // JSON pointer to the amount.
  value: string
  // JSON pointer to the currency, or a literal ISO 4217 code (three upper-case letters).
  currency: string
  // "minor": the value is a non-negative safe integer in minor units. "major": a number or decimal string with at most `decimals` fractional digits, converted by string arithmetic.
  unit: "minor" | "major"
  // Required with "major": the currency's fractional digits (0–6).
  decimals?: number | undefined
}

interface ToolMapEntry {
  action: "commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call"
  // Literal text plus `{<json-pointer>}` placeholders. For api:call the result is appended to the tool URI; for the commerce types it is the resource itself.
  resource: string
  amount?: ToolMapAmount | undefined
}

type ToolMapAction = "commerce:quote" | "commerce:accept" | "commerce:fulfil" | "commerce:purchase" | "api:call"

type ToolMapResult = { ok: true; action: Record<string, JsonValue>; resource: string; method: string; } | { ok: false; error: string; field: string; }

class RouteMapError {
  new (message: string, route?: string | null): RouteMapError
  route: string | null
  name: string
  message: string
  stack?: string | undefined
  cause?: unknown
}

function checkHttpRequest(client: Delegus, opts: HttpCheckOptions, req: HttpRequestLike & { url: string; }): Promise<HttpCheckOutcome>

function createHttpMiddleware(client: Delegus, opts?: HttpMiddlewareOptions): (req: MinimalReq, res: MinimalRes, next: (err?: unknown) => void) => Promise<void>

function fastifyDelegusHttp(client: Delegus, opts?: HttpMiddlewareOptions): (request: { method: string; url: string; headers: Record<string, string | string[] | undefined>; body?: unknown; delegus?: unknown; }, reply: { code(c: number): unknown; header(n: string, v: string): unknown; send(b: unknown): unknown; }) => Promise<void>

function httpAction(compiled: CompiledRoutes | null, req: { method: string; url: string; body?: unknown; }): HttpActionResult

function matchRoute(compiled: CompiledRoutes, method: string, path: string): { route: CompiledRoutes["routes"][number]; params: Record<string, string>; } | null

const ROUTE_MAP_FILE: "delegus-routes.json"

const ROUTE_MAP_VERSION: 1

interface CompiledRoutes {
  map: RouteMap
  hash: string
  json: string
  routes: (RouteDef & { segments: Array<{ literal: string; } | { param: string; }>; })[]
  // The templates, as a tool map keyed by route id (so mcpAction renders them).
  templates: ToolMap
  // The same templates under the tool map's own member name, so mcpAction can read a CompiledRoutes directly.
  tools: Record<string, ToolMapEntry>
}

interface HttpCheckOptions {
  // The route map, already compiled with compileRouteMap; null = every request is `api:call` on its URL.
  routes?: CompiledRoutes | null | undefined
  protocol?: VerifyProtocol | undefined
  // The relying-party DID to advertise on missing credentials. Absent = resolved once via GET /me.
  relyingParty?: string | undefined
  onDecision?: ((d: { decision: "ALLOW" | "DENY"; reason: string | null; route: string | null; method: string; url: string; receiptId?: string; error?: string; }) => void) | undefined
}

interface HttpCheckOutcome {
  status: 200 | 401 | 403
  headers: Record<string, string>
  // Present when the request may proceed.
  receipt?: VerifyResult | undefined
  // Present on a refusal: the JSON body to send.
  body?: JsonObject | undefined
  decision: "ALLOW" | "DENY"
  reason: string | null
  action: JsonObject | null
  route: string | null
}

interface HttpMiddlewareOptions {
  // The route map JSON (validated here) or an already compiled one.
  routeMap?: unknown
  // The route map, already compiled with compileRouteMap; null = every request is `api:call` on its URL.
  routes?: CompiledRoutes | null | undefined
  protocol?: VerifyProtocol | undefined
  // The relying-party DID to advertise on missing credentials. Absent = resolved once via GET /me.
  relyingParty?: string | undefined
  onDecision?: ((d: { decision: "ALLOW" | "DENY"; reason: string | null; route: string | null; method: string; url: string; receiptId?: string; error?: string; }) => void) | undefined
}

interface RouteMap {
  version: 1
  routes: RouteDef[]
}

type HttpActionResult = { ok: true; action: JsonObject; route: string | null; } | { ok: false; reason: string; detail: string; route: string | null; }

function comparePolicy(report: ChainReport, policy: PolicyMapping): PolicyReport

function verifyChain(chain: ChainInput, keys: Record<string, Uint8Array>, grants?: readonly string[], serviceDid?: string): ChainReport

interface ChainInput {
  root: string
  links: { receipt_id: string; depth: number; receipt: string; decision: "ALLOW" | "DENY"; reason: string | null; evaluated_at: string; relying_party: string; principal: string | null; agent: string | null; grant_id: string | null; grant_hash: string | null; action: JsonValue | null; relies_on: Array<{ fingerprint: string; mode: string; checks: JsonValue; transaction_equal: boolean | null; receipt_hash?: string; receipt_id?: string; opening?: string; withheld?: boolean; }>; }[]
  withheld?: number | undefined
  truncated?: boolean | undefined
}

interface ChainReport {
  root: string
  ok: boolean
  links: LinkReport[]
  link_count: number
  withheld: number
  truncated: boolean
  not_confirmed_here: string[]
  // Each link's action as the chain carried it, by receipt id (for the policy comparison).
  actions?: Record<string, JsonValue> | undefined
}

interface LinkReport {
  receipt_id: string
  depth: number
  agent: string | null
  decision: "ALLOW" | "DENY"
  reason: string | null
  signature: "invalid" | "valid"
  body_matches_payload: boolean
  relies_on: { fingerprint: string; mode: string; prior_receipt_id: string | null; prior_agent: string | null; opening_reproduces: boolean | "withheld"; prior_is_allow: boolean | "withheld"; prior_signature: "valid" | "invalid" | "withheld"; }[]
  grant: { grant_id: string | null; grant_hash: string | null; supplied: boolean; hash_matches: boolean | null; parses: boolean | null; subject_is_agent: boolean | null; authority: Capability[] | null; audience: string[] | null; valid_from: string | null; valid_until: string | null; }
  ok: boolean
  failures: string[]
}

interface PolicyLink {
  receipt_id: string
  agent: string | null
  holder: { id: string; kind: string; } | null
  // matches: same authority; narrower: inside the policy's; wider: something the policy does not give; not_supplied: no Grant to compare; no_holder: the agent is not a holder at as_of.
  grant: "not_supplied" | "matches" | "narrower" | "wider" | "no_holder"
  detail: string | null
  // Per Grant Capability: the policy rule ids it traces to (empty when it fits no policy Capability).
  provenance: { capability: number; rules: string[]; }[]
  // The step this link performed, read from the action's resource; null when it cannot be told, with the candidates.
  step: string | null
  candidates: string[]
}

interface PolicyMapping {
  format: "delegus-pack-authority-map-v1"
  matrix_hash: string
  as_of: string
  relying_party: string
  grants: { did: string; id: string; kind: string; authority: Capability[]; audience: string[]; provenance: Array<{ capability: number; rules: Array<{ rule: string; role: string; unit: string; }>; }>; }[]
  steps: { action: string; operation: string; doc: string; creates: boolean; approval: boolean; distinct_from: string[]; requires_prior: string[]; quorum: { actions: string[]; min: number; } | null; }[]
}

interface PolicyReport {
  matrix_hash: string
  as_of: string
  ok: boolean
  links: PolicyLink[]
  segregation: SegregationCheck[]
  quorum: QuorumCheck[]
  not_confirmed_here: string[]
}

interface QuorumCheck {
  receipt_id: string
  step: string
  required: number
  distinct_voters: number
  verdict: "not_determinable" | "met" | "not_met"
  why: string
}

interface SegregationCheck {
  receipt_id: string
  prior_receipt_id: string | null
  agent: string | null
  prior_agent: string | null
  step: string | null
  prior_step: string | null
  // distinct: different agents; same_agent_violation: the policy requires different people here; same_agent_allowed: the same person, and the policy does not forbid it; not_determinable: a step or an agent is unknown (withheld, or ambiguous).
  verdict: "distinct" | "same_agent_violation" | "same_agent_allowed" | "not_determinable"
  why: string
}

function lintAuthority(authority: unknown): LintFinding[]

function luhnValid(d: string): boolean

function personalDataIn(s: string): PersonalDataKind[]

interface LintFinding {
  // Where, e.g. `authority[0].resources[1]`. The matched value is not echoed.
  path: string
  kind: PersonalDataKind
}

type PersonalDataKind = "email" | "phone" | "card"

const EVALUATION_ORDER_V3 = {
  // Gets the length of the array. This is a number one higher than the highest element defined in an array.
  length: number
  // Returns a string representation of an array.
  toString(): string
  // Returns a string representation of an array. The elements are converted to string using their toLocaleString methods.
  toLocaleString(): string
  // Combines two or more arrays.
  concat(...items: ConcatArray<CheckId>[]): CheckId[]
  // Adds all the elements of an array separated by the specified separator string.
  join(separator?: string): string
  // Returns a section of an array.
  slice(start?: number, end?: number): CheckId[]
  // Returns the index of the first occurrence of a value in an array.
  indexOf(searchElement: CheckId, fromIndex?: number): number
  // Returns the index of the last occurrence of a specified value in an array.
  lastIndexOf(searchElement: CheckId, fromIndex?: number): number
  // Determines whether all the members of an array satisfy the specified test.
  every<S extends CheckId>(predicate: (value: CheckId, index: number, array: readonly CheckId[]) => value is S, thisArg?: any): this is readonly S[]
  // Determines whether the specified callback function returns true for any element of an array.
  some(predicate: (value: CheckId, index: number, array: readonly CheckId[]) => unknown, thisArg?: any): boolean
  // Performs the specified action for each element in an array.
  forEach(callbackfn: (value: CheckId, index: number, array: readonly CheckId[]) => void, thisArg?: any): void
  // Calls a defined callback function on each element of an array, and returns an array that contains the results.
  map<U>(callbackfn: (value: CheckId, index: number, array: readonly CheckId[]) => U, thisArg?: any): U[]
  // Returns the elements of an array that meet the condition specified in a callback function.
  filter<S extends CheckId>(predicate: (value: CheckId, index: number, array: readonly CheckId[]) => value is S, thisArg?: any): S[]
  // Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
  reduce(callbackfn: (previousValue: CheckId, currentValue: CheckId, currentIndex: number, array: readonly CheckId[]) => CheckId): CheckId
  // Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
  reduceRight(callbackfn: (previousValue: CheckId, currentValue: CheckId, currentIndex: number, array: readonly CheckId[]) => CheckId): CheckId
  // Returns the value of the first element in the array where predicate is true, and undefined
  // otherwise.
  find<S extends CheckId>(predicate: (value: CheckId, index: number, obj: readonly CheckId[]) => value is S, thisArg?: any): S | undefined
  // Returns the index of the first element in the array where predicate is true, and -1
  // otherwise.
  findIndex(predicate: (value: CheckId, index: number, obj: readonly CheckId[]) => unknown, thisArg?: any): number
  // Returns an iterable of key, value pairs for every entry in the array
  entries(): ArrayIterator<[number, CheckId]>
  // Returns an iterable of keys in the array
  keys(): ArrayIterator<number>
  // Returns an iterable of values in the array
  values(): ArrayIterator<CheckId>
  // Determines whether an array includes a certain element, returning true or false as appropriate.
  includes(searchElement: CheckId, fromIndex?: number): boolean
  // Calls a defined callback function on each element of an array. Then, flattens the result into
  // a new array.
  // This is identical to a map followed by flat with depth 1.
  flatMap<U, This = undefined>(callback: (this: This, value: CheckId, index: number, array: CheckId[]) => U | readonly U[], thisArg?: This | undefined): U[]
  // Returns a new array with all sub-array elements concatenated into it recursively up to the
  // specified depth.
  flat<A, D extends number = 1>(this: A, depth?: D | undefined): FlatArray<A, D>[]
  // Returns the item located at the specified index.
  at(index: number): CheckId | undefined
  // Iterator of values in the array.
  __@iterator@208(): ArrayIterator<CheckId>
  // Is an object whose properties have the value 'true'
  // when they will be absent when used in a 'with' statement.
  __@unscopables@592: { readonly [x: number]: boolean | undefined; readonly length?: boolean | undefined; toString?: boolean | undefined; toLocaleString?: boolean | undefined; concat?: boolean | undefined; join?: boolean | undefined; slice?: boolean | undefined; indexOf?: boolean | undefined; lastIndexOf?: boolean | undefined; every?: boolean | undefined; some?: boolean | undefined; forEach?: boolean | undefined; map?: boolean | undefined; filter?: boolean | undefined; reduce?: boolean | undefined; reduceRight?: boolean | undefined; find?: boolean | undefined; findIndex?: boolean | undefined; entries?: boolean | undefined; keys?: boolean | undefined; values?: boolean | undefined; includes?: boolean | undefined; flatMap?: boolean | undefined; flat?: boolean | undefined; at?: boolean | undefined; [Symbol.iterator]?: boolean | undefined; readonly [Symbol.unscopables]?: boolean | undefined; }
}

interface DependencyDeclaration {
  fingerprint: `sha256:${string}`
  mode: "PRIOR_DECISION" | "CURRENT_AUTHORITY"
}

interface Receipt {
  // Non-detached compact JWS over JCS(body as signed).
  receipt: string
  receipt_version: "delegus-receipt-v2" | "delegus-receipt-v1" | "delegus-receipt-v3"
  // delegus-receipt-v1 only: the matched Capability, or null on DENY.
  authority?: Capability | null | undefined
  // delegus-receipt-v2: the matched Capability under a commitment (§R.6); the plaintext and its opening go to the RP beside the receipt.
  authority_commitment?: `sha256:${string}` | undefined
  // delegus-receipt-v2: sha256 over JCS(the declared dependencies with their per-entry results).
  // Constant size whatever the number of dependencies (KMS signs ≤ 4,096 bytes); the entries
  // themselves go to the relying party beside the receipt, like `authority`.
  relies_on_hash?: `sha256:${string}` | undefined
  // delegus-receipt-v2: sha256 over JCS(the relying party's `requires`), when it sent one, so D1 is reproducible.
  requires_hash?: `sha256:${string}` | undefined
  // delegus-receipt-v2: this receipt's pairwise transaction handle (22 chars base64url).
  transaction?: string | undefined
  receipt_id: string
  decision: Decision
  reason: ReasonCode | null
  evaluated_at: string
  relying_party: string
  principal?: { id: string; verification: "domain" | "unverified" | "managed"; } | undefined
  agent?: string | undefined
  grant_id?: string | undefined
  grant_hash: `sha256:${string}`
  proof_hash: `sha256:${string}`
  request_hash?: `sha256:${string}` | undefined
  expires_at?: string | undefined
  evidence: ReceiptEvidence
  trust: { result: LayerResult; policy_version: ProfileSpec["policy"]; checks: Record<string, CheckOutcome>; }
  protocol: Omit<{ result: LayerResult; profile: ProfileId; profile_hash: Sha256Ref; checks: Record<string, CheckOutcome>; }, "checks"> & { checks: ReceiptBody["protocol"]["checks"] | string; }
}

interface ReverifyResult {
  // Signature valid, every supplied artifact matches its pinned hash, and everything that could be reproduced was.
  ok: boolean
  signature: "invalid" | "valid"
  detail?: string | undefined
  hashes?: Record<"profile" | "grant" | "proof" | "request" | "did_document" | "status_credential" | "trust_config", HashComparison> | undefined
  // Whether `protocol`, `decision` and `reason` were reproduced, and what differed.
  reproduced?: { protocol: boolean; decision: boolean; differences: string[]; } | undefined
  // What this run could not reproduce and why: the trust attestations (always), and for a v0.3 receipt
  // the commitments without their openings, P21 without the consumption snapshot, D1–D7 without the
  // dependency material, and the decision when it rests on one of those. Not a failure; a boundary.
  notReproduced?: { what: string; why: string; }[] | undefined
  receipt?: ReceiptBody | undefined
  recomputed?: ReceiptBody | undefined
}

type DependencyMode = "PRIOR_DECISION" | "CURRENT_AUTHORITY"

type TrustedKeys = { readonly [x: string]: Uint8Array<ArrayBufferLike>; }