Entity Bind / Resolvd API quickstart — offer planned

Read without an account:
  /api/docs              Static navigation and request access
  /api/pricing           Subscription plans, limits and planned evaluation offer
  /api/openapi.json      Generated shipped schema and revision fingerprints
  /api/mcp              Complete MCP connection and tool guide
  /api/mcp/tools.json    Generated MCP tools/list schemas and metadata
  /api/operations        Auth, errors, rate limits, retries and long-running work
  /api/sandbox           Executable isolated local sandbox with a dated offline feed
  /api/openai-agents     Runnable OpenAI integration and investigation workspace
  /docs and /redoc       Interactive Swagger and browsable API reference
  /api/demo              Finite snapshots, never arbitrary live execution
  /api/evidence          Methodology and evidence limitations
  /llms.txt              Agent index
  /llms-full.txt         Full corpus with current generated OpenAPI

Request evaluation access: mailto:support@tenhaw.com?subject=Entity%20Bind%20evaluation%20access
The owner authorizes an agent and receives a resolve-scoped key via the issued-key
flow. No instant key is promised while launch gates are blocked. Use the actual
API origin and MCP URL supplied by your deployment; do not guess hosted origins.

With an authorized key, set RESOLVD_API_ORIGIN and RESOLVD_API_KEY in your local
secret environment. First make a free, authenticated readiness read:

curl --fail-with-body "$RESOLVD_API_ORIGIN/v1/reference/enrichment-fields" \
  -H "Authorization: Bearer $RESOLVD_API_KEY"

This resolution request performs computation and can use credits:

curl --fail-with-body "$RESOLVD_API_ORIGIN/v1/resolve" \
  -H "Authorization: Bearer $RESOLVD_API_KEY" \
  -H 'Content-Type: application/json' \
  -H 'Idempotency-Key: own-evaluation-smoke-1' \
  --data '{"name":"INSTITUTE OF PATENTEES & INVENTORS","country":"GB",
    "registration_number":"00170887","jurisdiction":"GB","depth":"research"}'

Read /v1/usage, /v1/reference/limits and /v1/reference/enrichment-fields using that
key for actual balances/source availability/rights. Read each response's
/v1/decisions/{decision_id} for its authorized receipt. Stateless /v1/match
has no entity ID or resolve receipt; repeated calls are fresh work unless they
are retries of the same durable operation. Same idempotency key with changed
content is a conflict. Different resolve company content is fresh computation.

MCP uses the actual deployment MCP origin and the same resolve-scoped bearer key.
resolve_company supports the company context and structured address schema;
REST and MCP share the tenant grant. The same key cannot administer accounts or
approve reviewer decisions. Runtime source readiness remains authenticated.
Use /api/mcp for copyable connection examples and current tool schemas;
/api/operations explains typed errors, Retry-After, idempotency and long tasks.

This deployment's shared production batch limit: 500 records. Batch admission
must include row/internal-comparison exposure, not one standalone 5-credit ceiling.

Evaluate Entity Bind on your own companies. We are preparing 1,000 one-time
credits with full research depth, no card and 30 days from your first admitted
resolution-family computation. Request evaluation access; availability requires
confirmation. Status: planned; instant self-service activation is not live.

Planned grant: 1,000 lifetime credits and 1,000 lifetime deep attempts per
eligible verified organization/account, shared by its tenant's keys, REST and
MCP. No renewal, automatic purchase, card charge or overage. The separate Free
plan remains 300 credits with probabilistic maximum depth.

Chargeable shallow outcomes use 1 credit; adjudication/research outcomes use 5.
Abstentions, no identifying signal and eligible exact-content resolve replays
use 0. Chargeable new_entity outcomes retain their existing billing. Credits
are not response counts: up to 1,000 shallow or 200 deep chargeable outcomes,
or a mixture. Deep attempts include abstentions. Reads consume no credits.

New research-capable operations reserve 5 credits; with only 1-4 available,
explicitly choose depth=probabilistic (1-credit ceiling) or receive
an evaluation_insufficient_credits refusal. Never silently lower depth.
Deep-attempt exhaustion, expiry and provider-spend pauses are distinct refusals.
Confirmed eligible free replay and authorized evidence reads survive expiry,
subject to published retention and erasure. Upgrade needs explicit purchase.

Proposed evaluation throughput: 60 resolve/match operations per minute and two
concurrent deep executions per tenant. Shared production source/request/batch
limits also apply. Monetary ceilings and expected pause behavior require an
operator decision and measured pilot costs before activation. No numerical
provider-spend ceiling has been approved by this repository implementation.

Evidence methodology

New resolve, compare and batch submissions require a nonblank company `name` and valid
`country` (country name or ISO code), even when a legal identifier is supplied. Optional
`description` maps to `context`; `postcode` maps to `address.postal_code`. Conflicting
alias and canonical values are rejected. Existing-catalogue reads retain optional filters.

Freeze user-chosen cases and independently expected authority-qualified company
numbers or LEIs before execution. Include exact identifiers, legal-name variants,
name/domain, postcode, country, typed city, town prose, business descriptions,
common-name collisions, brands/subsidiaries, stale or misleading context and true
no-matches. Keep unknown truth unknown. Test cold and explicitly seeded catalogues
separately; a namespace reset must never replenish evaluation entitlement.

Inspect decision, match_confidence, match_confidence_basis, entity_created,
clarification, shortlist and receipt together. A newly minted entity ID alone
proves no real-world identity. Candidate-backed accepted matches require >=0.90;
confidence is population-calibrated evidence, not independent accuracy proof.
Check each returned field's source, time, currency/period, company/group scope
and licence. Missing fields remain absent; no commercial data rights are bundled.

Export every outcome, including errors, ambiguities and abstentions. Report
coverage, independently verified precision, unknown truth, false binds, latency,
field fill/freshness and credit/provider cost separately with denominators and
company-family grouping. Compare identical frozen inputs and source access/date.
Never discard difficult cases after seeing results or prescribe a recommendation.

The internal regression accepts 499/705. The 99% minimum-input target remains
unmet. Historical UK replay's 1,666/1,740 includes legacy/missing calls and no
full-prompt-verified calls. Neither these results nor this small fixture supports
an independent current customer holdout or a global 'best' claim.

The starter runner is scripts/run_own_case_eval.py in the repository. Its freeze
command accepts CSV/JSON. Its run command consumes the immutable manifest and
exports all cases; offline records require matching request hashes. Live execution
requires the account owner's issued key and an explicit --allow-live option.
Do not impersonate a person to obtain access. A headless agent can use an issued
resolve-scoped bearer key; MCP connection and OAuth authorization are documented
at /api/mcp. Public researching agents need no identity for these docs/examples.

Data retention: evidence_retained_until is a minimum of 30 days after evaluation
expiry, subject to authorized erasure/revocation. Automatic maintenance purge
skips all evaluation tenants to preserve evidence through expiry extensions.
There is no automatic evaluation-data deletion schedule; the owner can explicitly
erase data. A dynamic deletion policy and minimal eligibility/abuse retention
remain launch decisions. No scheduled deletion promise is made here.


# API and MCP operations: errors, limits, retries and long tasks

[API quickstart](/api/quickstart.txt) · [MCP guide](/api/mcp)
· [Generated OpenAPI](/api/openapi.json) · [MCP catalogue](/api/mcp/tools.json)
· [Interactive Swagger](/docs) · [ReDoc reference](/redoc) · [Local sandbox](/api/sandbox)

## Compatibility and deprecation

`/v1` is the REST contract major version. OpenAPI `info.version` identifies the
pipeline release, not a replacement URL version. `x-resolvd-revision` records
runtime/schema fingerprints so evaluations can compare actual implementations.
MCP negotiates its protocol version separately and publishes current tool schemas.

Within `/v1`, retain existing endpoint paths, required inputs, established field
types and meanings. New optional inputs must preserve behavior when omitted;
responses may gain fields, so clients should tolerate unknown response fields.
Breaking removals or incompatible schema changes require a new major contract
and migration instructions. Provider facts, calibrated policy and resulting
decisions can evolve with dated data/pipeline revisions; a compatible schema does
not promise identical matching results forever.

Deprecation policy: mark an affected operation `deprecated: true` in OpenAPI,
publish its replacement, migration steps and proposed retirement date in the
release notes before removal, and keep it operational during the announced
migration interval. Do not silently remove a `/v1` operation. Security fixes may
tighten authorization to close an exposure; their migration notes must identify
the changed permission and required owner action. Current deprecated operations:
none. No retirement date is announced
unless the operation's deprecation notice explicitly supplies one.

## Authentication and machine-readable contracts

Send `Authorization: Bearer <issued credential>` over HTTPS. Do not send keys
in URLs. Request only the scopes accepted by the operation; OpenAPI's
`x-accepted-key-scopes` records alternatives, not cumulative requirements.
The MCP catalogue carries each tool's own schema and metadata. Reference and
receipt reads require authorization even though they consume no credits.

## Error envelopes

Non-OAuth REST errors use `error.code`, `error.message`, `error.correlation_id`
and `error.details`. OAuth follows its own OAuth error contract. The following
is a **format example**, not a captured live failure:

```json
{
  "error": {
    "code": "rate_limited",
    "message": "Too many requests",
    "correlation_id": "req_example",
    "details": {"retry_after": "5"}
  }
}
```

MCP application errors set `isError: true` and carry the error envelope in
`structuredContent`; SDK schema rejection can instead carry validation content
without application metadata. Authentication can fail at the HTTP boundary with
an OAuth-style `error` string and bearer challenge.
Preserve the correlation ID when reporting a problem. Internal/storage errors
are deliberately opaque. Field validation errors require corrected input.

| Response or condition | Client action |
|---|---|
| `401` / `unauthorized` | Obtain a valid credential; follow the OAuth challenge when applicable. |
| `403` / `key_scope_forbidden` | Ask the owner for a scope accepted by this operation. |
| `409` / idempotency conflict | Bind each operation key to one unchanged request. |
| `413` / body too large | Reduce payload size using the published limits. |
| `422` / invalid input | Fix fields against the schema; unknown arguments are rejected. |
| `429` / `rate_limited` | Wait `Retry-After`; use bounded backoff, jitter and a retry limit. |
| `503`, deadline or transport interruption | Keep the operation key; inspect and reconcile state. |
| `unresolved` | Completed abstention: inspect clarification; do not loop unchanged input. |
| Evaluation refusal | Inspect its code and balances; never silently lower depth. |

## Pace calls using returned limits

REST publishes `RateLimit-Limit`, `RateLimit-Remaining` and `RateLimit-Reset`
on rate-limited operations; refusals publish `Retry-After`. Reset and retry
values are seconds, not Unix timestamps. Use the headers on your response:
limits depend on the operation, credential plan and current shared bucket.
Read authenticated `/v1/reference/limits` for configured limits and `/v1/usage`
for usage. MCP tool results publish `_meta.resolvd.correlation_id` and
`_meta.resolvd.rate_limit` with `scope`, `limit`, `remaining`, `reset_seconds`
and `retry_after_seconds`. Inspect this metadata as well as the error envelope
and HTTP response. Zero retry seconds means the rate gate admitted the call,
not that provider work or billing succeeded. A rate bucket is not a credit balance.

Configured base token-bucket capacities before plan multipliers:

| Operation bucket | Capacity / maximum full-bucket burst | Continuous refill / second |
|---|---:|---:|
| Read | 1000 | 16.6667 |
| Resolve | 300 | 5 |
| Match | 300 | 5 |
| Batch | 30 | 0.5 |

The credential's plan multiplier scales capacity and refill; returned headers
publish effective values. A full bucket permits up to its capacity immediately,
then refills continuously. These are admission ceilings, not a throughput SLA.
Batch calls have separate row/compute admission and credit constraints. REST/MCP
share tenant buckets with the same Redis state; without Redis, buckets are local
to each process. Per-IP gates and provider/concurrency limits can also refuse a
call. No advertised burst bypasses those limits.

The configured request deadline is 300 seconds
(zero disables it). The batch ceiling is 500 records.
Client timeouts should allow the server's deadline and response transfer.
Lower concurrency when a concurrency gate refuses work; aggressive retries
make the same queue worse. Do not split a request merely to evade admission.

## Idempotency, replay and charging

For REST computation use `Idempotency-Key`; MCP computation tools accept
`idempotency_key`. Send the same key and same payload on a retry. A changed
payload with the same key is a conflict. Store the operation key before sending.
Stateless pair matching is new computation on a new operation; it creates no
resolve receipt. Exact-content resolve replay is separately reported and free.

Read the response's `usage` and evaluation state. Shallow chargeable results
cost one credit; deep chargeable results cost five. Abstentions consume no
credits but can consume deep attempts and provider budget. A 1,000-credit
evaluation is not 1,000 chargeable research results. Trial access remains
[planned](/api/pricing); no card, automatic purchase or hidden downgrade is promised.

## Long-running work and progress

The shipped schema includes durable batch jobs:

1. Submit `POST /v1/batch-jobs` with the required `Idempotency-Key` and a body
   matching OpenAPI. A `202` acceptance gives a `Location` to poll; it is not a
   completed match or enrichment result.
2. Read `GET /v1/batch-jobs/{id}` for state and lifecycle progress. State names are
   progress evidence; do not turn them into an invented percentage.
3. Read `GET /v1/batch-jobs/{id}/result` after successful completion. Consume
   `GET /v1/batch-jobs/{id}/events` as SSE for events; reconnect with
   `Last-Event-ID` to resume from your last processed event.
4. Handle `queued`, `running`, `succeeded`, `failed`, `cancelled`, `erased` and
   `reconciliation_required` separately. An unresolved execution commitment
   requires reconciliation, not blind resubmission under a fresh key.

`POST /v1/batch-jobs/{id}/cancel` cancels queued work; execution already running
cannot be recalled. `/result` returns `202` with `Retry-After` while queued/running,
`200` with the completed batch, or an error for a terminal state with no result.
Erased results return `410`; completed failures do not become successful empty
batches. An SSE event does not replace the authoritative result or receipt.

Example submission (computation can consume credits), followed by polling:

```bash
: "${RESOLVD_API_ORIGIN:?Set the operator's API origin}"
: "${RESOLVD_API_KEY:?Set your issued credential}"
curl --fail-with-body -i "$RESOLVD_API_ORIGIN/v1/batch-jobs" \
  -H "Authorization: Bearer $RESOLVD_API_KEY" \
  -H 'Content-Type: application/json' \
  -H 'Idempotency-Key: own-batch-evaluation-1' \
  --data '{"records":[{"name":"INSTITUTE OF PATENTEES & INVENTORS","country":"GB",
    "registration_number":"00170887","jurisdiction":"GB","depth":"research"}]}'

# Set the returned job_id. Honor Retry-After; do not poll in a tight loop.
: "${RESOLVD_JOB_ID:?Set the returned job_id}"
curl --fail-with-body "$RESOLVD_API_ORIGIN/v1/batch-jobs/$RESOLVD_JOB_ID" \
  -H "Authorization: Bearer $RESOLVD_API_KEY"
curl --fail-with-body -N "$RESOLVD_API_ORIGIN/v1/batch-jobs/$RESOLVD_JOB_ID/events" \
  -H "Authorization: Bearer $RESOLVD_API_KEY" \
  -H 'Accept: text/event-stream' -H 'Last-Event-ID: 0'
```

Persist the last processed event ID before reconnecting; `0` requests the initial
history. Connections are finite and may end before the job does. Workers recheck
credentials before execution; revoked credentials cannot start queued work.
The operator must run `python -m resolvd.worker` with the same database/configuration
as the API. `--once` processes a bounded worker tick. A stopped worker leaves jobs
queued; accepting a job does not prove a worker is healthy.


## Signed completion webhooks

Register `POST /v1/webhooks` with a required `Idempotency-Key`, your public HTTPS
port-443 `url` and `event_types` from OpenAPI. This requires resolve permission;
reading subscriptions/delivery receipts accepts read permission. Private/local
destinations and redirects are refused. Store the returned `whsec_` signing secret
in your receiver's secret store. An idempotent creation retry returns the same
subscription/secret; list responses omit secrets.

Notifications contain a job ID/state, not organization records or credentials.
Retrieve the result using your own authenticated API call. The supported events
are the terminal `batch.succeeded`, `batch.failed`, `batch.cancelled`,
`batch.reconciliation_required` and `batch.erased` states.

Verify Standard Webhooks headers `webhook-id`, `webhook-timestamp` and
`webhook-signature`. Base64-decode the secret after removing `whsec_`; compute
HMAC-SHA256 over `webhook-id + '.' + webhook-timestamp + '.' + exact_body_bytes`.
Compare its base64 value with the `v1,` signature using constant-time comparison.
Reject timestamps outside a five-minute tolerance before accepting the event.
Verify the exact received bytes before parsing or reserializing JSON.

Persist/deduplicate `webhook-id`, acknowledge with a `2xx` response, and process
asynchronously. At most five attempts use delays of 5, 30, 120 and 600 seconds;
retries keep the same event ID. Inspect `GET /v1/webhooks/{id}/deliveries` for the
latest 100 delivery receipts, including final `failed` state. A delivery failure
does not change the job result; polling remains available. `DELETE /v1/webhooks/{id}`
disables delivery, but cannot recall a request already in flight.

The operator must configure `RESOLVD_WEBHOOK_SIGNING_KEY` (at least 32 characters)
and run the shared worker. There is no default key. Existing subscriptions pin
the master-key fingerprint; changing the key requires explicit operator recovery.


## Company fields and local changes

Discover fields and named packs at `GET /v1/reference/enrichment-fields` or MCP
`get_enrichment_fields`. `POST /v1/resolve`, `GET /v1/entities/{entity_id}` and
`GET /v1/entities/{entity_id}/intelligence` accept `fields`, `field_packs` and
`include_field_status`. For GET requests, repeat a query parameter for each
selected name, for example `?fields=identity.legal_name&fields=financials.revenue`.
These selectors only project returned values and provenance; they do not limit
source acquisition, change evidence or reduce computation charges. The default
with neither selector remains the complete authorized view.

Explicit selections include `field_status`; `include_field_status` requests
diagnostics for the complete view, and intelligence reads default to diagnostics.
Missing values stay separate from `field_status`; no null is replaced with a
diagnostic object and no missing amount becomes zero. `not_checked` is not a
company-specific absence finding. Capability readiness and resale entitlement
are also separate from company coverage and fact-level licences. Unknown
financial entity/group scope remains `unknown`.

`GET /v1/entities/{entity_id}/events` and MCP `get_entity_events` accept repeated
`categories` names such as `financials`, `ownership` or `legal_status`. Consume
`next_cursor` even when filtering returns no events. `scanned_count` is the
number scanned before filtering; a full scanned page can have later matches.
These events reflect committed local watch observations, not a live provider
monitoring service. Read values and their citations through `/intelligence`.

## Company workflows with retained local evidence

These October 7 additions are implemented locally. The repository records
development validation separately from deployment. Production is unchanged on
schema `0029`. Development migration `0030`
requires coordinated API/worker rollout. The running OpenAPI/tool catalogue
states which contracts this deployment actually serves.

| Workflow | Primary REST paths under `/v1` |
|---|---|
| Portfolios | `/portfolios`, `/portfolios/{portfolio_id}` and child routes |
| Financial statements | `GET /entities/{entity_id}/financial-statements` |
| Identifier lifecycle | `GET /entities/{entity_id}/identifier-history` |
| Source disagreement | `POST /entities/{entity_id}/source-comparison` |
| Typed local queries | `GET /reference/search-fields`; `POST /entities/query` |
| Cited relationship paths | `POST /relationships/explain` |
| Data-selection receipts | `POST /data-selections`; `/data-selections/{receipt_id}` |

Equivalent registered MCP tools:

- Portfolios: `manage_portfolio`, `list_portfolios`, `get_portfolio`,
  `manage_portfolio_member`, `get_portfolio_members`, `get_portfolio_events`,
  `enable_portfolio_watches`, `export_portfolio`.
- Statements: `get_financial_statements`, `select_financial_statement`,
  `compare_financial_statements`.
- Identifier lifecycle: `get_identifier_history`.
- Source disagreement: `compare_entity_sources`.
- Typed queries: `get_search_fields`, `query_companies`.
- Relationships: `explain_relationship_paths`.
- Receipts: `capture_data_selection`, `get_data_selection`, `delete_data_selection`.

Use company IDs already owned by the authenticated tenant. Reads use retained
facts/configured authorized local observations, with no provider or model calls.
Remote `read` or `resolve` credentials can read; list edits, receipt creation
and deletion require `resolve`. Optional `capture: true` also requires that
scope. Ordinary reads save no receipt. These workflows make no company-match
decision or source-fact correction.

Discover filter operators with `get_search_fields` or the REST reference route.
All query filters combine with AND. `identity.legal_name` supports `eq`,
`contains`, `in`; `digital.domain` and `location.country` support `eq`, `in`.
`entity_id` supports `eq`, `in`, and `created_at` supports `gte`, `lte`.
Only `created_at`/`entity_id` are sortable, with `asc`/`desc` directions and an
entity-ID tie-break. `UK` aliases to `GB`; date-times need timezones and must be
UTC-representable. Returnable enrichment fields are not automatically searchable.

For `POST /v1/entities/query`, this is the body; MCP `query_companies` takes it
as `payload`:

```json
{
  "filters": [{"field":"location.country","operator":"in","value":["GB","US"]}],
  "sort_by":"created_at","direction":"asc","limit":50,"scan_limit":500
}
```

Bounds are 16 filters, 50 strings per `in`, 100 matches and 1,000 scanned rows
per request. Read `scanned_count` and follow `next_cursor` even through empty
filtered pages, keeping the same filters/sort. Stop when it is null. The cursor
fixes tenant/query and creation-time boundary; corrections/deletions can still
change values. Source-effective `as_of` is not a complete knowledge snapshot.

Financial selection takes a `selection` object with optional sibling `capture`.
The exact wrapper is shared by REST and MCP. This MCP call only reads:

```json
{
  "jsonrpc":"2.0","id":6,"method":"tools/call",
  "params":{
    "name":"select_financial_statement",
    "arguments":{
      "entity_id":"ent_from_your_own_resolve_result",
      "payload":{
        "selection":{
          "relative_period":0,
          "requirements":{"attributes":["financials.revenue"]},
          "preferences":{"currency":"GBP","scope":"consolidated_group"}
        },
        "capture":false
      }
    }
  }
}
```

REST `POST /v1/entities/{entity_id}/financial-selection` takes that `payload`
object as its body. Use exact `statement_id`, exact ISO `period_end`, or integer
`relative_period` 0 to 20. Relative zero means the newest distinct available
reporting end after strict requirements, not a calendar-year offset. Exact and
relative periods cannot be combined. Both criteria objects support `source_id`,
uppercase three-letter `currency`, `scope`, `basis` and exact financial
`attributes`. Scope is `legal_entity`, `consolidated_group` or `unknown`; basis
is `reported`, `derived`, `estimated`, `average`, `point_in_time` or `unknown`.

Requirements never fall back; unavailable strict choices return `selected: null`
and a gap. Preferences choose the fewest mismatches, then latest dates/stable ID.
Read `requested`, `selected`, `actual`, `fallback_reasons` and `gaps` together.
No FX conversion or consolidation inference occurs. The inventory returns
stable IDs, source fingerprints, cited observations and truncation/coverage
gaps. Archives retain admitted values already acquired, not all upstream filings.
POST `/v1/entities/{entity_id}/financial-comparison` with `left_statement_id`
and `right_statement_id`; the response keeps
both cited statements, `inventory_gaps`, `inventory_truncated`, `inventory_note`
and comparison gaps. A changed amount or amendment is not proof of restatement;
explicit source restatement status and an earlier-accession link are required.

Portfolios allow 100 lists per tenant and 1,000 owned companies per list. Create
with `POST /v1/portfolios` and a name/optional stable `portfolio_id`; rename with
PATCH, delete with DELETE. PUT/DELETE `/members/{entity_id}` maintain membership,
with optional `customer_reference`/`role` as list metadata, not identity evidence.
List/member/export pages have at most 100 entries. Watch enabling accepts
`interval_seconds` 300 to 86400, `limit` and `cursor`; follow returned pages.
At most 1,000 entity watches exist per tenant. Re-enabling preserves baselines;
watches are shared across lists. Removing a list/member leaves company data and
shared watches intact. Events expose local observation changes and advancing
cursors/scanned counts, not complete provider history. Export pages contain
current local values/citations and are not a frozen multi-page snapshot.

Identifier history keeps sourced validity/successor evidence and paged durable
local correction events separate. A provider removal is not dissolution and
there is no automatic ID redirect. Source comparison takes `fields`, optional
`include_history` and `capture`; it returns dated observations/survivor policy,
disagreement, bounds, `withheld_by_licence` and `coverage_complete: false`.
Future/pass-through values are excluded. Relationship explanation takes two
owned entity IDs, optional `as_of`, `max_hops` 1 to 10, `limit` 1 to 20 and `capture`.
Edges are cited and dated; share ownership, control and accounting consolidation
stay distinct. Missing paths do not prove absence or shared legal identity.

Set `capture: true` on financial selection, source comparison or relationships,
or POST `/v1/data-selections` with `entity_ids`, optional `fields`, `field_packs`
and `as_of`. Limits are 1,000 receipts per tenant, 100 companies, 5,000 contributing
customer-record references and 2,000,000 UTF-8 JSON bytes per capture. Current
projections refresh authorized local feeds; historical captures use retained
stored facts, without replaying a complete old feed or prior knowledge state.
Pass-through values never enter a saved capture. Receipts fix values, citations,
source/evaluation dates, policy and fallback/gaps. Fingerprints normalize caller
resale flags to false, as stated by `fingerprint_scope`; receipt retrieval derives
current eligibility from captured licences and the current caller plan, preserving
raw values. No supplier licence is acquired or refreshed. Entity, contributing
customer-record and captured intermediary erasure purge the entire receipt.
GET `/v1/data-selections/{receipt_id}` to reopen it; DELETE that path to remove
the capture without changing company facts. Keep its reference to reopen/download it.

For safe response-loss retries, supply a stable client-generated `capture_id`
in the projection request or beside `capture` in a financial/source/relationship
wrapper. This optional ID accepts ASCII `[A-Za-z0-9_-]{1,64}` and becomes
`receipt_id`; otherwise it remains a generated `ds_<uuid>`. Within the same
tenant, the same ID and workflow/input intent return the original immutable
receipt/snapshot with current caller redistribution rights. Changed intent
returns HTTP `409`. Replay does not refresh observations or call remote providers.
Deleting/erasing the receipt keeps that ID reserved; it cannot recreate the
capture. Retry returns `409`, or company access checks may return `404` first.
Use a new ID for a new capture. The ledger retains only tenant ID and SHA-256
token/intent hashes, with no plaintext token, company IDs or evidence. There
are at most 10,000 explicit capture-ID reservations per tenant; the live receipt
limit remains 1,000.

The workspace exposes these operations through authenticated `/portal/api`
routes. No Orbis dataset/access, global lifecycle database, complete upstream
history, CRM writeback or new accuracy claim is implied.


## Company-only reference batches without AI

`POST /v1/company-reference/batch` and MCP `lookup_company_reference_batch`
read the existing licensed Tenhaw company warehouse. They do not invoke company
resolution, models, public registries or metered commercial enrichment APIs.
The workspace Company lookup view also accepts a mapped UTF-8 CSV and exports
the returned profiles. This workflow consumes zero resolution credits.

The request takes `records` (1-100 rows) and `limit` (2-10 candidates per row,
default 5). Each row accepts only `client_ref`, `domain` and optional US/GB
`country`; UK aliases to GB. Unknown input columns are not imported. Example:

```json
{"records":[{"client_ref":"crm-1","domain":"example.com","country":"GB"}],"limit":5}
```

For MCP put this object in `arguments.payload`. Each response row preserves its
one-based `row_number` and original input. Status is `candidates`, `no_candidates`,
`unavailable`, `missing_domain` or `invalid_input`. Unavailable results carry a
fixed reason; they do not imply the company does not exist. Every competing
profile up to the cap is retained, with explicit truncation and licensed,
unverified source snapshot provenance. A profile is not a verified legal match;
snapshot extraction dates do not establish field freshness. No profiles are
automatically selected or written to a tenant entity/decision store.

One batch admission and one ordinary tenant READ admission per distinct valid
normalized domain/country are required before any warehouse lookup. Insufficient
read allowance rejects the batch with rate_limited before source work. Duplicate
rows share one lookup within a request but remain separate output rows. At most
four warehouse queries run concurrently; a 30-second execution budget returns
completed rows and explicitly labels unfinished rows unavailable/request_deadline.
Each individual source read retains its existing five-second maximum budget.


## Evaluate evidence, not response volume

Check decision/confidence basis, identity authority and each field's source,
reporting period, currency and legal-entity/group scope. A populated employee
field for the wrong group or period is not verified enrichment. Preserve errors,
abstentions, unknown truth and budget interruptions in the denominator.
[Dated examples](/api/demo) and [evidence methodology](/api/evidence) state their
limits; neither is a live demonstration or proof of 99% accuracy.


# Run a local offline sandbox

From a repository checkout with dependencies installed (`uv sync`), run:

```bash
uv run python scripts/run_local_sandbox.py
```

Open `http://127.0.0.1:8000/docs` for interactive Swagger, `/redoc` for the
reference, or `/api/docs` for static/agent discovery. `--port` changes the local
port; `--data-dir` accepts an empty directory. By default the launcher creates
a fresh temporary directory and prints its path. It never resets an existing
database. Keep real customer inputs out of this disposable evaluation state.

This runs the production composition, validation, resolver, enrichment, persistence,
receipts, rate limiting and usage ledger. It uses SQLite locally; shared production
uses its configured database and Redis. The launcher ignores process environment,
`.env` and secret directories, disables network registries and models, and loads
only the checked-in official Scottish Refugee Council enrichment snapshot.
No paid provider credentials are loaded. The fixture is dated, not a live lookup
or a coverage benchmark. The API also mounts the authenticated MCP endpoint at
`/mcp`; the bootstrap `dev-local` credential is accepted by REST only. Use a
persisted API key for remote MCP requests.

The development-only `dev-local` credential works on this loopback listener.
This is local operator access, not an activated public 1,000-credit trial. The
normal ledger reports modeled credits, with no purchase or provider charge.

```bash
curl --fail-with-body http://127.0.0.1:8000/v1/resolve \
  -H 'Authorization: Bearer dev-local' \
  -H 'Content-Type: application/json' \
  -H 'Idempotency-Key: sandbox-company-1' \
  --data '{"name":"Scottish Refugee Council","country":"GB",
    "registration_number":"SC145067","jurisdiction":"GB","depth":"research"}'
```

The first request creates a local entity from the submitted identifier and
enriches it with the exact-ID feed: income GBP7,194,086 and 94 average employees,
for the legal entity from 2024-04-01 through 2025-03-31. It reports `new_entity`,
not an independently verified candidate match. No revenue is invented. Provenance
retains source URLs, licence and measurement period. The checked-in
`data/charity-ngo-source-snapshot-2026-09-06/manifest.json` records source artifacts
and hashes; `docs/CHARITY-DATA.md` explains the filed accounts and OGL attribution.

Repeat the identical keyed request to exercise safe operation retry. Read its
`/v1/decisions/{decision_id}` receipt with the same bearer header. Submit a name
absent from the local catalogue to see an unverified local `new_entity`, without
registry identity or enrichment; this sandbox cannot research arbitrary
organizations. A local entity ID is not an accepted real-world match.
Read source readiness at
`/v1/reference/enrichment-fields`. The [MCP guide](/api/mcp) shows equivalent
`resolve_company` arguments for the embedded MCP endpoint. The sandbox does not
simulate provider intelligence or remote OAuth consent.
An idempotent retry returns the original operation's usage receipt without a new
ledger charge; do not sum repeated copies of that receipt as new spending.

Unkeyed exact-content replay is also free, but a prior novel mint can be withheld
when it does not meet the current candidate-match confidence floor. Do not treat
an initial `new_entity` as a guarantee of subsequent accepted-match confidence.

Stop with Ctrl-C. The database remains in the printed directory for inspection;
each launch requires a new empty directory. Its transient erasure key is not a
production recovery mechanism. [API operations](/api/operations) describes the
separate worker and deployment setup. Contract parity does not imply identical
data, performance, topology or live-provider answers.


# Entity Bind / Resolvd MCP guide

Connect an authorized agent to the same company-resolution services used by REST.
This guide and the [generated tool catalogue](/api/mcp/tools.json) are anonymous,
free reads. Reading documentation does not activate an evaluation or execute tools.
[API quickstart](/api/quickstart.txt) · [Errors, retries and long tasks](/api/operations)
· [OpenAPI](/api/openapi.json) · [Dated examples](/api/demo) · [Offer](/api/pricing)

## Connect a remote client

Use **Streamable HTTP** and the exact HTTPS MCP URL supplied by your operator.
The supported deployment routes API and MCP paths under one public origin.
The settings currently advertise:

```json
{
  "api_origin": "https://app.entitybind.com",
  "mcp_url": "https://app.entitybind.com/mcp",
  "mcp_transport": "streamable-http",
  "protocol_version": "2025-11-25",
  "configuration_required": false,
  "note": "Configured URLs are connection settings, not proof of public deployment."
}
```

A null URL means the operator has not configured it; do not guess a hostname.
Configured URLs are not a claim that a deployment has been externally verified.
Replace the two placeholders below with your URL and issued credential. Client
configuration formats differ; this example is for clients accepting `mcpServers`,
`type`, `url` and `headers`. Prefer the client's credential vault when available.

```json
{
  "mcpServers": {
    "resolvd": {
      "type": "http",
      "url": "https://app.entitybind.com/mcp",
      "headers": {
        "Authorization": "Bearer <your issued credential>"
      }
    }
  }
}
```

Send the bearer credential on every request. Keep it out of prompts, URLs and
committed configuration. API keys and authorized OAuth access tokens use the
same `Authorization: Bearer` header. Your account administrator grants access;
an agent cannot self-assert a verified organization or create its own trial.
The [1,000-credit evaluation](/api/pricing) remains planned behind launch gates.

For a shell connectivity check, set `RESOLVD_MCP_URL` and `RESOLVD_API_KEY` in
your secret environment. These initialization/catalogue requests do not execute
company resolution. An SDK client should perform its normal MCP handshake.

```bash
: "${RESOLVD_MCP_URL:?Set the MCP URL supplied by your operator}"
: "${RESOLVD_API_KEY:?Set your issued bearer credential}"
curl --fail-with-body "$RESOLVD_MCP_URL" \
  -H "Authorization: Bearer $RESOLVD_API_KEY" \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  --data '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-11-25","capabilities":{},"clientInfo":{"name":"company-evaluator","version":"1.0"}}}'

curl --fail-with-body "$RESOLVD_MCP_URL" \
  -H "Authorization: Bearer $RESOLVD_API_KEY" \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -H 'MCP-Protocol-Version: 2025-11-25' \
  --data '{"jsonrpc":"2.0","method":"notifications/initialized"}'

curl --fail-with-body "$RESOLVD_MCP_URL" \
  -H "Authorization: Bearer $RESOLVD_API_KEY" \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -H 'MCP-Protocol-Version: 2025-11-25' \
  --data '{"jsonrpc":"2.0","id":2,"method":"tools/list"}'
```

The transport is stateless: it issues no session credential. Responses may use
JSON or SSE framing; an SSE transport frame does not itself mean a resolution
is producing incremental progress. For durable batch progress, see
[long-running operations](/api/operations).

## Credentials and permission checks

Use the least privilege accepted by the operation. REST publishes
`x-accepted-key-scopes` in [OpenAPI](/api/openapi.json); MCP exposes its current
accepted alternatives in `_meta.resolvd.accepted_scopes` in the catalogue below.
A permission error is not a reason to
retry the same credential. Ask the owner for the appropriate scope.

`read` allows stored tenant/reference reads; `resolve` also allows resolution.
`review` allows review reads and verdicts. `erase` allows REST erasure, and
does not authorize resolution. Administrative and operator keys are separate.
OAuth grants support `read` and `resolve`; review and erasure require API keys.
Existing OAuth grants lacking the resource audience must be reauthorized after
the audience migration; API keys are unaffected.

For OAuth, follow the protected-resource metadata named in the server's bearer
challenge and its authorization-server metadata. Do not derive OAuth endpoints
from a guessed API hostname. Connector registration and owner authorization are
required; dynamic client registration is not promised. Static bearer remains
available to clients that can store an issued key.

The API and MCP listener expose `/.well-known/oauth-protected-resource` and
`/.well-known/oauth-protected-resource{mcp_path}`. Its `resource` is the audience
to include in authorization, token and refresh requests. A token for this resource works across
this deployment's REST and MCP surfaces, subject to scope. The authorization
server publishes `/.well-known/oauth-authorization-server`. The flow requires
authorization code, PKCE `S256`, `state`, and an exact registered redirect URI.
Refresh tokens rotate; OAuth errors use the OAuth string `error` contract.

An operator registers the connector's actual callback URL:

```bash
: "${RESOLVD_CONNECTOR_CALLBACK:?Set the client's exact callback URL}"
uv run python -m resolvd.maintenance register-oauth-client \
  --name 'Company research connector' --redirect-uri "$RESOLVD_CONNECTOR_CALLBACK"
```

A tenant administrator then issues a single-use install ticket. Substitute an
existing tenant ID and keep the returned ticket private:

```bash
: "${RESOLVD_API_ORIGIN:?Set the operator's API origin}"
: "${RESOLVD_ADMIN_KEY:?Set the administrator credential}"
curl --fail-with-body "$RESOLVD_API_ORIGIN/v1/admin/oauth/install-tickets" \
  -H "Authorization: Bearer $RESOLVD_ADMIN_KEY" \
  -H 'Content-Type: application/json' \
  --data '{"tenant_id":"<your existing tenant ID>"}'
```

The owner connects through the client and enters that ticket on the consent page.
Tenant identity comes from the ticket, never an agent-provided tenant parameter.
This requires an owner action; discovery is not automatic account provisioning.

## First authorized calls

Read `get_enrichment_fields` for actual field suppliers, readiness and licences.
Read `get_evaluation` and `get_usage` for grant status and balances. These are
authenticated reads, not claims that every requested field is available.

For resolution, send `tools/call` with a name and arguments matching that tool's
published input schema. Unknown arguments are rejected. This example performs
computation and may consume credits:

```json
{
  "jsonrpc": "2.0",
  "id": 3,
  "method": "tools/call",
  "params": {
    "name": "resolve_company",
    "arguments": {
      "name": "INSTITUTE OF PATENTEES & INVENTORS",
      "country": "GB",
      "registration_number": "00170887",
      "jurisdiction": "GB",
      "depth": "research",
      "idempotency_key": "own-company-evaluation-1"
    }
  }
}
```

`context` accepts a company description or location clue; `address.postal_code`
is the structured postcode field. A registration number needs its issuing
jurisdiction. Country, name or domain alone is not independent identity truth.

## Choose company fields and explain gaps

`get_enrichment_fields` also returns named `field_packs`: `identity`,
`firmographics`, `financials` and `ownership`. Each field describes its value
shape, cardinality, units and dimensions where known; stricter
`source_value_schemas` apply only to the named supplier. Connector support does
not establish that a particular company has a value.

`resolve_company`, `get_entity` and `get_entity_intelligence` accept `fields`
and `field_packs`. These limit returned entity attributes and their provenance.
They do not change identity evidence, source acquisition or charges.
Omitting both preserves the complete authorized view; an explicit empty
selection returns no entity fields. Names are exact, with no wildcard expansion.
At most 64 explicit fields and 8 packs can be requested.

For a company already resolved in your tenant:

```json
{
  "jsonrpc": "2.0", "id": 5, "method": "tools/call",
  "params": {
    "name": "get_entity",
    "arguments": {
      "entity_id": "ent_from_your_own_resolve_result",
      "fields": ["identity.legal_name"],
      "field_packs": ["financials"],
      "include_field_status": true
    }
  }
}
```

Values keep their existing types. Explicit selections include `field_status`;
`include_field_status` requests diagnostics for the complete view, and intelligence
reads default to those diagnostics. Separate status entries explain
`present`, `not_supported`, `not_configured`, `source_unavailable`,
`licence_restricted` and `not_checked`. `not_checked` means this view has no
authorized value or company-specific absence finding; it does not mean a
supplier reported no value. Existing cited values can remain present during
a connector outage. Resale permission remains attached to each fact.

Financial scope remains `unknown` when the source does not establish whether
a figure describes a legal entity or consolidated group. Check reporting
period, currency and measurement basis alongside the amount. A candidate's
`explanation` compares its visible name and domain with the submission; those
comparisons are separate from calibrated `match_confidence` and acceptance.

`get_entity_events` accepts `categories` to filter durable local watch changes.
Advance using `next_cursor` even if `events` is empty: `scanned_count` describes
the scanned page before category filtering. Watches inspect stored facts and
configured local feeds; they do not establish live upstream freshness.

## Company workflows with retained local evidence

These October 7 additions are implemented locally. The repository records
development validation separately from deployment. Production is unchanged on
schema `0029`. Development migration `0030`
requires coordinated API/worker rollout. The running OpenAPI/tool catalogue
states which contracts this deployment actually serves.

| Workflow | Primary REST paths under `/v1` |
|---|---|
| Portfolios | `/portfolios`, `/portfolios/{portfolio_id}` and child routes |
| Financial statements | `GET /entities/{entity_id}/financial-statements` |
| Identifier lifecycle | `GET /entities/{entity_id}/identifier-history` |
| Source disagreement | `POST /entities/{entity_id}/source-comparison` |
| Typed local queries | `GET /reference/search-fields`; `POST /entities/query` |
| Cited relationship paths | `POST /relationships/explain` |
| Data-selection receipts | `POST /data-selections`; `/data-selections/{receipt_id}` |

Equivalent registered MCP tools:

- Portfolios: `manage_portfolio`, `list_portfolios`, `get_portfolio`,
  `manage_portfolio_member`, `get_portfolio_members`, `get_portfolio_events`,
  `enable_portfolio_watches`, `export_portfolio`.
- Statements: `get_financial_statements`, `select_financial_statement`,
  `compare_financial_statements`.
- Identifier lifecycle: `get_identifier_history`.
- Source disagreement: `compare_entity_sources`.
- Typed queries: `get_search_fields`, `query_companies`.
- Relationships: `explain_relationship_paths`.
- Receipts: `capture_data_selection`, `get_data_selection`, `delete_data_selection`.

Use company IDs already owned by the authenticated tenant. Reads use retained
facts/configured authorized local observations, with no provider or model calls.
Remote `read` or `resolve` credentials can read; list edits, receipt creation
and deletion require `resolve`. Optional `capture: true` also requires that
scope. Ordinary reads save no receipt. These workflows make no company-match
decision or source-fact correction.

Discover filter operators with `get_search_fields` or the REST reference route.
All query filters combine with AND. `identity.legal_name` supports `eq`,
`contains`, `in`; `digital.domain` and `location.country` support `eq`, `in`.
`entity_id` supports `eq`, `in`, and `created_at` supports `gte`, `lte`.
Only `created_at`/`entity_id` are sortable, with `asc`/`desc` directions and an
entity-ID tie-break. `UK` aliases to `GB`; date-times need timezones and must be
UTC-representable. Returnable enrichment fields are not automatically searchable.

For `POST /v1/entities/query`, this is the body; MCP `query_companies` takes it
as `payload`:

```json
{
  "filters": [{"field":"location.country","operator":"in","value":["GB","US"]}],
  "sort_by":"created_at","direction":"asc","limit":50,"scan_limit":500
}
```

Bounds are 16 filters, 50 strings per `in`, 100 matches and 1,000 scanned rows
per request. Read `scanned_count` and follow `next_cursor` even through empty
filtered pages, keeping the same filters/sort. Stop when it is null. The cursor
fixes tenant/query and creation-time boundary; corrections/deletions can still
change values. Source-effective `as_of` is not a complete knowledge snapshot.

Financial selection takes a `selection` object with optional sibling `capture`.
The exact wrapper is shared by REST and MCP. This MCP call only reads:

```json
{
  "jsonrpc":"2.0","id":6,"method":"tools/call",
  "params":{
    "name":"select_financial_statement",
    "arguments":{
      "entity_id":"ent_from_your_own_resolve_result",
      "payload":{
        "selection":{
          "relative_period":0,
          "requirements":{"attributes":["financials.revenue"]},
          "preferences":{"currency":"GBP","scope":"consolidated_group"}
        },
        "capture":false
      }
    }
  }
}
```

REST `POST /v1/entities/{entity_id}/financial-selection` takes that `payload`
object as its body. Use exact `statement_id`, exact ISO `period_end`, or integer
`relative_period` 0 to 20. Relative zero means the newest distinct available
reporting end after strict requirements, not a calendar-year offset. Exact and
relative periods cannot be combined. Both criteria objects support `source_id`,
uppercase three-letter `currency`, `scope`, `basis` and exact financial
`attributes`. Scope is `legal_entity`, `consolidated_group` or `unknown`; basis
is `reported`, `derived`, `estimated`, `average`, `point_in_time` or `unknown`.

Requirements never fall back; unavailable strict choices return `selected: null`
and a gap. Preferences choose the fewest mismatches, then latest dates/stable ID.
Read `requested`, `selected`, `actual`, `fallback_reasons` and `gaps` together.
No FX conversion or consolidation inference occurs. The inventory returns
stable IDs, source fingerprints, cited observations and truncation/coverage
gaps. Archives retain admitted values already acquired, not all upstream filings.
POST `/v1/entities/{entity_id}/financial-comparison` with `left_statement_id`
and `right_statement_id`; the response keeps
both cited statements, `inventory_gaps`, `inventory_truncated`, `inventory_note`
and comparison gaps. A changed amount or amendment is not proof of restatement;
explicit source restatement status and an earlier-accession link are required.

Portfolios allow 100 lists per tenant and 1,000 owned companies per list. Create
with `POST /v1/portfolios` and a name/optional stable `portfolio_id`; rename with
PATCH, delete with DELETE. PUT/DELETE `/members/{entity_id}` maintain membership,
with optional `customer_reference`/`role` as list metadata, not identity evidence.
List/member/export pages have at most 100 entries. Watch enabling accepts
`interval_seconds` 300 to 86400, `limit` and `cursor`; follow returned pages.
At most 1,000 entity watches exist per tenant. Re-enabling preserves baselines;
watches are shared across lists. Removing a list/member leaves company data and
shared watches intact. Events expose local observation changes and advancing
cursors/scanned counts, not complete provider history. Export pages contain
current local values/citations and are not a frozen multi-page snapshot.

Identifier history keeps sourced validity/successor evidence and paged durable
local correction events separate. A provider removal is not dissolution and
there is no automatic ID redirect. Source comparison takes `fields`, optional
`include_history` and `capture`; it returns dated observations/survivor policy,
disagreement, bounds, `withheld_by_licence` and `coverage_complete: false`.
Future/pass-through values are excluded. Relationship explanation takes two
owned entity IDs, optional `as_of`, `max_hops` 1 to 10, `limit` 1 to 20 and `capture`.
Edges are cited and dated; share ownership, control and accounting consolidation
stay distinct. Missing paths do not prove absence or shared legal identity.

Set `capture: true` on financial selection, source comparison or relationships,
or POST `/v1/data-selections` with `entity_ids`, optional `fields`, `field_packs`
and `as_of`. Limits are 1,000 receipts per tenant, 100 companies, 5,000 contributing
customer-record references and 2,000,000 UTF-8 JSON bytes per capture. Current
projections refresh authorized local feeds; historical captures use retained
stored facts, without replaying a complete old feed or prior knowledge state.
Pass-through values never enter a saved capture. Receipts fix values, citations,
source/evaluation dates, policy and fallback/gaps. Fingerprints normalize caller
resale flags to false, as stated by `fingerprint_scope`; receipt retrieval derives
current eligibility from captured licences and the current caller plan, preserving
raw values. No supplier licence is acquired or refreshed. Entity, contributing
customer-record and captured intermediary erasure purge the entire receipt.
GET `/v1/data-selections/{receipt_id}` to reopen it; DELETE that path to remove
the capture without changing company facts. Keep its reference to reopen/download it.

For safe response-loss retries, supply a stable client-generated `capture_id`
in the projection request or beside `capture` in a financial/source/relationship
wrapper. This optional ID accepts ASCII `[A-Za-z0-9_-]{1,64}` and becomes
`receipt_id`; otherwise it remains a generated `ds_<uuid>`. Within the same
tenant, the same ID and workflow/input intent return the original immutable
receipt/snapshot with current caller redistribution rights. Changed intent
returns HTTP `409`. Replay does not refresh observations or call remote providers.
Deleting/erasing the receipt keeps that ID reserved; it cannot recreate the
capture. Retry returns `409`, or company access checks may return `404` first.
Use a new ID for a new capture. The ledger retains only tenant ID and SHA-256
token/intent hashes, with no plaintext token, company IDs or evidence. There
are at most 10,000 explicit capture-ID reservations per tenant; the live receipt
limit remains 1,000.

The workspace exposes these operations through authenticated `/portal/api`
routes. No Orbis dataset/access, global lifecycle database, complete upstream
history, CRM writeback or new accuracy claim is implied.


## Interpret outcomes and recover safely

Read `decision`, `match_confidence`, `match_confidence_basis`, `entity_created`,
`clarification`, `candidates` and `usage` together. `unresolved` means the evidence
did not justify a binding; it is not a transport error or proof no company exists.
`entity_created` means new to this tenant, not independently proven identity.
Read the receipt using `get_decision`. `match_records` is stateless and does not
create a resolve receipt. Every enrichment field carries source/licence evidence;
check its reporting period, currency and company/group scope. Income is not revenue.

[Three complete captured responses and receipts](/api/demo) illustrate identity,
ambiguity and weak-evidence abstention. They are dated, seeded, probabilistic
offline examples with enrichment disabled; they do not demonstrate live research
or full enrichment coverage.

MCP can return an HTTP authentication failure before JSON-RPC execution, or a
tool result with `isError: true`. Inspect `structuredContent.error` for the code,
message, correlation ID and retry details when an application error is present.
SDK argument/schema rejection can occur before application execution and contain
only validation content, with no application metadata. Correct the input against
the published schema; do not blindly retry or parse human prose for control flow.
A JSON-RPC response arriving successfully is not proof the tool succeeded.
[The operations guide](/api/operations) explains rate limits and safe retries.

Both `resolve_company` and `match_records` accept `idempotency_key`. Reuse that
key only for a retry of the same operation and unchanged arguments; changed
content conflicts. A transport timeout may follow completed work: preserve the
operation key and inspect state before deciding whether another execution is safe.
Content replay and durable operation retry are separate concepts. Do not assume
a different key makes an unresolved provider commitment safe to execute again.

## Durable batches from an agent

Remote clients can submit a job, retain its ID and return later. This example
can consume credits when the worker executes it:

```json
{
  "jsonrpc": "2.0", "id": 4, "method": "tools/call",
  "params": {
    "name": "submit_batch_job",
    "arguments": {
      "payload": {"records": [
        {"name": "INSTITUTE OF PATENTEES & INVENTORS", "country": "GB",
         "registration_number": "00170887", "jurisdiction": "GB", "depth": "research"}
      ]},
      "idempotency_key": "own-batch-evaluation-1"
    }
  }
}
```

Read `get_batch_job` until a terminal state; honor retry timing. Prefer REST
lifecycle SSE or signed completion webhooks when available. After success,
`get_batch_job_results` pages complete per-record evidence with `offset`, `limit`
and `next_offset`; stop when `next_offset` is null. Its `usage` is the same job
total on every page: do not sum it across pages. The complete batch envelope,
including pair diagnostics, is available at the returned REST `result_path`.
`cancel_batch_job` only cancels queued work. Submission requires a remote issued
credential; operator-local stdio cannot enqueue an unauthenticated job.
See [operations](/api/operations) for states, reconnection and worker setup.


## Company-only reference batches without AI

`POST /v1/company-reference/batch` and MCP `lookup_company_reference_batch`
read the existing licensed Tenhaw company warehouse. They do not invoke company
resolution, models, public registries or metered commercial enrichment APIs.
The workspace Company lookup view also accepts a mapped UTF-8 CSV and exports
the returned profiles. This workflow consumes zero resolution credits.

The request takes `records` (1-100 rows) and `limit` (2-10 candidates per row,
default 5). Each row accepts only `client_ref`, `domain` and optional US/GB
`country`; UK aliases to GB. Unknown input columns are not imported. Example:

```json
{"records":[{"client_ref":"crm-1","domain":"example.com","country":"GB"}],"limit":5}
```

For MCP put this object in `arguments.payload`. Each response row preserves its
one-based `row_number` and original input. Status is `candidates`, `no_candidates`,
`unavailable`, `missing_domain` or `invalid_input`. Unavailable results carry a
fixed reason; they do not imply the company does not exist. Every competing
profile up to the cap is retained, with explicit truncation and licensed,
unverified source snapshot provenance. A profile is not a verified legal match;
snapshot extraction dates do not establish field freshness. No profiles are
automatically selected or written to a tenant entity/decision store.

One batch admission and one ordinary tenant READ admission per distinct valid
normalized domain/country are required before any warehouse lookup. Insufficient
read allowance rejects the batch with rate_limited before source work. Duplicate
rows share one lookup within a request but remain separate output rows. At most
four warehouse queries run concurrently; a 30-second execution budget returns
completed rows and explicitly labels unfinished rows unavailable/request_deadline.
Each individual source read retains its existing five-second maximum budget.


## Local stdio and deployment

Local stdio is an operator-owned process with direct database access. It is not
an anonymous hosted trial. After configuring the database and current migrations:

```bash
uv run python -m resolvd.mcpserver
```

To serve remote clients, configure TLS/reverse proxy, the real public origin,
shared database and Redis before starting the listener:

```bash
RESOLVD_MCP_TRANSPORT=streamable-http RESOLVD_MCP_HOST=0.0.0.0 \
  RESOLVD_MCP_PORT=8081 uv run python -m resolvd.mcpserver
```

`RESOLVD_PUBLIC_BASE_URL` controls the admitted public Host/Origin. A wrong host
can produce `421` even while `/healthz` succeeds. `/readyz` checks database,
schema and index readiness; a green probe does not replace an external MCP
handshake. The API and MCP processes must share tenant/account state and rate
limits. No public deployment is implied by these local commands.

## Generated tool contract (50 tools)

The following descriptions, schemas, annotations and metadata come directly
from registered `tools/list` output. Registration inspection constructs no
application container and invokes no authentication client, tool or provider.
Use the schema rather than a remembered argument list.

### `resolve_company`

Resolve a company record to a golden entity, creating one if it is new.

    Provide a company name and a valid country name or ISO code on every record.
    Website, description/context, postcode and identifiers are optional clues. The pipeline
    normalises the record, finds candidate entities, and decides match /
    no_match / unresolved. `unresolved` is an honest answer, not a failure: the
    evidence was ambiguous and the record was queued for review rather than
    guessed at; it carries `candidate` (the one the cascade came closest on),
    `candidates` (the whole shortlist, ranked best first) and `review_id` so you
    can fetch the review item. An actionable `clarification` names typed answer
    fields and visible candidate clues. Ask the caller for a clue they know,
    then resubmit their corrected input with the same `client_ref` and
    `clarification_of={record_id, decision_id}` from the unresolved result.
    The answer is unverified caller evidence, not a candidate-selection command;
    normal admission, plan limits and billing apply. A separately authorized
    reviewer can use review_submit when more evidence is still needed.
    When an entity is returned, every
    attribute in `record` carries a citation in `provenance` (source_id,
    source_url, licence).

    `decision_id` is the receipt: read it back with get_decision for the
    features, thresholds, cited evidence and a replay of the score.

    `description` aliases `context`; `postcode` aliases `address.postal_code`.
    Conflicting alias/canonical values are rejected. `context` is a bounded,
    unverified company description or location clue;
    authoritative contradictory evidence wins. `address` accepts structured
    line1, line2, city, region, postal_code and country fields. Both use the same
    validation and normalization as REST, including conflicting address clues.

    `entity_created` means the entity is new to this tenant's local store. That
    includes a confidently matched external-registry identity as well as a
    no-candidate mint; `match_confidence_basis` distinguishes match-side
    evidence from the weaker no-candidate/reject-side estimate. A single member
    record is never, by itself, corroboration that the company exists as
    described.

    `depth` is your cost ceiling: "probabilistic" makes no external call at all
    (no LLM, no research agent, no registry lookup) and answers in milliseconds,
    "adjudication" adds the LLM, "research" (the default) adds agentic
    registry/web research. Capping does not lower precision — a capped record
    abstains rather than being decided cheaply, and `depth_capped` tells you
    that is what happened. `enrich=false` turns the registries off at any depth.

    `usage` reports what this call cost and what your plan has left. An
    `unresolved` answer costs 0 credits.

    Discover `fields` and `field_packs` with get_enrichment_fields. Selection
    projects the returned entity and provenance. Opt into quality_target with
    explicit fields or packs for a default 0.95 match-confidence and 0.95 sourced
    completeness requirement. At research depth one bounded paid pass may gather
    missing supported descriptive fields. Unmet targets require review; model
    self-confidence and invented values cannot satisfy them. Selected fields
    carry a field_status;
    `not_checked` does not establish that the company lacks that value.
    

```json
{
  "name": "resolve_company",
  "description": "Resolve a company record to a golden entity, creating one if it is new.\n\n    Provide a company name and a valid country name or ISO code on every record.\n    Website, description/context, postcode and identifiers are optional clues. The pipeline\n    normalises the record, finds candidate entities, and decides match /\n    no_match / unresolved. `unresolved` is an honest answer, not a failure: the\n    evidence was ambiguous and the record was queued for review rather than\n    guessed at; it carries `candidate` (the one the cascade came closest on),\n    `candidates` (the whole shortlist, ranked best first) and `review_id` so you\n    can fetch the review item. An actionable `clarification` names typed answer\n    fields and visible candidate clues. Ask the caller for a clue they know,\n    then resubmit their corrected input with the same `client_ref` and\n    `clarification_of={record_id, decision_id}` from the unresolved result.\n    The answer is unverified caller evidence, not a candidate-selection command;\n    normal admission, plan limits and billing apply. A separately authorized\n    reviewer can use review_submit when more evidence is still needed.\n    When an entity is returned, every\n    attribute in `record` carries a citation in `provenance` (source_id,\n    source_url, licence).\n\n    `decision_id` is the receipt: read it back with get_decision for the\n    features, thresholds, cited evidence and a replay of the score.\n\n    `description` aliases `context`; `postcode` aliases `address.postal_code`.\n    Conflicting alias/canonical values are rejected. `context` is a bounded,\n    unverified company description or location clue;\n    authoritative contradictory evidence wins. `address` accepts structured\n    line1, line2, city, region, postal_code and country fields. Both use the same\n    validation and normalization as REST, including conflicting address clues.\n\n    `entity_created` means the entity is new to this tenant's local store. That\n    includes a confidently matched external-registry identity as well as a\n    no-candidate mint; `match_confidence_basis` distinguishes match-side\n    evidence from the weaker no-candidate/reject-side estimate. A single member\n    record is never, by itself, corroboration that the company exists as\n    described.\n\n    `depth` is your cost ceiling: \"probabilistic\" makes no external call at all\n    (no LLM, no research agent, no registry lookup) and answers in milliseconds,\n    \"adjudication\" adds the LLM, \"research\" (the default) adds agentic\n    registry/web research. Capping does not lower precision — a capped record\n    abstains rather than being decided cheaply, and `depth_capped` tells you\n    that is what happened. `enrich=false` turns the registries off at any depth.\n\n    `usage` reports what this call cost and what your plan has left. An\n    `unresolved` answer costs 0 credits.\n\n    Discover `fields` and `field_packs` with get_enrichment_fields. Selection\n    projects the returned entity and provenance. Opt into quality_target with\n    explicit fields or packs for a default 0.95 match-confidence and 0.95 sourced\n    completeness requirement. At research depth one bounded paid pass may gather\n    missing supported descriptive fields. Unmet targets require review; model\n    self-confidence and invented values cannot satisfy them. Selected fields\n    carry a field_status;\n    `not_checked` does not establish that the company lacks that value.\n    ",
  "inputSchema": {
    "$defs": {
      "AddressRequest": {
        "additionalProperties": false,
        "properties": {
          "line1": {
            "anyOf": [
              {
                "maxLength": 200,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Line1"
          },
          "line2": {
            "anyOf": [
              {
                "maxLength": 200,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Line2"
          },
          "city": {
            "anyOf": [
              {
                "maxLength": 128,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "City"
          },
          "region": {
            "anyOf": [
              {
                "maxLength": 128,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Region"
          },
          "postal_code": {
            "anyOf": [
              {
                "maxLength": 32,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Postal Code"
          },
          "country": {
            "anyOf": [
              {
                "maxLength": 64,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Country"
          }
        },
        "title": "AddressRequest",
        "type": "object"
      },
      "ClarificationOrigin": {
        "additionalProperties": false,
        "description": "A tenant-owned unresolved submission, never an admission instruction.",
        "properties": {
          "record_id": {
            "maxLength": 64,
            "minLength": 1,
            "title": "Record Id",
            "type": "string"
          },
          "decision_id": {
            "anyOf": [
              {
                "maxLength": 64,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Decision Id"
          },
          "job_id": {
            "anyOf": [
              {
                "maxLength": 64,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Job Id"
          },
          "record_index": {
            "anyOf": [
              {
                "maximum": 4999,
                "minimum": 0,
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Record Index"
          }
        },
        "required": [
          "record_id"
        ],
        "title": "ClarificationOrigin",
        "type": "object"
      },
      "QualityTarget": {
        "additionalProperties": false,
        "description": "An opt-in delivery requirement, never a dial for changing confidence.",
        "properties": {
          "minimum_match_confidence": {
            "default": 0.95,
            "maximum": 1.0,
            "minimum": 0.9,
            "title": "Minimum Match Confidence",
            "type": "number"
          },
          "minimum_completeness": {
            "default": 0.95,
            "exclusiveMinimum": 0.0,
            "maximum": 1.0,
            "title": "Minimum Completeness",
            "type": "number"
          }
        },
        "title": "QualityTarget",
        "type": "object"
      },
      "ResolutionDepth": {
        "description": "How far down the cascade a caller is willing to pay to go.\n\nThe cascade costs orders of magnitude more at the bottom than at the top\n(docs/COMMERCIAL-MODEL.md §2), so the depth cap is simultaneously the\ncaller's price ceiling and our cost ceiling. Capping does not lower\nprecision — a capped record abstains instead of being decided cheaply.",
        "enum": [
          "probabilistic",
          "adjudication",
          "research"
        ],
        "title": "ResolutionDepth",
        "type": "string"
      }
    },
    "additionalProperties": false,
    "properties": {
      "name": {
        "maxLength": 500,
        "minLength": 1,
        "title": "Name",
        "type": "string"
      },
      "country": {
        "maxLength": 64,
        "minLength": 1,
        "title": "Country",
        "type": "string"
      },
      "website": {
        "anyOf": [
          {
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Website"
      },
      "domain": {
        "anyOf": [
          {
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Domain"
      },
      "email": {
        "anyOf": [
          {
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Email"
      },
      "phone": {
        "anyOf": [
          {
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Phone"
      },
      "registration_number": {
        "anyOf": [
          {
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Registration Number"
      },
      "jurisdiction": {
        "anyOf": [
          {
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Jurisdiction"
      },
      "lei": {
        "anyOf": [
          {
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Lei"
      },
      "depth": {
        "$ref": "#/$defs/ResolutionDepth",
        "default": "research"
      },
      "enrich": {
        "default": true,
        "title": "Enrich",
        "type": "boolean"
      },
      "address": {
        "anyOf": [
          {
            "$ref": "#/$defs/AddressRequest"
          },
          {
            "type": "null"
          }
        ],
        "default": null
      },
      "context": {
        "anyOf": [
          {
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Context"
      },
      "description": {
        "anyOf": [
          {
            "maxLength": 1000,
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Description"
      },
      "postcode": {
        "anyOf": [
          {
            "maxLength": 32,
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Postcode"
      },
      "trading_names": {
        "anyOf": [
          {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Trading Names"
      },
      "previous_names": {
        "anyOf": [
          {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Previous Names"
      },
      "incorporation_date": {
        "anyOf": [
          {
            "format": "date",
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Incorporation Date"
      },
      "legal_form": {
        "anyOf": [
          {
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Legal Form"
      },
      "vat_number": {
        "anyOf": [
          {
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Vat Number"
      },
      "duns": {
        "anyOf": [
          {
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Duns"
      },
      "isin": {
        "anyOf": [
          {
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Isin"
      },
      "ticker": {
        "anyOf": [
          {
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Ticker"
      },
      "exchange": {
        "anyOf": [
          {
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Exchange"
      },
      "parent_name": {
        "anyOf": [
          {
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Parent Name"
      },
      "extra": {
        "anyOf": [
          {
            "additionalProperties": {
              "type": "string"
            },
            "type": "object"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Extra"
      },
      "client_ref": {
        "anyOf": [
          {
            "maxLength": 200,
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Client Ref"
      },
      "idempotency_key": {
        "anyOf": [
          {
            "maxLength": 200,
            "minLength": 1,
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Idempotency Key"
      },
      "fields": {
        "anyOf": [
          {
            "items": {
              "type": "string"
            },
            "maxItems": 64,
            "type": "array"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Fields"
      },
      "field_packs": {
        "anyOf": [
          {
            "items": {
              "type": "string"
            },
            "maxItems": 8,
            "type": "array"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Field Packs"
      },
      "include_field_status": {
        "default": false,
        "title": "Include Field Status",
        "type": "boolean"
      },
      "quality_target": {
        "anyOf": [
          {
            "$ref": "#/$defs/QualityTarget"
          },
          {
            "type": "null"
          }
        ],
        "default": null
      },
      "clarification_of": {
        "anyOf": [
          {
            "$ref": "#/$defs/ClarificationOrigin"
          },
          {
            "type": "null"
          }
        ],
        "default": null
      }
    },
    "required": [
      "name",
      "country"
    ],
    "title": "resolve_companyArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "resolve_companyDictOutput",
    "type": "object"
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "resolve"
      ]
    }
  }
}
```
### `match_records`

Decide whether two raw company records refer to the same company.

    `left` and `right` are company records. Each accepts name, website, domain,
    email, phone, registration_number, lei, jurisdiction, country, address and
    extra, and each requires a company name and a valid country name or ISO code.
    Country is a retrieval clue, not legal identity proof. Unknown field names are
    rejected rather than ignored. Returns the pairwise decision (match /
    no_match / unresolved), the pipeline stage that decided, the calibrated
    probability when one was computed, and the adjudicator's rationale when an
    LLM verdict was involved. `unresolved` means the evidence is genuinely
    ambiguous — do not treat it as a no_match.

    `depth` controls the entire comparison: probabilistic, adjudication or
    research (default). Choose probabilistic explicitly for a shallow attempt.
    

```json
{
  "name": "match_records",
  "description": "Decide whether two raw company records refer to the same company.\n\n    `left` and `right` are company records. Each accepts name, website, domain,\n    email, phone, registration_number, lei, jurisdiction, country, address and\n    extra, and each requires a company name and a valid country name or ISO code.\n    Country is a retrieval clue, not legal identity proof. Unknown field names are\n    rejected rather than ignored. Returns the pairwise decision (match /\n    no_match / unresolved), the pipeline stage that decided, the calibrated\n    probability when one was computed, and the adjudicator's rationale when an\n    LLM verdict was involved. `unresolved` means the evidence is genuinely\n    ambiguous — do not treat it as a no_match.\n\n    `depth` controls the entire comparison: probabilistic, adjudication or\n    research (default). Choose probabilistic explicitly for a shallow attempt.\n    ",
  "inputSchema": {
    "$defs": {
      "AddressRequest": {
        "additionalProperties": false,
        "properties": {
          "line1": {
            "anyOf": [
              {
                "maxLength": 200,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Line1"
          },
          "line2": {
            "anyOf": [
              {
                "maxLength": 200,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Line2"
          },
          "city": {
            "anyOf": [
              {
                "maxLength": 128,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "City"
          },
          "region": {
            "anyOf": [
              {
                "maxLength": 128,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Region"
          },
          "postal_code": {
            "anyOf": [
              {
                "maxLength": 32,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Postal Code"
          },
          "country": {
            "anyOf": [
              {
                "maxLength": 64,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Country"
          }
        },
        "title": "AddressRequest",
        "type": "object"
      },
      "CompanyComparisonRecord": {
        "additionalProperties": false,
        "properties": {
          "ticker": {
            "anyOf": [
              {
                "maxLength": 16,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Ticker"
          },
          "isin": {
            "anyOf": [
              {
                "maxLength": 12,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Isin"
          },
          "email": {
            "anyOf": [
              {
                "maxLength": 320,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Email"
          },
          "vat_number": {
            "anyOf": [
              {
                "maxLength": 32,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Vat Number"
          },
          "incorporation_date": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Incorporation Date"
          },
          "name": {
            "description": "Company name is required.",
            "maxLength": 500,
            "minLength": 1,
            "title": "Name",
            "type": "string"
          },
          "previous_names": {
            "items": {
              "type": "string"
            },
            "maxItems": 10,
            "title": "Previous Names",
            "type": "array"
          },
          "country": {
            "description": "Required country name or ISO country code; a retrieval clue, not legal identity proof.",
            "maxLength": 64,
            "minLength": 1,
            "title": "Country",
            "type": "string"
          },
          "domain": {
            "anyOf": [
              {
                "maxLength": 253,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Domain"
          },
          "exchange": {
            "anyOf": [
              {
                "maxLength": 64,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Exchange"
          },
          "registration_number": {
            "anyOf": [
              {
                "maxLength": 64,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Registration Number"
          },
          "jurisdiction": {
            "anyOf": [
              {
                "maxLength": 32,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Jurisdiction"
          },
          "context": {
            "anyOf": [
              {
                "maxLength": 1000,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Anything you know about this company in plain language, e.g. 'recruitment company based in the UK, not the pub chain'. Use it when the name alone is ambiguous: it is weighed as evidence alongside the registers, and it is what separates two companies that share a name. It is treated as an unverified claim, so a register that contradicts it wins, and it cannot direct the answer — asserting the verdict or a confidence here has no effect.",
            "title": "Context"
          },
          "parent_name": {
            "anyOf": [
              {
                "maxLength": 500,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Parent Name"
          },
          "legal_form": {
            "anyOf": [
              {
                "maxLength": 64,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Legal Form"
          },
          "description": {
            "anyOf": [
              {
                "maxLength": 1000,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Alias for context: an optional, unverified company description.",
            "title": "Description"
          },
          "trading_names": {
            "items": {
              "type": "string"
            },
            "maxItems": 10,
            "title": "Trading Names",
            "type": "array"
          },
          "address": {
            "anyOf": [
              {
                "$ref": "#/$defs/AddressRequest"
              },
              {
                "type": "null"
              }
            ],
            "default": null
          },
          "website": {
            "anyOf": [
              {
                "maxLength": 500,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Website"
          },
          "extra": {
            "additionalProperties": {
              "type": "string"
            },
            "title": "Extra",
            "type": "object"
          },
          "postcode": {
            "anyOf": [
              {
                "maxLength": 32,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Alias for address.postal_code: an optional postcode or ZIP code.",
            "title": "Postcode"
          },
          "duns": {
            "anyOf": [
              {
                "maxLength": 16,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Duns"
          },
          "lei": {
            "anyOf": [
              {
                "maxLength": 20,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Lei"
          },
          "phone": {
            "anyOf": [
              {
                "maxLength": 64,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Phone"
          }
        },
        "required": [
          "name",
          "country"
        ],
        "title": "CompanyComparisonRecord",
        "type": "object"
      },
      "ResolutionDepth": {
        "description": "How far down the cascade a caller is willing to pay to go.\n\nThe cascade costs orders of magnitude more at the bottom than at the top\n(docs/COMMERCIAL-MODEL.md §2), so the depth cap is simultaneously the\ncaller's price ceiling and our cost ceiling. Capping does not lower\nprecision — a capped record abstains instead of being decided cheaply.",
        "enum": [
          "probabilistic",
          "adjudication",
          "research"
        ],
        "title": "ResolutionDepth",
        "type": "string"
      }
    },
    "additionalProperties": false,
    "properties": {
      "left": {
        "$ref": "#/$defs/CompanyComparisonRecord"
      },
      "right": {
        "$ref": "#/$defs/CompanyComparisonRecord"
      },
      "depth": {
        "$ref": "#/$defs/ResolutionDepth",
        "default": "research"
      },
      "idempotency_key": {
        "anyOf": [
          {
            "maxLength": 200,
            "minLength": 1,
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Idempotency Key"
      }
    },
    "required": [
      "left",
      "right"
    ],
    "title": "match_recordsArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "match_recordsDictOutput",
    "type": "object"
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "resolve"
      ]
    }
  }
}
```
### `get_enrichment_fields`

Discover enrichment fields, supplier readiness and your resale rights, free.

    Check this before requesting market cap, revenue, employees or sectors.
    Available means a configured connector supports the field, not that every
    company has a value. Unsupported requirements have no invented supplier.
    This calls no provider and writes no record or usage-ledger row.
    

```json
{
  "name": "get_enrichment_fields",
  "description": "Discover enrichment fields, supplier readiness and your resale rights, free.\n\n    Check this before requesting market cap, revenue, employees or sectors.\n    Available means a configured connector supports the field, not that every\n    company has a value. Unsupported requirements have no invented supplier.\n    This calls no provider and writes no record or usage-ledger row.\n    ",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {},
    "title": "get_enrichment_fieldsArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "get_enrichment_fieldsDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `get_entity`

Fetch a resolved golden record by entity_id, with per-field provenance.

    Every attribute in `record` is the surviving value chosen by survivorship
    ranking; `provenance` cites where each value came from (source_id,
    source_url, licence). Raises an error if the entity does not exist —
    including one that exists under a different account, which is reported as
    absent rather than as forbidden.
    

```json
{
  "name": "get_entity",
  "description": "Fetch a resolved golden record by entity_id, with per-field provenance.\n\n    Every attribute in `record` is the surviving value chosen by survivorship\n    ranking; `provenance` cites where each value came from (source_id,\n    source_url, licence). Raises an error if the entity does not exist —\n    including one that exists under a different account, which is reported as\n    absent rather than as forbidden.\n    ",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "entity_id": {
        "maxLength": 64,
        "title": "Entity Id",
        "type": "string"
      },
      "fields": {
        "anyOf": [
          {
            "items": {
              "type": "string"
            },
            "maxItems": 64,
            "type": "array"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Fields"
      },
      "field_packs": {
        "anyOf": [
          {
            "items": {
              "type": "string"
            },
            "maxItems": 8,
            "type": "array"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Field Packs"
      },
      "include_field_status": {
        "default": false,
        "title": "Include Field Status",
        "type": "boolean"
      }
    },
    "required": [
      "entity_id"
    ],
    "title": "get_entityArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "get_entityDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `get_crosswalk`

Map one entity across every identifier system it is known by, cited.

    Returns `identifiers` (LEI, company number + its jurisdiction, CIK, every
    ticker with its exchange, DUNS), each with the citation, licence and
    freshness for THAT identifier — not one citation for the whole map. Use this
    when you need to join a company across systems rather than read its full
    record.

    `checked_and_empty` names the systems that produced nothing, and why:
    `not_found` means a wired source supplies that scheme and has no value for
    this company; `not_configured` means no source here supplies it at all.
    Treat those differently — only the first is a statement about the company.

    `ownership` defaults to one hop. Raise `max_hops` to follow exact LEIs or
    authority-scoped company numbers through entities already held by this
    tenant; `as_of` filters source-effective facts and PSC intervals. The walk
    is cycle-safe and refuses ambiguous or name-only edges. Its nodes, edges,
    candidate people, cycles and `not_traversed` ledger make those limits
    explicit, so do not read an empty parent as "no parent exists".
    

```json
{
  "name": "get_crosswalk",
  "description": "Map one entity across every identifier system it is known by, cited.\n\n    Returns `identifiers` (LEI, company number + its jurisdiction, CIK, every\n    ticker with its exchange, DUNS), each with the citation, licence and\n    freshness for THAT identifier — not one citation for the whole map. Use this\n    when you need to join a company across systems rather than read its full\n    record.\n\n    `checked_and_empty` names the systems that produced nothing, and why:\n    `not_found` means a wired source supplies that scheme and has no value for\n    this company; `not_configured` means no source here supplies it at all.\n    Treat those differently — only the first is a statement about the company.\n\n    `ownership` defaults to one hop. Raise `max_hops` to follow exact LEIs or\n    authority-scoped company numbers through entities already held by this\n    tenant; `as_of` filters source-effective facts and PSC intervals. The walk\n    is cycle-safe and refuses ambiguous or name-only edges. Its nodes, edges,\n    candidate people, cycles and `not_traversed` ledger make those limits\n    explicit, so do not read an empty parent as \"no parent exists\".\n    ",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "entity_id": {
        "maxLength": 64,
        "title": "Entity Id",
        "type": "string"
      },
      "max_hops": {
        "default": 1,
        "maximum": 10,
        "minimum": 1,
        "title": "Max Hops",
        "type": "integer"
      },
      "as_of": {
        "anyOf": [
          {
            "format": "date",
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "As Of"
      }
    },
    "required": [
      "entity_id"
    ],
    "title": "get_crosswalkArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "get_crosswalkDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `search_entities`

Find entities already known here that match the given fields, without resolving.

    Returns lightweight candidates ({entity_id, legal_name, domain}) retrieved
    on the same blocking keys the cascade uses and RANKED by the same calibrated
    scorer, likeliest first — so the first row is the likeliest company rather
    than whichever entity id sorted lowest. No probability is returned: a score
    against a triage query is not a match claim, and resolve_company is what
    makes one.

    Nothing is written and nothing is charged. Use this to check whether a
    company is already known before spending a resolve; an empty list means no
    known entity shares an identifier or a name key with your input, which is
    not a claim that the company does not exist.

    Supply at least one of name, domain, registration_number or lei — country
    narrows a query but cannot retrieve on its own.
    

```json
{
  "name": "search_entities",
  "description": "Find entities already known here that match the given fields, without resolving.\n\n    Returns lightweight candidates ({entity_id, legal_name, domain}) retrieved\n    on the same blocking keys the cascade uses and RANKED by the same calibrated\n    scorer, likeliest first — so the first row is the likeliest company rather\n    than whichever entity id sorted lowest. No probability is returned: a score\n    against a triage query is not a match claim, and resolve_company is what\n    makes one.\n\n    Nothing is written and nothing is charged. Use this to check whether a\n    company is already known before spending a resolve; an empty list means no\n    known entity shares an identifier or a name key with your input, which is\n    not a claim that the company does not exist.\n\n    Supply at least one of name, domain, registration_number or lei — country\n    narrows a query but cannot retrieve on its own.\n    ",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "name": {
        "anyOf": [
          {
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Name"
      },
      "domain": {
        "anyOf": [
          {
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Domain"
      },
      "registration_number": {
        "anyOf": [
          {
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Registration Number"
      },
      "lei": {
        "anyOf": [
          {
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Lei"
      },
      "country": {
        "anyOf": [
          {
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Country"
      },
      "limit": {
        "default": 10,
        "maximum": 100,
        "minimum": 1,
        "title": "Limit",
        "type": "integer"
      }
    },
    "title": "search_entitiesArguments",
    "type": "object"
  },
  "outputSchema": {
    "properties": {
      "result": {
        "items": {
          "additionalProperties": true,
          "type": "object"
        },
        "title": "Result",
        "type": "array"
      }
    },
    "required": [
      "result"
    ],
    "title": "search_entitiesOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `review_queue_list`

List review items — resolutions the pipeline abstained on — oldest first.

    Each item carries the submitted record, the candidate entity (if any), the
    ranked shortlist, the decision context and created_at. Paginate with
    limit/offset; submit a verdict for an item with review_submit.

    `status` selects "open" (the default — still awaiting a verdict), "resolved"
    or "all". `stage` separates "the model could not tell" from "the caller
    capped the depth", which are worked differently. `evidence_tier` selects
    the identifier/corroborated/uncorroborated calibration slice. `record_id`
    is the join back to a submission: resolve_company returns the record_id it
    minted, and this finds the queue item that submission produced.
    `min_confidence` drops items scored below the given probability — an item
    that never reached the scorer carries no probability and is dropped by any
    minimum at all.

    `sort="confidence_desc"` works the backlog by value instead of by arrival:
    the items nearest the auto-merge band are the cheapest to settle. Oldest
    first stays the default, so an agent that does not choose does not starve
    the tail of the queue.
    

```json
{
  "name": "review_queue_list",
  "description": "List review items — resolutions the pipeline abstained on — oldest first.\n\n    Each item carries the submitted record, the candidate entity (if any), the\n    ranked shortlist, the decision context and created_at. Paginate with\n    limit/offset; submit a verdict for an item with review_submit.\n\n    `status` selects \"open\" (the default — still awaiting a verdict), \"resolved\"\n    or \"all\". `stage` separates \"the model could not tell\" from \"the caller\n    capped the depth\", which are worked differently. `evidence_tier` selects\n    the identifier/corroborated/uncorroborated calibration slice. `record_id`\n    is the join back to a submission: resolve_company returns the record_id it\n    minted, and this finds the queue item that submission produced.\n    `min_confidence` drops items scored below the given probability — an item\n    that never reached the scorer carries no probability and is dropped by any\n    minimum at all.\n\n    `sort=\"confidence_desc\"` works the backlog by value instead of by arrival:\n    the items nearest the auto-merge band are the cheapest to settle. Oldest\n    first stays the default, so an agent that does not choose does not starve\n    the tail of the queue.\n    ",
  "inputSchema": {
    "$defs": {
      "ComparisonEvidenceTier": {
        "description": "Strength of the evidence that actually agrees for one comparison.\n\nPopulated fields are not evidence of a match.  In particular, a legal name,\ncountry and legal form can all be present on both sides while still naming\ntwo unrelated companies.  This tier is derived from agreement features so\nconfidence calibration cannot pool those name-only decisions with pairs\ncorroborated by an independent attribute.",
        "enum": [
          "identifier",
          "corroborated",
          "uncorroborated"
        ],
        "title": "ComparisonEvidenceTier",
        "type": "string"
      },
      "DecisionStage": {
        "enum": [
          "deterministic",
          "probabilistic",
          "llm_adjudication",
          "agentic_research",
          "human_review"
        ],
        "title": "DecisionStage",
        "type": "string"
      },
      "ReviewSort": {
        "description": "The orders a reviewer may walk the abstention queue in.\n\nA StrEnum so callers above this layer need not import from infrastructure:\nthe API defines its own query enum and hands the store its string value, the\nsame way `ReviewStatus` arrives here already reduced to `resolved: bool`.",
        "enum": [
          "oldest_first",
          "newest_first",
          "confidence_desc",
          "confidence_asc"
        ],
        "title": "ReviewSort",
        "type": "string"
      },
      "ReviewStatus": {
        "description": "Which slice of the queue a listing asks for.",
        "enum": [
          "open",
          "resolved",
          "all"
        ],
        "title": "ReviewStatus",
        "type": "string"
      }
    },
    "additionalProperties": false,
    "properties": {
      "limit": {
        "default": 20,
        "title": "Limit",
        "type": "integer"
      },
      "offset": {
        "default": 0,
        "title": "Offset",
        "type": "integer"
      },
      "status": {
        "$ref": "#/$defs/ReviewStatus",
        "default": "open"
      },
      "stage": {
        "anyOf": [
          {
            "$ref": "#/$defs/DecisionStage"
          },
          {
            "type": "null"
          }
        ],
        "default": null
      },
      "evidence_tier": {
        "anyOf": [
          {
            "$ref": "#/$defs/ComparisonEvidenceTier"
          },
          {
            "type": "null"
          }
        ],
        "default": null
      },
      "record_id": {
        "anyOf": [
          {
            "maxLength": 64,
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Record Id"
      },
      "min_confidence": {
        "anyOf": [
          {
            "maximum": 1.0,
            "minimum": 0.0,
            "type": "number"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Min Confidence"
      },
      "sort": {
        "$ref": "#/$defs/ReviewSort",
        "default": "oldest_first"
      }
    },
    "title": "review_queue_listArguments",
    "type": "object"
  },
  "outputSchema": {
    "properties": {
      "result": {
        "items": {
          "additionalProperties": true,
          "type": "object"
        },
        "title": "Result",
        "type": "array"
      }
    },
    "required": [
      "result"
    ],
    "title": "review_queue_listOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve",
        "review"
      ]
    }
  }
}
```
### `review_queue_get`

Poll one review item: what the abstention was about, and whether it is settled.

    When resolve_company answers `unresolved` it returns the `review_id` of the
    item it queued. This is where that id is redeemed — an agent can track its
    own abstention to a verdict instead of re-resolving the record to find out,
    which would cost a second call and tell it less.

    `resolved` says whether a verdict has been reached, `reviewer_decision` what
    it was, and `applied` whether it changed stored state (`blocked_reason` says
    why it did not). An item belonging to another account reads as not found,
    never as forbidden.
    

```json
{
  "name": "review_queue_get",
  "description": "Poll one review item: what the abstention was about, and whether it is settled.\n\n    When resolve_company answers `unresolved` it returns the `review_id` of the\n    item it queued. This is where that id is redeemed — an agent can track its\n    own abstention to a verdict instead of re-resolving the record to find out,\n    which would cost a second call and tell it less.\n\n    `resolved` says whether a verdict has been reached, `reviewer_decision` what\n    it was, and `applied` whether it changed stored state (`blocked_reason` says\n    why it did not). An item belonging to another account reads as not found,\n    never as forbidden.\n    ",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "review_id": {
        "maxLength": 64,
        "title": "Review Id",
        "type": "string"
      }
    },
    "required": [
      "review_id"
    ],
    "title": "review_queue_getArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "review_queue_getDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve",
        "review"
      ]
    }
  }
}
```
### `get_decision`

Read the receipt for a decision: features, thresholds, evidence and a replay.

    Every resolve returns a `decision_id`; this redeems it. An agent that can
    resolve but cannot pull the receipt for what it just resolved can report a
    conclusion and never the grounds for it — which is the difference between a
    tool a person can sign off on and one they have to take on trust.

    `replay.reproduced` is the part that matters: the scorer is re-run over the
    features stored at decision time and compared with the stored probability.
    It is null for a deterministic identifier match, which never reached the
    scorer, and `replay.pipeline_version_matches` says whether the weights doing
    the reproducing are the ones that decided.

    Pairwise match_records calls are stateless and mint no receipt — there is no
    decision_id to read back. A decision belonging to another account reads as
    not found, never as forbidden.
    

```json
{
  "name": "get_decision",
  "description": "Read the receipt for a decision: features, thresholds, evidence and a replay.\n\n    Every resolve returns a `decision_id`; this redeems it. An agent that can\n    resolve but cannot pull the receipt for what it just resolved can report a\n    conclusion and never the grounds for it — which is the difference between a\n    tool a person can sign off on and one they have to take on trust.\n\n    `replay.reproduced` is the part that matters: the scorer is re-run over the\n    features stored at decision time and compared with the stored probability.\n    It is null for a deterministic identifier match, which never reached the\n    scorer, and `replay.pipeline_version_matches` says whether the weights doing\n    the reproducing are the ones that decided.\n\n    Pairwise match_records calls are stateless and mint no receipt — there is no\n    decision_id to read back. A decision belonging to another account reads as\n    not found, never as forbidden.\n    ",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "decision_id": {
        "maxLength": 64,
        "title": "Decision Id",
        "type": "string"
      }
    },
    "required": [
      "decision_id"
    ],
    "title": "get_decisionArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "get_decisionDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve",
        "review"
      ]
    }
  }
}
```
### `get_usage`

What your account has spent and how much of it was automated, with intervals.

    An agent budgets its own spend, and the `usage` block on a resolve only
    reports one call. This is the period: calls, credits, automation rate,
    abstention rate and the stage and endpoint mix — every rate with its 95%
    Wilson interval and the sample behind it, because an automation rate of 1.0
    over nine calls and one over nine thousand are the same number and not the
    same claim.

    `since` and `until` are dates read as UTC and applied half-open, so two
    adjacent periods sum without double-counting; `until` covers the whole of
    that day. Omitted, the window is your billing period, which is the same span
    the `usage` block on every other tool is summed over.

    `not_measured` names what this cannot tell you and why — precision above all,
    which no view of usage can measure, because review items exist only where the
    pipeline abstained and the automatically merged population carries no labels.
    

```json
{
  "name": "get_usage",
  "description": "What your account has spent and how much of it was automated, with intervals.\n\n    An agent budgets its own spend, and the `usage` block on a resolve only\n    reports one call. This is the period: calls, credits, automation rate,\n    abstention rate and the stage and endpoint mix — every rate with its 95%\n    Wilson interval and the sample behind it, because an automation rate of 1.0\n    over nine calls and one over nine thousand are the same number and not the\n    same claim.\n\n    `since` and `until` are dates read as UTC and applied half-open, so two\n    adjacent periods sum without double-counting; `until` covers the whole of\n    that day. Omitted, the window is your billing period, which is the same span\n    the `usage` block on every other tool is summed over.\n\n    `not_measured` names what this cannot tell you and why — precision above all,\n    which no view of usage can measure, because review items exist only where the\n    pipeline abstained and the automatically merged population carries no labels.\n    ",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "since": {
        "anyOf": [
          {
            "format": "date",
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Since"
      },
      "until": {
        "anyOf": [
          {
            "format": "date",
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Until"
      }
    },
    "title": "get_usageArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "get_usageDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `get_evaluation`

Read lifetime evaluation balances, expiry, pauses and source configuration for free.

    No grant is created and validity does not start. Credits and deep attempts
    are independent lifetime balances shared with REST and every tenant key.
    

```json
{
  "name": "get_evaluation",
  "description": "Read lifetime evaluation balances, expiry, pauses and source configuration for free.\n\n    No grant is created and validity does not start. Credits and deep attempts\n    are independent lifetime balances shared with REST and every tenant key.\n    ",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {},
    "title": "get_evaluationArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "get_evaluationDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `review_submit`

Submit a human/agent verdict for an open review item.

    `decision` must be either "match" or "no_match" — a reviewer settles the
    item, and "unresolved" is the state it is already in. Resolves the item and
    returns its final state; this is how ambiguous cases get settled by a
    reviewer instead of an over-confident automatic merge. An item that already
    carries a verdict is an error, not an overwrite.

    A remote call requires a separately issued `review` credential. Its stored,
    immutable name becomes the accountable reviewer principal; `reviewer_id` is
    optional transition data and, when supplied, must equal that name. The
    credential and the fact that the verdict arrived over MCP are recorded beside
    it automatically. A trusted local stdio operator may still name the analyst
    explicitly because that process is itself the operator boundary.

    `reason` is what settled it, stored on the same audit row.

    `applied` says whether the verdict changed stored state and `blocked_reason`
    says why it did not — the candidate was never stored, has been erased, or
    the merge guard refused the merge.
    

```json
{
  "name": "review_submit",
  "description": "Submit a human/agent verdict for an open review item.\n\n    `decision` must be either \"match\" or \"no_match\" — a reviewer settles the\n    item, and \"unresolved\" is the state it is already in. Resolves the item and\n    returns its final state; this is how ambiguous cases get settled by a\n    reviewer instead of an over-confident automatic merge. An item that already\n    carries a verdict is an error, not an overwrite.\n\n    A remote call requires a separately issued `review` credential. Its stored,\n    immutable name becomes the accountable reviewer principal; `reviewer_id` is\n    optional transition data and, when supplied, must equal that name. The\n    credential and the fact that the verdict arrived over MCP are recorded beside\n    it automatically. A trusted local stdio operator may still name the analyst\n    explicitly because that process is itself the operator boundary.\n\n    `reason` is what settled it, stored on the same audit row.\n\n    `applied` says whether the verdict changed stored state and `blocked_reason`\n    says why it did not — the candidate was never stored, has been erased, or\n    the merge guard refused the merge.\n    ",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "review_id": {
        "maxLength": 64,
        "title": "Review Id",
        "type": "string"
      },
      "decision": {
        "title": "Decision",
        "type": "string"
      },
      "reviewer_id": {
        "anyOf": [
          {
            "maxLength": 255,
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Reviewer Id"
      },
      "reason": {
        "anyOf": [
          {
            "maxLength": 2000,
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Reason"
      }
    },
    "required": [
      "review_id",
      "decision"
    ],
    "title": "review_submitArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "review_submitDictOutput",
    "type": "object"
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "review"
      ]
    }
  }
}
```
### `submit_batch_job`

Queue durable resolution/enrichment with the same batch contract and billing as REST.

    Requires an issued remote resolve credential and a stable idempotency_key.
    Retry with identical input/key to recover the same job; a changed input conflicts.
    Up to the deployment's batch limit (default 500) per job; split 1,000 records
    into two jobs. Inspect get_evaluation/get_usage first for depth and credit limits.
    Returns immediately. Use get_batch_job/results, lifecycle SSE or a registered
    webhook to observe completion. A worker must be running beside the API.
    

```json
{
  "name": "submit_batch_job",
  "description": "Queue durable resolution/enrichment with the same batch contract and billing as REST.\n\n    Requires an issued remote resolve credential and a stable idempotency_key.\n    Retry with identical input/key to recover the same job; a changed input conflicts.\n    Up to the deployment's batch limit (default 500) per job; split 1,000 records\n    into two jobs. Inspect get_evaluation/get_usage first for depth and credit limits.\n    Returns immediately. Use get_batch_job/results, lifecycle SSE or a registered\n    webhook to observe completion. A worker must be running beside the API.\n    ",
  "inputSchema": {
    "$defs": {
      "AddressRequest": {
        "additionalProperties": false,
        "properties": {
          "line1": {
            "anyOf": [
              {
                "maxLength": 200,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Line1"
          },
          "line2": {
            "anyOf": [
              {
                "maxLength": 200,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Line2"
          },
          "city": {
            "anyOf": [
              {
                "maxLength": 128,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "City"
          },
          "region": {
            "anyOf": [
              {
                "maxLength": 128,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Region"
          },
          "postal_code": {
            "anyOf": [
              {
                "maxLength": 32,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Postal Code"
          },
          "country": {
            "anyOf": [
              {
                "maxLength": 64,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Country"
          }
        },
        "title": "AddressRequest",
        "type": "object"
      },
      "BatchRequest": {
        "additionalProperties": false,
        "properties": {
          "records": {
            "items": {
              "$ref": "#/$defs/ResolveRequest"
            },
            "maxItems": 5000,
            "minItems": 1,
            "title": "Records",
            "type": "array"
          }
        },
        "required": [
          "records"
        ],
        "title": "BatchRequest",
        "type": "object"
      },
      "ClarificationOrigin": {
        "additionalProperties": false,
        "description": "A tenant-owned unresolved submission, never an admission instruction.",
        "properties": {
          "record_id": {
            "maxLength": 64,
            "minLength": 1,
            "title": "Record Id",
            "type": "string"
          },
          "decision_id": {
            "anyOf": [
              {
                "maxLength": 64,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Decision Id"
          },
          "job_id": {
            "anyOf": [
              {
                "maxLength": 64,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Job Id"
          },
          "record_index": {
            "anyOf": [
              {
                "maximum": 4999,
                "minimum": 0,
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Record Index"
          }
        },
        "required": [
          "record_id"
        ],
        "title": "ClarificationOrigin",
        "type": "object"
      },
      "QualityTarget": {
        "additionalProperties": false,
        "description": "An opt-in delivery requirement, never a dial for changing confidence.",
        "properties": {
          "minimum_match_confidence": {
            "default": 0.95,
            "maximum": 1.0,
            "minimum": 0.9,
            "title": "Minimum Match Confidence",
            "type": "number"
          },
          "minimum_completeness": {
            "default": 0.95,
            "exclusiveMinimum": 0.0,
            "maximum": 1.0,
            "title": "Minimum Completeness",
            "type": "number"
          }
        },
        "title": "QualityTarget",
        "type": "object"
      },
      "ResolutionDepth": {
        "description": "How far down the cascade a caller is willing to pay to go.\n\nThe cascade costs orders of magnitude more at the bottom than at the top\n(docs/COMMERCIAL-MODEL.md §2), so the depth cap is simultaneously the\ncaller's price ceiling and our cost ceiling. Capping does not lower\nprecision — a capped record abstains instead of being decided cheaply.",
        "enum": [
          "probabilistic",
          "adjudication",
          "research"
        ],
        "title": "ResolutionDepth",
        "type": "string"
      },
      "ResolveRequest": {
        "additionalProperties": false,
        "description": "Mirrors CompanyRecord's caller-suppliable fields with hard input caps.\n\nWHAT MAY BE ADDED HERE, and where it goes. Every field below that describes\nthe company is mapped onto `CompanyRecord` and is therefore inside the\ncontent fingerprint — see that class for the rule and why both halves of it\nmatter. Fields that describe the CALL rather than the company (`depth`,\n`enrich`, `client_ref`) stay on this request and never reach the record.\n\nThe identifiers are two classes and the distinction decides where in the\ncascade they may ever be used:\n\n* STRONG IDENTIFIER — one value, one company, issued by a body that\n  guarantees it. `lei`, `registration_number` + `jurisdiction`, `duns`, and\n  `ticker` + `exchange`. These are the only kind that could justify a\n  deterministic short-circuit.\n* CORROBORATING SIGNAL — narrows the field, settles nothing alone.\n  `vat_number`, `isin`, `incorporation_date`, `legal_form`, `trading_names`,\n  `previous_names`, `parent_name`, `context`, `extra`.\n\nTwo of these look strong and are not, which is the whole reason the\ndistinction is written down rather than inferred from the field name:\n\n* `vat_number` — group VAT registration is MANY companies to ONE number, so\n  equal VAT numbers do not imply one company. It may corroborate a merge and\n  may never carry one.\n* `isin` — identifies a security, not an issuer. One company has many, and a\n  financing subsidiary issues under itself. It becomes strong only once\n  GLEIF's ISIN->LEI mapping resolves it to an LEI, which already is.\n\nREJECTED, with the reason, because a wide schema nobody populates is worse\nthan a narrow one:\n\n* `employee_count` — self-reported, ranges disagree between every source\n  that publishes one, and it moves monthly. Enrichment already carries\n  `financials.employees_range`; a caller-supplied count would contradict it\n  routinely and the contradiction would mean nothing.\n* `industry_code` — not comparable without also negotiating a scheme (SIC\n  62020 and NAICS 541512 are the same activity and share no characters), and\n  every member of a group files the same code, so it separates nothing.\n  `context` carries the same intent — \"IT consultancy, not the pub of\n  the same name\" — with no scheme to agree on.\n* `company_status` — a register-derived attribute we already fetch\n  (`registration.status` in `llm.prompts.ENRICHMENT_ATTRIBUTES`). A caller\n  asserting it adds no information and can only contradict the register,\n  which is the one source that outranks them.",
        "properties": {
          "name": {
            "description": "Company name is required.",
            "maxLength": 500,
            "minLength": 1,
            "title": "Name",
            "type": "string"
          },
          "website": {
            "anyOf": [
              {
                "maxLength": 500,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Website"
          },
          "domain": {
            "anyOf": [
              {
                "maxLength": 253,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Domain"
          },
          "email": {
            "anyOf": [
              {
                "maxLength": 320,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Email"
          },
          "phone": {
            "anyOf": [
              {
                "maxLength": 64,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Phone"
          },
          "registration_number": {
            "anyOf": [
              {
                "maxLength": 64,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Registration Number"
          },
          "jurisdiction": {
            "anyOf": [
              {
                "maxLength": 32,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Jurisdiction"
          },
          "lei": {
            "anyOf": [
              {
                "maxLength": 20,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Lei"
          },
          "address": {
            "anyOf": [
              {
                "$ref": "#/$defs/AddressRequest"
              },
              {
                "type": "null"
              }
            ],
            "default": null
          },
          "country": {
            "description": "Required country name or ISO country code; a retrieval clue, not legal identity proof.",
            "maxLength": 64,
            "minLength": 1,
            "title": "Country",
            "type": "string"
          },
          "trading_names": {
            "items": {
              "type": "string"
            },
            "maxItems": 10,
            "title": "Trading Names",
            "type": "array"
          },
          "previous_names": {
            "items": {
              "type": "string"
            },
            "maxItems": 10,
            "title": "Previous Names",
            "type": "array"
          },
          "incorporation_date": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Incorporation Date"
          },
          "legal_form": {
            "anyOf": [
              {
                "maxLength": 64,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Legal Form"
          },
          "vat_number": {
            "anyOf": [
              {
                "maxLength": 32,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Vat Number"
          },
          "duns": {
            "anyOf": [
              {
                "maxLength": 16,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Duns"
          },
          "isin": {
            "anyOf": [
              {
                "maxLength": 12,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Isin"
          },
          "ticker": {
            "anyOf": [
              {
                "maxLength": 16,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Ticker"
          },
          "exchange": {
            "anyOf": [
              {
                "maxLength": 64,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Exchange"
          },
          "parent_name": {
            "anyOf": [
              {
                "maxLength": 500,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Parent Name"
          },
          "context": {
            "anyOf": [
              {
                "maxLength": 1000,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Anything you know about this company in plain language, e.g. 'recruitment company based in the UK, not the pub chain'. Use it when the name alone is ambiguous: it is weighed as evidence alongside the registers, and it is what separates two companies that share a name. It is treated as an unverified claim, so a register that contradicts it wins, and it cannot direct the answer — asserting the verdict or a confidence here has no effect.",
            "title": "Context"
          },
          "description": {
            "anyOf": [
              {
                "maxLength": 1000,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Alias for context: an optional, unverified company description.",
            "title": "Description"
          },
          "postcode": {
            "anyOf": [
              {
                "maxLength": 32,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Alias for address.postal_code: an optional postcode or ZIP code.",
            "title": "Postcode"
          },
          "clarification_of": {
            "anyOf": [
              {
                "$ref": "#/$defs/ClarificationOrigin"
              },
              {
                "type": "null"
              }
            ],
            "default": null
          },
          "extra": {
            "additionalProperties": {
              "type": "string"
            },
            "title": "Extra",
            "type": "object"
          },
          "depth": {
            "$ref": "#/$defs/ResolutionDepth",
            "default": "research"
          },
          "enrich": {
            "default": true,
            "title": "Enrich",
            "type": "boolean"
          },
          "client_ref": {
            "anyOf": [
              {
                "maxLength": 200,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Client Ref"
          },
          "fields": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "maxItems": 64,
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Returned entity attributes; discover them at /v1/reference/enrichment-fields. Projection only: does not change identity evidence, acquisition, confidence or billing.",
            "title": "Fields"
          },
          "field_packs": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "maxItems": 8,
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Named groups of returned attributes; combined with fields. Missing values have explicit status rather than invented data.",
            "title": "Field Packs"
          },
          "include_field_status": {
            "default": false,
            "title": "Include Field Status",
            "type": "boolean"
          },
          "quality_target": {
            "anyOf": [
              {
                "$ref": "#/$defs/QualityTarget"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Optional delivery target, defaulting to 0.95 calibrated match confidence and 0.95 sourced completeness. Requires explicit nonempty fields or field_packs. At research depth, missing supported descriptive fields may trigger one bounded paid research pass. Unmet targets are reported for review; values are never invented."
          }
        },
        "required": [
          "name",
          "country"
        ],
        "title": "ResolveRequest",
        "type": "object"
      }
    },
    "additionalProperties": false,
    "properties": {
      "payload": {
        "$ref": "#/$defs/BatchRequest"
      },
      "idempotency_key": {
        "maxLength": 200,
        "minLength": 1,
        "title": "Idempotency Key",
        "type": "string"
      }
    },
    "required": [
      "payload",
      "idempotency_key"
    ],
    "title": "submit_batch_jobArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "submit_batch_jobDictOutput",
    "type": "object"
  },
  "annotations": {
    "destructiveHint": false,
    "idempotentHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "resolve"
      ]
    }
  }
}
```
### `get_batch_job`

Read this tenant's durable job state. Terminal failures are never silently replayed.

    Prefer completion webhooks or GET /v1/batch-jobs/{job_id}/events (SSE) over polling.
    reconciliation_required means execution was interrupted and may have incurred cost.
    

```json
{
  "name": "get_batch_job",
  "description": "Read this tenant's durable job state. Terminal failures are never silently replayed.\n\n    Prefer completion webhooks or GET /v1/batch-jobs/{job_id}/events (SSE) over polling.\n    reconciliation_required means execution was interrupted and may have incurred cost.\n    ",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "job_id": {
        "maxLength": 64,
        "title": "Job Id",
        "type": "string"
      }
    },
    "required": [
      "job_id"
    ],
    "title": "get_batch_jobArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "get_batch_jobDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `get_batch_job_results`

Read a bounded page of completed enriched outcomes without rerunning or charging.

    Returns full per-record evidence/fields in outcomes, total and next_offset.
    The complete batch envelope, including pair-level diagnostics, is available
    at GET /v1/batch-jobs/{job_id}/result. Pending/failed/erased jobs return a typed error.
    

```json
{
  "name": "get_batch_job_results",
  "description": "Read a bounded page of completed enriched outcomes without rerunning or charging.\n\n    Returns full per-record evidence/fields in outcomes, total and next_offset.\n    The complete batch envelope, including pair-level diagnostics, is available\n    at GET /v1/batch-jobs/{job_id}/result. Pending/failed/erased jobs return a typed error.\n    ",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "job_id": {
        "maxLength": 64,
        "title": "Job Id",
        "type": "string"
      },
      "offset": {
        "default": 0,
        "minimum": 0,
        "title": "Offset",
        "type": "integer"
      },
      "limit": {
        "default": 20,
        "maximum": 50,
        "minimum": 1,
        "title": "Limit",
        "type": "integer"
      }
    },
    "required": [
      "job_id"
    ],
    "title": "get_batch_job_resultsArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "get_batch_job_resultsDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `cancel_batch_job`

Cancel a queued job; repeated cancellation is safe. Running work returns a conflict.

```json
{
  "name": "cancel_batch_job",
  "description": "Cancel a queued job; repeated cancellation is safe. Running work returns a conflict.",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "job_id": {
        "maxLength": 64,
        "title": "Job Id",
        "type": "string"
      }
    },
    "required": [
      "job_id"
    ],
    "title": "cancel_batch_jobArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "cancel_batch_jobDictOutput",
    "type": "object"
  },
  "annotations": {
    "destructiveHint": false,
    "idempotentHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "resolve"
      ]
    }
  }
}
```
### `get_search_fields`

Discover exact local filter/operators/sorting; returnable fields are separate.

```json
{
  "name": "get_search_fields",
  "description": "Discover exact local filter/operators/sorting; returnable fields are separate.",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {},
    "title": "get_search_fieldsArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "get_search_fieldsDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `query_companies`

Query stored owned companies using typed filters and a resumable bounded scan.

    Empty filtered pages can have next_cursor. Creation boundaries are frozen;
    corrections can change values. No external search or supplier call is made.
    

```json
{
  "name": "query_companies",
  "description": "Query stored owned companies using typed filters and a resumable bounded scan.\n\n    Empty filtered pages can have next_cursor. Creation boundaries are frozen;\n    corrections can change values. No external search or supplier call is made.\n    ",
  "inputSchema": {
    "$defs": {
      "CompanyFilter": {
        "additionalProperties": false,
        "properties": {
          "field": {
            "enum": [
              "identity.legal_name",
              "digital.domain",
              "location.country",
              "entity_id",
              "created_at"
            ],
            "title": "Field",
            "type": "string"
          },
          "operator": {
            "enum": [
              "eq",
              "contains",
              "in",
              "gte",
              "lte"
            ],
            "title": "Operator",
            "type": "string"
          },
          "value": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "items": {
                  "type": "string"
                },
                "type": "array"
              }
            ],
            "title": "Value"
          }
        },
        "required": [
          "field",
          "operator",
          "value"
        ],
        "title": "CompanyFilter",
        "type": "object"
      },
      "CompanySearch": {
        "additionalProperties": false,
        "properties": {
          "filters": {
            "items": {
              "$ref": "#/$defs/CompanyFilter"
            },
            "maxItems": 16,
            "title": "Filters",
            "type": "array"
          },
          "sort_by": {
            "default": "created_at",
            "enum": [
              "created_at",
              "entity_id"
            ],
            "title": "Sort By",
            "type": "string"
          },
          "direction": {
            "default": "asc",
            "enum": [
              "asc",
              "desc"
            ],
            "title": "Direction",
            "type": "string"
          },
          "as_of": {
            "anyOf": [
              {
                "format": "date-time",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "As Of"
          },
          "cursor": {
            "anyOf": [
              {
                "maxLength": 2048,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Cursor"
          },
          "limit": {
            "default": 50,
            "maximum": 100,
            "minimum": 1,
            "title": "Limit",
            "type": "integer"
          },
          "scan_limit": {
            "default": 500,
            "maximum": 1000,
            "minimum": 1,
            "title": "Scan Limit",
            "type": "integer"
          }
        },
        "title": "CompanySearch",
        "type": "object"
      }
    },
    "additionalProperties": false,
    "properties": {
      "payload": {
        "$ref": "#/$defs/CompanySearch"
      }
    },
    "required": [
      "payload"
    ],
    "title": "query_companiesArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "query_companiesDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `manage_portfolio`

Create, rename or delete an owned saved company set; company facts stay intact.

    Creation with a supplied ID is idempotent. Deletion removes this portfolio's
    memberships; shared company watches remain enabled.
    

```json
{
  "name": "manage_portfolio",
  "description": "Create, rename or delete an owned saved company set; company facts stay intact.\n\n    Creation with a supplied ID is idempotent. Deletion removes this portfolio's\n    memberships; shared company watches remain enabled.\n    ",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "action": {
        "enum": [
          "create",
          "rename",
          "delete"
        ],
        "title": "Action",
        "type": "string"
      },
      "portfolio_id": {
        "anyOf": [
          {
            "maxLength": 64,
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Portfolio Id"
      },
      "name": {
        "anyOf": [
          {
            "maxLength": 120,
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Name"
      }
    },
    "required": [
      "action"
    ],
    "title": "manage_portfolioArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "manage_portfolioDictOutput",
    "type": "object"
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "resolve"
      ]
    }
  }
}
```
### `list_portfolios`

List this tenant's named portfolios with a scoped continuation cursor.

```json
{
  "name": "list_portfolios",
  "description": "List this tenant's named portfolios with a scoped continuation cursor.",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "cursor": {
        "anyOf": [
          {
            "maxLength": 2048,
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Cursor"
      },
      "limit": {
        "default": 50,
        "maximum": 100,
        "minimum": 1,
        "title": "Limit",
        "type": "integer"
      }
    },
    "title": "list_portfoliosArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "list_portfoliosDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `get_portfolio`

Read an owned portfolio's name and membership count.

```json
{
  "name": "get_portfolio",
  "description": "Read an owned portfolio's name and membership count.",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "portfolio_id": {
        "maxLength": 64,
        "title": "Portfolio Id",
        "type": "string"
      }
    },
    "required": [
      "portfolio_id"
    ],
    "title": "get_portfolioArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "get_portfolioDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `manage_portfolio_member`

Idempotently add/update an owned company membership or remove it.

    Customer references and roles are portfolio metadata, never identity evidence.
    

```json
{
  "name": "manage_portfolio_member",
  "description": "Idempotently add/update an owned company membership or remove it.\n\n    Customer references and roles are portfolio metadata, never identity evidence.\n    ",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "portfolio_id": {
        "maxLength": 64,
        "title": "Portfolio Id",
        "type": "string"
      },
      "entity_id": {
        "maxLength": 64,
        "title": "Entity Id",
        "type": "string"
      },
      "action": {
        "enum": [
          "add",
          "remove"
        ],
        "title": "Action",
        "type": "string"
      },
      "customer_reference": {
        "anyOf": [
          {
            "maxLength": 256,
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Customer Reference"
      },
      "role": {
        "anyOf": [
          {
            "maxLength": 64,
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Role"
      }
    },
    "required": [
      "portfolio_id",
      "entity_id",
      "action"
    ],
    "title": "manage_portfolio_memberArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "manage_portfolio_memberDictOutput",
    "type": "object"
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "resolve"
      ]
    }
  }
}
```
### `get_portfolio_members`

Read a bounded membership page with customer references and roles.

```json
{
  "name": "get_portfolio_members",
  "description": "Read a bounded membership page with customer references and roles.",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "portfolio_id": {
        "maxLength": 64,
        "title": "Portfolio Id",
        "type": "string"
      },
      "cursor": {
        "anyOf": [
          {
            "maxLength": 2048,
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Cursor"
      },
      "limit": {
        "default": 100,
        "maximum": 100,
        "minimum": 1,
        "title": "Limit",
        "type": "integer"
      }
    },
    "required": [
      "portfolio_id"
    ],
    "title": "get_portfolio_membersArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "get_portfolio_membersDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `get_portfolio_events`

Read consolidated local changes; filtered pages advance over scanned events.

```json
{
  "name": "get_portfolio_events",
  "description": "Read consolidated local changes; filtered pages advance over scanned events.",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "portfolio_id": {
        "maxLength": 64,
        "title": "Portfolio Id",
        "type": "string"
      },
      "after_id": {
        "default": 0,
        "maximum": 2147483647,
        "minimum": 0,
        "title": "After Id",
        "type": "integer"
      },
      "limit": {
        "default": 100,
        "maximum": 100,
        "minimum": 1,
        "title": "Limit",
        "type": "integer"
      },
      "categories": {
        "anyOf": [
          {
            "items": {
              "type": "string"
            },
            "maxItems": 16,
            "type": "array"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Categories"
      }
    },
    "required": [
      "portfolio_id"
    ],
    "title": "get_portfolio_eventsArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "get_portfolio_eventsDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `enable_portfolio_watches`

Enable bounded local watches for members; follow next_cursor for another page.

    This compares stored/configured local observations and makes no provider calls.
    

```json
{
  "name": "enable_portfolio_watches",
  "description": "Enable bounded local watches for members; follow next_cursor for another page.\n\n    This compares stored/configured local observations and makes no provider calls.\n    ",
  "inputSchema": {
    "$defs": {
      "WatchPageRequest": {
        "additionalProperties": false,
        "properties": {
          "cursor": {
            "anyOf": [
              {
                "maxLength": 2048,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Cursor"
          },
          "limit": {
            "default": 100,
            "maximum": 100,
            "minimum": 1,
            "title": "Limit",
            "type": "integer"
          },
          "interval_seconds": {
            "default": 86400,
            "maximum": 86400,
            "minimum": 300,
            "title": "Interval Seconds",
            "type": "integer"
          }
        },
        "title": "WatchPageRequest",
        "type": "object"
      }
    },
    "additionalProperties": false,
    "properties": {
      "portfolio_id": {
        "maxLength": 64,
        "title": "Portfolio Id",
        "type": "string"
      },
      "payload": {
        "$ref": "#/$defs/WatchPageRequest"
      }
    },
    "required": [
      "portfolio_id",
      "payload"
    ],
    "title": "enable_portfolio_watchesArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "enable_portfolio_watchesDictOutput",
    "type": "object"
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "resolve"
      ]
    }
  }
}
```
### `export_portfolio`

Export a bounded page of current local values and unchanged provenance/rights.

    Pages are not a frozen snapshot; use capture_data_selection for selected members.
    

```json
{
  "name": "export_portfolio",
  "description": "Export a bounded page of current local values and unchanged provenance/rights.\n\n    Pages are not a frozen snapshot; use capture_data_selection for selected members.\n    ",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "portfolio_id": {
        "maxLength": 64,
        "title": "Portfolio Id",
        "type": "string"
      },
      "cursor": {
        "anyOf": [
          {
            "maxLength": 2048,
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Cursor"
      },
      "limit": {
        "default": 100,
        "maximum": 100,
        "minimum": 1,
        "title": "Limit",
        "type": "integer"
      }
    },
    "required": [
      "portfolio_id"
    ],
    "title": "export_portfolioArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "export_portfolioDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `get_financial_statements`

Read available retained filing/observation history with cited metrics and gaps.

```json
{
  "name": "get_financial_statements",
  "description": "Read available retained filing/observation history with cited metrics and gaps.",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "entity_id": {
        "maxLength": 64,
        "title": "Entity Id",
        "type": "string"
      },
      "limit": {
        "default": 100,
        "maximum": 100,
        "minimum": 1,
        "title": "Limit",
        "type": "integer"
      }
    },
    "required": [
      "entity_id"
    ],
    "title": "get_financial_statementsArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "get_financial_statementsDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `select_financial_statement`

Select an exact filing or period with strict criteria and disclosed preference fallback.

    capture=true saves a reproducible receipt and requires a resolve credential.
    Default selection only reads; missing financial observations remain gaps.
    

```json
{
  "name": "select_financial_statement",
  "description": "Select an exact filing or period with strict criteria and disclosed preference fallback.\n\n    capture=true saves a reproducible receipt and requires a resolve credential.\n    Default selection only reads; missing financial observations remain gaps.\n    ",
  "inputSchema": {
    "$defs": {
      "FinancialSelection": {
        "additionalProperties": false,
        "properties": {
          "statement_id": {
            "anyOf": [
              {
                "maxLength": 128,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Statement Id"
          },
          "period_end": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Period End"
          },
          "relative_period": {
            "anyOf": [
              {
                "maximum": 20,
                "minimum": 0,
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Relative Period"
          },
          "requirements": {
            "$ref": "#/$defs/StatementCriteria"
          },
          "preferences": {
            "$ref": "#/$defs/StatementCriteria"
          }
        },
        "title": "FinancialSelection",
        "type": "object"
      },
      "FinancialSelectionRequest": {
        "additionalProperties": false,
        "properties": {
          "selection": {
            "$ref": "#/$defs/FinancialSelection"
          },
          "capture": {
            "default": false,
            "title": "Capture",
            "type": "boolean"
          },
          "capture_id": {
            "anyOf": [
              {
                "maxLength": 64,
                "minLength": 1,
                "pattern": "^[A-Za-z0-9_-]+$",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Capture Id"
          }
        },
        "title": "FinancialSelectionRequest",
        "type": "object"
      },
      "StatementCriteria": {
        "additionalProperties": false,
        "properties": {
          "source_id": {
            "anyOf": [
              {
                "maxLength": 128,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Source Id"
          },
          "currency": {
            "anyOf": [
              {
                "pattern": "^[A-Z]{3}$",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Currency"
          },
          "scope": {
            "anyOf": [
              {
                "enum": [
                  "legal_entity",
                  "consolidated_group",
                  "unknown"
                ],
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Scope"
          },
          "basis": {
            "anyOf": [
              {
                "enum": [
                  "reported",
                  "derived",
                  "estimated",
                  "average",
                  "point_in_time",
                  "unknown"
                ],
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Basis"
          },
          "attributes": {
            "default": [],
            "items": {
              "maxLength": 128,
              "minLength": 12,
              "pattern": "^financials\\.[a-z][a-z0-9_]*$",
              "type": "string"
            },
            "maxItems": 64,
            "title": "Attributes",
            "type": "array"
          }
        },
        "title": "StatementCriteria",
        "type": "object"
      }
    },
    "additionalProperties": false,
    "properties": {
      "entity_id": {
        "maxLength": 64,
        "title": "Entity Id",
        "type": "string"
      },
      "payload": {
        "$ref": "#/$defs/FinancialSelectionRequest"
      }
    },
    "required": [
      "entity_id",
      "payload"
    ],
    "title": "select_financial_statementArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "select_financial_statementDictOutput",
    "type": "object"
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `compare_financial_statements`

Compare cited comparable statement versions; restatement requires explicit evidence.

```json
{
  "name": "compare_financial_statements",
  "description": "Compare cited comparable statement versions; restatement requires explicit evidence.",
  "inputSchema": {
    "$defs": {
      "FinancialComparisonRequest": {
        "additionalProperties": false,
        "properties": {
          "left_statement_id": {
            "maxLength": 128,
            "minLength": 1,
            "title": "Left Statement Id",
            "type": "string"
          },
          "right_statement_id": {
            "maxLength": 128,
            "minLength": 1,
            "title": "Right Statement Id",
            "type": "string"
          }
        },
        "required": [
          "left_statement_id",
          "right_statement_id"
        ],
        "title": "FinancialComparisonRequest",
        "type": "object"
      }
    },
    "additionalProperties": false,
    "properties": {
      "entity_id": {
        "maxLength": 64,
        "title": "Entity Id",
        "type": "string"
      },
      "payload": {
        "$ref": "#/$defs/FinancialComparisonRequest"
      }
    },
    "required": [
      "entity_id",
      "payload"
    ],
    "title": "compare_financial_statementsArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "compare_financial_statementsDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `get_identifier_history`

Read sourced identifier lifecycle and reviewed local corrections, including own retired IDs.

    Provider removal is not dissolution; successor evidence is not an automatic redirect.
    

```json
{
  "name": "get_identifier_history",
  "description": "Read sourced identifier lifecycle and reviewed local corrections, including own retired IDs.\n\n    Provider removal is not dissolution; successor evidence is not an automatic redirect.\n    ",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "entity_id": {
        "maxLength": 64,
        "title": "Entity Id",
        "type": "string"
      },
      "as_of": {
        "anyOf": [
          {
            "format": "date",
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "As Of"
      },
      "after_id": {
        "default": 0,
        "maximum": 2147483647,
        "minimum": 0,
        "title": "After Id",
        "type": "integer"
      },
      "limit": {
        "default": 100,
        "maximum": 100,
        "minimum": 1,
        "title": "Limit",
        "type": "integer"
      }
    },
    "required": [
      "entity_id"
    ],
    "title": "get_identifier_historyArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "get_identifier_historyDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `compare_entity_sources`

Read dated source disagreement and survivor policy without changing company facts.

    Stored customer/registry/authorized incumbent observations only. capture=true
    stores the compared evidence and requires a resolve credential.
    

```json
{
  "name": "compare_entity_sources",
  "description": "Read dated source disagreement and survivor policy without changing company facts.\n\n    Stored customer/registry/authorized incumbent observations only. capture=true\n    stores the compared evidence and requires a resolve credential.\n    ",
  "inputSchema": {
    "$defs": {
      "SourceComparisonRequest": {
        "additionalProperties": false,
        "properties": {
          "fields": {
            "items": {
              "type": "string"
            },
            "maxItems": 64,
            "minItems": 1,
            "title": "Fields",
            "type": "array"
          },
          "include_history": {
            "default": false,
            "title": "Include History",
            "type": "boolean"
          },
          "capture": {
            "default": false,
            "title": "Capture",
            "type": "boolean"
          },
          "capture_id": {
            "anyOf": [
              {
                "maxLength": 64,
                "minLength": 1,
                "pattern": "^[A-Za-z0-9_-]+$",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Capture Id"
          }
        },
        "required": [
          "fields"
        ],
        "title": "SourceComparisonRequest",
        "type": "object"
      }
    },
    "additionalProperties": false,
    "properties": {
      "entity_id": {
        "maxLength": 64,
        "title": "Entity Id",
        "type": "string"
      },
      "payload": {
        "$ref": "#/$defs/SourceComparisonRequest"
      }
    },
    "required": [
      "entity_id",
      "payload"
    ],
    "title": "compare_entity_sourcesArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "compare_entity_sourcesDictOutput",
    "type": "object"
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `explain_relationship_paths`

Explain bounded cited paths between owned companies, including shared ancestors.

    Control, share ownership and consolidation remain distinct from identity.
    No path found does not prove no relationship. capture=true saves a receipt.
    

```json
{
  "name": "explain_relationship_paths",
  "description": "Explain bounded cited paths between owned companies, including shared ancestors.\n\n    Control, share ownership and consolidation remain distinct from identity.\n    No path found does not prove no relationship. capture=true saves a receipt.\n    ",
  "inputSchema": {
    "$defs": {
      "RelationshipRequest": {
        "additionalProperties": false,
        "properties": {
          "left_entity_id": {
            "maxLength": 64,
            "minLength": 1,
            "title": "Left Entity Id",
            "type": "string"
          },
          "right_entity_id": {
            "maxLength": 64,
            "minLength": 1,
            "title": "Right Entity Id",
            "type": "string"
          },
          "max_hops": {
            "default": 3,
            "maximum": 10,
            "minimum": 1,
            "title": "Max Hops",
            "type": "integer"
          },
          "limit": {
            "default": 10,
            "maximum": 20,
            "minimum": 1,
            "title": "Limit",
            "type": "integer"
          },
          "as_of": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "As Of"
          },
          "capture": {
            "default": false,
            "title": "Capture",
            "type": "boolean"
          },
          "capture_id": {
            "anyOf": [
              {
                "maxLength": 64,
                "minLength": 1,
                "pattern": "^[A-Za-z0-9_-]+$",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Capture Id"
          }
        },
        "required": [
          "left_entity_id",
          "right_entity_id"
        ],
        "title": "RelationshipRequest",
        "type": "object"
      }
    },
    "additionalProperties": false,
    "properties": {
      "payload": {
        "$ref": "#/$defs/RelationshipRequest"
      }
    },
    "required": [
      "payload"
    ],
    "title": "explain_relationship_pathsArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "explain_relationship_pathsDictOutput",
    "type": "object"
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `capture_data_selection`

Save bounded dated company projections with source/selection policy and fingerprint.

    Creates a tenant-bound receipt; it changes no company facts. Entity/source-record
    erasure purges captures, and retrieval recomputes current redistribution rights.
    

```json
{
  "name": "capture_data_selection",
  "description": "Save bounded dated company projections with source/selection policy and fingerprint.\n\n    Creates a tenant-bound receipt; it changes no company facts. Entity/source-record\n    erasure purges captures, and retrieval recomputes current redistribution rights.\n    ",
  "inputSchema": {
    "$defs": {
      "CaptureRequest": {
        "additionalProperties": false,
        "properties": {
          "fields": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "maxItems": 64,
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Fields"
          },
          "field_packs": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "maxItems": 8,
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Field Packs"
          },
          "entity_ids": {
            "items": {
              "type": "string"
            },
            "maxItems": 100,
            "minItems": 1,
            "title": "Entity Ids",
            "type": "array"
          },
          "as_of": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "As Of"
          },
          "capture_id": {
            "anyOf": [
              {
                "maxLength": 64,
                "minLength": 1,
                "pattern": "^[A-Za-z0-9_-]+$",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Capture Id"
          }
        },
        "required": [
          "entity_ids"
        ],
        "title": "CaptureRequest",
        "type": "object"
      }
    },
    "additionalProperties": false,
    "properties": {
      "payload": {
        "$ref": "#/$defs/CaptureRequest"
      }
    },
    "required": [
      "payload"
    ],
    "title": "capture_data_selectionArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "capture_data_selectionDictOutput",
    "type": "object"
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "resolve"
      ]
    }
  }
}
```
### `get_data_selection`

Read an owned immutable data-selection capture under current caller resale rights.

```json
{
  "name": "get_data_selection",
  "description": "Read an owned immutable data-selection capture under current caller resale rights.",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "receipt_id": {
        "maxLength": 64,
        "title": "Receipt Id",
        "type": "string"
      }
    },
    "required": [
      "receipt_id"
    ],
    "title": "get_data_selectionArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "get_data_selectionDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `delete_data_selection`

Remove an owned saved capture; company records and decisions remain intact.

```json
{
  "name": "delete_data_selection",
  "description": "Remove an owned saved capture; company records and decisions remain intact.",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "receipt_id": {
        "maxLength": 64,
        "title": "Receipt Id",
        "type": "string"
      }
    },
    "required": [
      "receipt_id"
    ],
    "title": "delete_data_selectionArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "delete_data_selectionDictOutput",
    "type": "object"
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "resolve"
      ]
    }
  }
}
```
### `get_entity_identity`

Read portable registry anchors, dated aliases and distinct address roles, free.

    Public IDs are stable per official registry identifier, not a single global
    canonical entity ID. They confer no cross-tenant access. Subsidiaries stay
    separate. Missing or conflicting identity evidence is explicit.
    

```json
{
  "name": "get_entity_identity",
  "description": "Read portable registry anchors, dated aliases and distinct address roles, free.\n\n    Public IDs are stable per official registry identifier, not a single global\n    canonical entity ID. They confer no cross-tenant access. Subsidiaries stay\n    separate. Missing or conflicting identity evidence is explicit.\n    ",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "entity_id": {
        "maxLength": 64,
        "title": "Entity Id",
        "type": "string"
      },
      "as_of": {
        "anyOf": [
          {
            "format": "date",
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "As Of"
      }
    },
    "required": [
      "entity_id"
    ],
    "title": "get_entity_identityArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "get_entity_identityDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `get_ownership_plan`

Read bounded next steps for missing ownership evidence without executing them.

    Free local traversal. Accounting consolidation does not establish beneficial
    ownership. Suggested resolve calls are separate, normally metered operations.
    

```json
{
  "name": "get_ownership_plan",
  "description": "Read bounded next steps for missing ownership evidence without executing them.\n\n    Free local traversal. Accounting consolidation does not establish beneficial\n    ownership. Suggested resolve calls are separate, normally metered operations.\n    ",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "entity_id": {
        "maxLength": 64,
        "title": "Entity Id",
        "type": "string"
      },
      "max_hops": {
        "default": 3,
        "maximum": 10,
        "minimum": 1,
        "title": "Max Hops",
        "type": "integer"
      },
      "as_of": {
        "anyOf": [
          {
            "format": "date",
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "As Of"
      }
    },
    "required": [
      "entity_id"
    ],
    "title": "get_ownership_planArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "get_ownership_planDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `get_ultimate_owner`

Read organizational owner reports and bounded local controller evidence, free.

    Explicit source-reported ultimate owners remain separate from accounting
    consolidation and observed graph endpoints. Global coverage is unknown;
    no AI, provider lookup, resolution or persistence is performed.
    

```json
{
  "name": "get_ultimate_owner",
  "description": "Read organizational owner reports and bounded local controller evidence, free.\n\n    Explicit source-reported ultimate owners remain separate from accounting\n    consolidation and observed graph endpoints. Global coverage is unknown;\n    no AI, provider lookup, resolution or persistence is performed.\n    ",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "entity_id": {
        "maxLength": 64,
        "minLength": 1,
        "title": "Entity Id",
        "type": "string"
      },
      "max_hops": {
        "default": 3,
        "maximum": 10,
        "minimum": 1,
        "title": "Max Hops",
        "type": "integer"
      },
      "as_of": {
        "anyOf": [
          {
            "format": "date",
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "As Of"
      }
    },
    "required": [
      "entity_id"
    ],
    "title": "get_ultimate_ownerArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "get_ultimate_ownerDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `get_market_cap_history`

Read five years of cited monthly month-end market caps, without provider spend.

    Returns 60 completed calendar-month buckets by default. Actual valuation,
    publication and capture dates stay separate. Missing, stale, conflicting
    or unverified closes have no selected value. Values are not forward-filled,
    converted between currencies or summed across incomplete share classes.
    

```json
{
  "name": "get_market_cap_history",
  "description": "Read five years of cited monthly month-end market caps, without provider spend.\n\n    Returns 60 completed calendar-month buckets by default. Actual valuation,\n    publication and capture dates stay separate. Missing, stale, conflicting\n    or unverified closes have no selected value. Values are not forward-filled,\n    converted between currencies or summed across incomplete share classes.\n    ",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "entity_id": {
        "maxLength": 64,
        "minLength": 1,
        "title": "Entity Id",
        "type": "string"
      },
      "months": {
        "default": 60,
        "maximum": 60,
        "minimum": 1,
        "title": "Months",
        "type": "integer"
      },
      "as_of": {
        "anyOf": [
          {
            "format": "date",
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "As Of"
      },
      "scope": {
        "default": "issuer",
        "enum": [
          "issuer",
          "share_class"
        ],
        "title": "Scope",
        "type": "string"
      },
      "currency": {
        "anyOf": [
          {
            "pattern": "^[A-Z]{3}$",
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Currency"
      },
      "share_class": {
        "anyOf": [
          {
            "maxLength": 2000,
            "minLength": 1,
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Share Class"
      }
    },
    "required": [
      "entity_id"
    ],
    "title": "get_market_cap_historyArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "get_market_cap_historyDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `get_entity_intelligence`

Read current sourced intelligence, including refreshed authorized local feeds.

    Free, no provider calls or writes. Field coverage, dates, scope, methodology,
    uncertainty and licence remain explicit. Missing observations are never zero.
    Discover exact fields and named packs with get_enrichment_fields; selection
    filters the entity's values and citations together. field_status explains
    unreturned fields without changing their value type.
    

```json
{
  "name": "get_entity_intelligence",
  "description": "Read current sourced intelligence, including refreshed authorized local feeds.\n\n    Free, no provider calls or writes. Field coverage, dates, scope, methodology,\n    uncertainty and licence remain explicit. Missing observations are never zero.\n    Discover exact fields and named packs with get_enrichment_fields; selection\n    filters the entity's values and citations together. field_status explains\n    unreturned fields without changing their value type.\n    ",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "entity_id": {
        "maxLength": 64,
        "title": "Entity Id",
        "type": "string"
      },
      "fields": {
        "anyOf": [
          {
            "items": {
              "type": "string"
            },
            "maxItems": 64,
            "type": "array"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Fields"
      },
      "field_packs": {
        "anyOf": [
          {
            "items": {
              "type": "string"
            },
            "maxItems": 8,
            "type": "array"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Field Packs"
      },
      "include_field_status": {
        "default": true,
        "title": "Include Field Status",
        "type": "boolean"
      }
    },
    "required": [
      "entity_id"
    ],
    "title": "get_entity_intelligenceArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "get_entity_intelligenceDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `search_company_reference`

Find licensed, unverified company records by exact website hostname.

    No resolution credits or model calls. Returns every competing record up to
    the cap, with truncation and snapshot provenance. A domain hit is not legal
    validation. Do not merge candidates or claim registry confidence from it.
    Use resolve_company separately with the original customer input for an
    identity decision; a source outage is not evidence a company does not exist.
    

```json
{
  "name": "search_company_reference",
  "description": "Find licensed, unverified company records by exact website hostname.\n\n    No resolution credits or model calls. Returns every competing record up to\n    the cap, with truncation and snapshot provenance. A domain hit is not legal\n    validation. Do not merge candidates or claim registry confidence from it.\n    Use resolve_company separately with the original customer input for an\n    identity decision; a source outage is not evidence a company does not exist.\n    ",
  "inputSchema": {
    "$defs": {
      "CompanyReferenceQuery": {
        "additionalProperties": false,
        "properties": {
          "domain": {
            "maxLength": 253,
            "minLength": 1,
            "title": "Domain",
            "type": "string"
          },
          "country": {
            "anyOf": [
              {
                "enum": [
                  "US",
                  "GB"
                ],
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Country"
          },
          "limit": {
            "default": 20,
            "maximum": 50,
            "minimum": 1,
            "title": "Limit",
            "type": "integer"
          }
        },
        "required": [
          "domain"
        ],
        "title": "CompanyReferenceQuery",
        "type": "object"
      }
    },
    "additionalProperties": false,
    "properties": {
      "payload": {
        "$ref": "#/$defs/CompanyReferenceQuery"
      }
    },
    "required": [
      "payload"
    ],
    "title": "search_company_referenceArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "search_company_referenceDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `lookup_company_reference_batch`

Read licensed company profiles for up to 100 domains without AI or resolution.

    Zero resolution credits; read/resolve scope. Every original row is returned,
    including missing/invalid domains, outages and competing candidates. Company
    profiles remain unverified and dated to the source snapshot, not today.
    This uses only the existing company-only warehouse reader, writes no tenant
    entities/decisions, and cannot call models, public registries or paid vendors.
    One batch admission plus normal read admission for each distinct valid
    normalized domain/country; duplicates share a lookup within this request.
    At most four lookups run concurrently under a 30-second execution budget.
    

```json
{
  "name": "lookup_company_reference_batch",
  "description": "Read licensed company profiles for up to 100 domains without AI or resolution.\n\n    Zero resolution credits; read/resolve scope. Every original row is returned,\n    including missing/invalid domains, outages and competing candidates. Company\n    profiles remain unverified and dated to the source snapshot, not today.\n    This uses only the existing company-only warehouse reader, writes no tenant\n    entities/decisions, and cannot call models, public registries or paid vendors.\n    One batch admission plus normal read admission for each distinct valid\n    normalized domain/country; duplicates share a lookup within this request.\n    At most four lookups run concurrently under a 30-second execution budget.\n    ",
  "inputSchema": {
    "$defs": {
      "CompanyReferenceBatchItem": {
        "additionalProperties": false,
        "properties": {
          "client_ref": {
            "anyOf": [
              {
                "maxLength": 256,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Client Ref"
          },
          "domain": {
            "anyOf": [
              {
                "maxLength": 2048,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Domain"
          },
          "country": {
            "anyOf": [
              {
                "maxLength": 32,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Country"
          }
        },
        "title": "CompanyReferenceBatchItem",
        "type": "object"
      },
      "CompanyReferenceBatchRequest": {
        "additionalProperties": false,
        "properties": {
          "records": {
            "items": {
              "$ref": "#/$defs/CompanyReferenceBatchItem"
            },
            "maxItems": 100,
            "minItems": 1,
            "title": "Records",
            "type": "array"
          },
          "limit": {
            "default": 5,
            "maximum": 10,
            "minimum": 2,
            "title": "Limit",
            "type": "integer"
          }
        },
        "required": [
          "records"
        ],
        "title": "CompanyReferenceBatchRequest",
        "type": "object"
      }
    },
    "additionalProperties": false,
    "properties": {
      "payload": {
        "$ref": "#/$defs/CompanyReferenceBatchRequest"
      }
    },
    "required": [
      "payload"
    ],
    "title": "lookup_company_reference_batchArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "lookup_company_reference_batchDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `screen_entity`

Screen an organization/person against installed sanctions, PEP and media evidence.

    Free, read-only, tenant-scoped snapshots; query/results are not retained.
    Missing or stale lists yield not_screened. Potential matches require review;
    similarity is not match probability, a risk score or a compliance decision.
    

```json
{
  "name": "screen_entity",
  "description": "Screen an organization/person against installed sanctions, PEP and media evidence.\n\n    Free, read-only, tenant-scoped snapshots; query/results are not retained.\n    Missing or stale lists yield not_screened. Potential matches require review;\n    similarity is not match probability, a risk score or a compliance decision.\n    ",
  "inputSchema": {
    "$defs": {
      "ScreeningIdentifier": {
        "additionalProperties": false,
        "description": "Scheme and issuing jurisdiction are part of an identifier's meaning.",
        "properties": {
          "scheme": {
            "maxLength": 500,
            "minLength": 1,
            "title": "Scheme",
            "type": "string"
          },
          "value": {
            "maxLength": 500,
            "minLength": 1,
            "title": "Value",
            "type": "string"
          },
          "country": {
            "anyOf": [
              {
                "maxLength": 500,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Country"
          }
        },
        "required": [
          "scheme",
          "value"
        ],
        "title": "ScreeningIdentifier",
        "type": "object"
      },
      "ScreeningRequest": {
        "additionalProperties": false,
        "properties": {
          "name": {
            "maxLength": 500,
            "minLength": 1,
            "title": "Name",
            "type": "string"
          },
          "subject_type": {
            "default": "organization",
            "enum": [
              "organization",
              "person",
              "vessel",
              "aircraft",
              "unknown"
            ],
            "title": "Subject Type",
            "type": "string"
          },
          "aliases": {
            "items": {
              "maxLength": 500,
              "minLength": 1,
              "type": "string"
            },
            "maxItems": 20,
            "title": "Aliases",
            "type": "array"
          },
          "identifiers": {
            "items": {
              "$ref": "#/$defs/ScreeningIdentifier"
            },
            "maxItems": 20,
            "title": "Identifiers",
            "type": "array"
          },
          "country": {
            "anyOf": [
              {
                "maxLength": 500,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Country"
          },
          "date_of_birth": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Date Of Birth"
          },
          "kinds": {
            "items": {
              "enum": [
                "sanctions",
                "pep",
                "adverse_media"
              ],
              "type": "string"
            },
            "maxItems": 3,
            "minItems": 1,
            "title": "Kinds",
            "type": "array"
          },
          "sources": {
            "anyOf": [
              {
                "additionalProperties": {
                  "items": {
                    "pattern": "^[a-z0-9][a-z0-9_-]{0,79}$",
                    "type": "string"
                  },
                  "type": "array"
                },
                "propertyNames": {
                  "enum": [
                    "sanctions",
                    "pep",
                    "adverse_media"
                  ]
                },
                "type": "object"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Sources"
          },
          "min_name_similarity": {
            "default": 0.82,
            "maximum": 1.0,
            "minimum": 0.65,
            "title": "Min Name Similarity",
            "type": "number"
          },
          "max_matches_per_kind": {
            "default": 20,
            "maximum": 100,
            "minimum": 1,
            "title": "Max Matches Per Kind",
            "type": "integer"
          }
        },
        "required": [
          "name"
        ],
        "title": "ScreeningRequest",
        "type": "object"
      }
    },
    "additionalProperties": false,
    "properties": {
      "payload": {
        "$ref": "#/$defs/ScreeningRequest"
      }
    },
    "required": [
      "payload"
    ],
    "title": "screen_entityArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "screen_entityDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `get_screening_coverage`

Inspect installed screening sources, versions, freshness and gaps, free.

```json
{
  "name": "get_screening_coverage",
  "description": "Inspect installed screening sources, versions, freshness and gaps, free.",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {},
    "title": "get_screening_coverageArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "get_screening_coverageDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `watch_entity`

Enable/disable a free watch of stored and local-feed intelligence; retries are safe.

    Requires resolve permission. Worker checks daily by default; no research or
    network enrichment. Register entity.intelligence_changed via REST /v1/webhooks
    to receive signed notifications. Changes between checks can be coalesced.
    

```json
{
  "name": "watch_entity",
  "description": "Enable/disable a free watch of stored and local-feed intelligence; retries are safe.\n\n    Requires resolve permission. Worker checks daily by default; no research or\n    network enrichment. Register entity.intelligence_changed via REST /v1/webhooks\n    to receive signed notifications. Changes between checks can be coalesced.\n    ",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "entity_id": {
        "maxLength": 64,
        "title": "Entity Id",
        "type": "string"
      },
      "enabled": {
        "default": true,
        "title": "Enabled",
        "type": "boolean"
      },
      "interval_seconds": {
        "default": 86400,
        "maximum": 86400,
        "minimum": 300,
        "title": "Interval Seconds",
        "type": "integer"
      }
    },
    "required": [
      "entity_id"
    ],
    "title": "watch_entityArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "watch_entityDictOutput",
    "type": "object"
  },
  "annotations": {
    "destructiveHint": false,
    "idempotentHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "resolve"
      ]
    }
  }
}
```
### `get_entity_watch`

Read an entity's watch and last successful comparison time, free.

```json
{
  "name": "get_entity_watch",
  "description": "Read an entity's watch and last successful comparison time, free.",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "entity_id": {
        "maxLength": 64,
        "title": "Entity Id",
        "type": "string"
      }
    },
    "required": [
      "entity_id"
    ],
    "title": "get_entity_watchArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "get_entity_watchDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `get_run_room`

Read your Run Room stages, accounting status and retained evidence metadata, free.

    Use the run_id returned by resolution to investigate progress or failures.
    This bounded manifest never submits work, invokes a provider or includes
    source document bytes. Private artifact attachments are downloaded through
    the authenticated REST routes or workspace. Pending metadata may be visible
    before record publication; artifacts require a terminal, owned record.
    

```json
{
  "name": "get_run_room",
  "description": "Read your Run Room stages, accounting status and retained evidence metadata, free.\n\n    Use the run_id returned by resolution to investigate progress or failures.\n    This bounded manifest never submits work, invokes a provider or includes\n    source document bytes. Private artifact attachments are downloaded through\n    the authenticated REST routes or workspace. Pending metadata may be visible\n    before record publication; artifacts require a terminal, owned record.\n    ",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "run_id": {
        "maxLength": 64,
        "minLength": 1,
        "pattern": "^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$",
        "title": "Run Id",
        "type": "string"
      }
    },
    "required": [
      "run_id"
    ],
    "title": "get_run_roomArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "get_run_roomDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `get_entity_events`

Read durable watch changes after a cursor, free; values stay in intelligence.

    Prefer signed completion notifications to polling. Use next_cursor to resume.
    Categories filter the scanned page; always advance next_cursor, even when
    events is empty. scanned_count reports scanned events, not filtered results.
    Watches compare local observations; they are not an upstream event log.
    

```json
{
  "name": "get_entity_events",
  "description": "Read durable watch changes after a cursor, free; values stay in intelligence.\n\n    Prefer signed completion notifications to polling. Use next_cursor to resume.\n    Categories filter the scanned page; always advance next_cursor, even when\n    events is empty. scanned_count reports scanned events, not filtered results.\n    Watches compare local observations; they are not an upstream event log.\n    ",
  "inputSchema": {
    "$defs": {
      "EntityChangeCategory": {
        "enum": [
          "identity",
          "identifiers",
          "legal_status",
          "location",
          "contact",
          "financials",
          "ownership",
          "firmographics",
          "other"
        ],
        "title": "EntityChangeCategory",
        "type": "string"
      }
    },
    "additionalProperties": false,
    "properties": {
      "entity_id": {
        "maxLength": 64,
        "title": "Entity Id",
        "type": "string"
      },
      "after_id": {
        "default": 0,
        "maximum": 2147483647,
        "minimum": 0,
        "title": "After Id",
        "type": "integer"
      },
      "limit": {
        "default": 100,
        "maximum": 100,
        "minimum": 1,
        "title": "Limit",
        "type": "integer"
      },
      "categories": {
        "anyOf": [
          {
            "items": {
              "$ref": "#/$defs/EntityChangeCategory"
            },
            "maxItems": 9,
            "type": "array"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Categories"
      }
    },
    "required": [
      "entity_id"
    ],
    "title": "get_entity_eventsArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "get_entity_eventsDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `get_resolution_outcomes`

Read retained batch cohorts, credits, run duration, field fill and human feedback.

    Free. UTC dates include their final day and default to the last 30 days.
    Counts are original submitted records; synchronous calls only enter spend.
    Acceptance, sampled field fill and customer opinions are not verified accuracy.
    

```json
{
  "name": "get_resolution_outcomes",
  "description": "Read retained batch cohorts, credits, run duration, field fill and human feedback.\n\n    Free. UTC dates include their final day and default to the last 30 days.\n    Counts are original submitted records; synchronous calls only enter spend.\n    Acceptance, sampled field fill and customer opinions are not verified accuracy.\n    ",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "since": {
        "anyOf": [
          {
            "format": "date",
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Since"
      },
      "until": {
        "anyOf": [
          {
            "format": "date",
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Until"
      }
    },
    "title": "get_resolution_outcomesArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "get_resolution_outcomesDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": true
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "read",
        "resolve"
      ]
    }
  }
}
```
### `submit_resolution_feedback`

Record a customer's independent judgement about a named binding, free.

    Ask the customer for their evidence; do not label your own predictions as
    independent truth. Wrong reports reject this receipt's target and need no
    guessed replacement. Identity is unchanged. Retry the same stable key;
    explicit corrections append a revision using supersedes_label_id.
    

```json
{
  "name": "submit_resolution_feedback",
  "description": "Record a customer's independent judgement about a named binding, free.\n\n    Ask the customer for their evidence; do not label your own predictions as\n    independent truth. Wrong reports reject this receipt's target and need no\n    guessed replacement. Identity is unchanged. Retry the same stable key;\n    explicit corrections append a revision using supersedes_label_id.\n    ",
  "inputSchema": {
    "additionalProperties": false,
    "properties": {
      "decision_id": {
        "maxLength": 64,
        "minLength": 1,
        "title": "Decision Id",
        "type": "string"
      },
      "report": {
        "enum": [
          "correct",
          "wrong"
        ],
        "title": "Report",
        "type": "string"
      },
      "rationale": {
        "maxLength": 4000,
        "minLength": 1,
        "title": "Rationale",
        "type": "string"
      },
      "idempotency_key": {
        "maxLength": 200,
        "minLength": 1,
        "title": "Idempotency Key",
        "type": "string"
      },
      "source_uri": {
        "anyOf": [
          {
            "maxLength": 2000,
            "minLength": 1,
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Source Uri"
      },
      "supersedes_label_id": {
        "anyOf": [
          {
            "maxLength": 64,
            "minLength": 1,
            "type": "string"
          },
          {
            "type": "null"
          }
        ],
        "default": null,
        "title": "Supersedes Label Id"
      }
    },
    "required": [
      "decision_id",
      "report",
      "rationale",
      "idempotency_key"
    ],
    "title": "submit_resolution_feedbackArguments",
    "type": "object"
  },
  "outputSchema": {
    "additionalProperties": true,
    "title": "submit_resolution_feedbackDictOutput",
    "type": "object"
  },
  "annotations": {
    "readOnlyHint": false,
    "destructiveHint": false,
    "idempotentHint": true,
    "openWorldHint": false
  },
  "_meta": {
    "resolvd": {
      "accepted_scopes": [
        "resolve"
      ]
    }
  }
}
```

Generated OpenAPI JSON:
{
  "components": {
    "responses": {
      "ApiError": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ErrorResponse"
            }
          }
        },
        "description": "A typed API error. The HTTP status and error code identify the failure."
      },
      "ForbiddenError": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ErrorResponse"
            }
          }
        },
        "description": "The credential is valid but its key scope is not accepted by this operation."
      },
      "PayloadTooLargeError": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ErrorResponse"
            }
          }
        },
        "description": "The request body exceeds the deployment limit."
      },
      "RateLimitError": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ErrorResponse"
            }
          }
        },
        "description": "The request was rate limited.",
        "headers": {
          "RateLimit-Limit": {
            "schema": {
              "minimum": 0,
              "type": "integer"
            }
          },
          "RateLimit-Remaining": {
            "schema": {
              "minimum": 0,
              "type": "integer"
            }
          },
          "RateLimit-Reset": {
            "schema": {
              "minimum": 0,
              "type": "integer"
            }
          },
          "Retry-After": {
            "schema": {
              "minimum": 0,
              "type": "integer"
            }
          }
        }
      },
      "UnauthorizedError": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ErrorResponse"
            }
          }
        },
        "description": "Missing or invalid bearer credential.",
        "headers": {
          "WWW-Authenticate": {
            "schema": {
              "type": "string"
            }
          }
        }
      },
      "ValidationError": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ErrorResponse"
            }
          }
        },
        "description": "Request validation failed."
      }
    },
    "schemas": {
      "AbstentionOutcomesView": {
        "description": "What became of the abstentions queued in this period.\n\nThe price of abstention, and deliberately not an accuracy measurement: this\npopulation is exactly the records the pipeline REFUSED to decide, so a\nreviewer's verdict describes what a human could do with a case we would not\nautomate and is silent about every record we did.",
        "properties": {
          "human_decidable_rate": {
            "$ref": "#/components/schemas/IntervalView"
          },
          "pending": {
            "title": "Pending",
            "type": "integer"
          },
          "queued": {
            "title": "Queued",
            "type": "integer"
          },
          "settled_match": {
            "title": "Settled Match",
            "type": "integer"
          },
          "settled_no_match": {
            "title": "Settled No Match",
            "type": "integer"
          },
          "settled_unresolved": {
            "title": "Settled Unresolved",
            "type": "integer"
          }
        },
        "required": [
          "queued",
          "pending",
          "settled_match",
          "settled_no_match",
          "settled_unresolved",
          "human_decidable_rate"
        ],
        "title": "AbstentionOutcomesView",
        "type": "object"
      },
      "AccountingUltimateParentView": {
        "properties": {
          "provenance": {
            "$ref": "#/components/schemas/ProvenanceView"
          },
          "relationship_basis": {
            "const": "accounting_consolidation",
            "default": "accounting_consolidation",
            "title": "Relationship Basis",
            "type": "string"
          },
          "scheme": {
            "const": "lei",
            "default": "lei",
            "title": "Scheme",
            "type": "string"
          },
          "valid_from": {
            "format": "date",
            "title": "Valid From",
            "type": "string"
          },
          "valid_to": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Valid To"
          },
          "value": {
            "title": "Value",
            "type": "string"
          }
        },
        "required": [
          "value",
          "valid_from",
          "provenance"
        ],
        "title": "AccountingUltimateParentView",
        "type": "object"
      },
      "ActingSurface": {
        "description": "Which surface a decision was taken THROUGH.\n\nRecorded on every human-tier verdict beside the credential that carried it,\nbecause \"a human approved this merge\" and \"an autonomous agent holding an\nAPI key approved this merge\" are the same row without it: both are stamped\n`DecisionStage.HUMAN_REVIEW`, and a four-eyes control that cannot tell them\napart is a workflow step (docs/ACCURACY.md, docs/TRUST.md \u00a75).\n\nThe surface is derived from the code path that called the service and is\nnever caller-supplied. Remote API/MCP paths derive `reviewer_id` from the\nauthenticated REVIEW credential name; the trusted local operator path may\nname an analyst explicitly.",
        "enum": [
          "api",
          "mcp",
          "workbench",
          "maintenance"
        ],
        "title": "ActingSurface",
        "type": "string"
      },
      "AddressRequest": {
        "additionalProperties": false,
        "properties": {
          "city": {
            "anyOf": [
              {
                "maxLength": 128,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "City"
          },
          "country": {
            "anyOf": [
              {
                "maxLength": 64,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Country"
          },
          "line1": {
            "anyOf": [
              {
                "maxLength": 200,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Line1"
          },
          "line2": {
            "anyOf": [
              {
                "maxLength": 200,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Line2"
          },
          "postal_code": {
            "anyOf": [
              {
                "maxLength": 32,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Postal Code"
          },
          "region": {
            "anyOf": [
              {
                "maxLength": 128,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Region"
          }
        },
        "title": "AddressRequest",
        "type": "object"
      },
      "AdverseEvent": {
        "additionalProperties": false,
        "properties": {
          "category": {
            "enum": [
              "fraud",
              "corruption",
              "environment",
              "labor",
              "litigation",
              "regulatory",
              "other"
            ],
            "title": "Category",
            "type": "string"
          },
          "event_id": {
            "maxLength": 500,
            "minLength": 1,
            "title": "Event Id",
            "type": "string"
          },
          "evidence_excerpt": {
            "maxLength": 4000,
            "minLength": 1,
            "title": "Evidence Excerpt",
            "type": "string"
          },
          "occurred_on": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Occurred On"
          },
          "published_at": {
            "format": "date-time",
            "title": "Published At",
            "type": "string"
          },
          "source_url": {
            "format": "uri",
            "maxLength": 2083,
            "minLength": 1,
            "title": "Source Url",
            "type": "string"
          },
          "statement": {
            "maxLength": 1000,
            "minLength": 1,
            "title": "Statement",
            "type": "string"
          },
          "status": {
            "enum": [
              "allegation",
              "investigation",
              "charge",
              "confirmed_outcome",
              "dismissed",
              "corrected"
            ],
            "title": "Status",
            "type": "string"
          },
          "supersedes_event_id": {
            "anyOf": [
              {
                "maxLength": 500,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Supersedes Event Id"
          }
        },
        "required": [
          "event_id",
          "category",
          "status",
          "statement",
          "evidence_excerpt",
          "source_url",
          "published_at"
        ],
        "title": "AdverseEvent",
        "type": "object"
      },
      "ApiKeyListResponse": {
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "keys": {
            "items": {
              "$ref": "#/components/schemas/ApiKeyView"
            },
            "title": "Keys",
            "type": "array"
          }
        },
        "required": [
          "keys",
          "correlation_id"
        ],
        "title": "ApiKeyListResponse",
        "type": "object"
      },
      "ApiKeyView": {
        "description": "A credential's metadata. There is no field for the key, and cannot be:\nonly the SHA-256 digest is stored, so this is everything we hold.",
        "properties": {
          "active": {
            "title": "Active",
            "type": "boolean"
          },
          "created_at": {
            "format": "date-time",
            "title": "Created At",
            "type": "string"
          },
          "expires_at": {
            "anyOf": [
              {
                "format": "date-time",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Expires At"
          },
          "key_id": {
            "title": "Key Id",
            "type": "string"
          },
          "name": {
            "title": "Name",
            "type": "string"
          },
          "plan": {
            "title": "Plan",
            "type": "string"
          },
          "revoked": {
            "title": "Revoked",
            "type": "boolean"
          },
          "scope": {
            "title": "Scope",
            "type": "string"
          },
          "tenant_id": {
            "title": "Tenant Id",
            "type": "string"
          }
        },
        "required": [
          "key_id",
          "tenant_id",
          "name",
          "plan",
          "scope",
          "created_at",
          "revoked",
          "active"
        ],
        "title": "ApiKeyView",
        "type": "object"
      },
      "BatchEdgeBudgetView": {
        "description": "Observable bounds for phase-two pair comparison.\n\nDeferred pairs remain conservatively separate or in review; they are never\nsilently treated as non-matches.",
        "properties": {
          "bucket_deferred_pair_slots": {
            "default": 0,
            "title": "Bucket Deferred Pair Slots",
            "type": "integer"
          },
          "bucket_limit_exhausted": {
            "default": false,
            "title": "Bucket Limit Exhausted",
            "type": "boolean"
          },
          "candidate_pairs": {
            "default": 0,
            "title": "Candidate Pairs",
            "type": "integer"
          },
          "compared_pairs": {
            "default": 0,
            "title": "Compared Pairs",
            "type": "integer"
          },
          "deep_comparison_limit": {
            "default": 0,
            "title": "Deep Comparison Limit",
            "type": "integer"
          },
          "deep_comparisons": {
            "default": 0,
            "title": "Deep Comparisons",
            "type": "integer"
          },
          "deep_limit_exhausted": {
            "default": false,
            "title": "Deep Limit Exhausted",
            "type": "boolean"
          },
          "deferred_pairs": {
            "default": 0,
            "title": "Deferred Pairs",
            "type": "integer"
          },
          "oversized_bucket_records": {
            "default": 0,
            "title": "Oversized Bucket Records",
            "type": "integer"
          },
          "oversized_buckets": {
            "default": 0,
            "title": "Oversized Buckets",
            "type": "integer"
          },
          "pair_limit_deferred_pairs": {
            "default": 0,
            "title": "Pair Limit Deferred Pairs",
            "type": "integer"
          },
          "pair_limit_exhausted": {
            "default": false,
            "title": "Pair Limit Exhausted",
            "type": "boolean"
          }
        },
        "title": "BatchEdgeBudgetView",
        "type": "object"
      },
      "BatchJobView": {
        "properties": {
          "created_at": {
            "format": "date-time",
            "title": "Created At",
            "type": "string"
          },
          "error_code": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Error Code"
          },
          "finished_at": {
            "anyOf": [
              {
                "format": "date-time",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Finished At"
          },
          "job_id": {
            "title": "Job Id",
            "type": "string"
          },
          "state": {
            "enum": [
              "queued",
              "running",
              "succeeded",
              "failed",
              "cancelled",
              "reconciliation_required",
              "erased"
            ],
            "title": "State",
            "type": "string"
          },
          "total_records": {
            "title": "Total Records",
            "type": "integer"
          },
          "updated_at": {
            "format": "date-time",
            "title": "Updated At",
            "type": "string"
          }
        },
        "required": [
          "job_id",
          "state",
          "total_records",
          "created_at",
          "updated_at"
        ],
        "title": "BatchJobView",
        "type": "object"
      },
      "BatchPairDisclosureView": {
        "description": "Pairs found versus pairs returned. No cap in this contract is silent.\n\nThe pair lists are capped so one pathological batch cannot return a response\nlarger than the work it describes. When a cap bites, `*_truncated` is true\nand `*_found` still reports the real total, because a truncated list read as\na complete one understates prevented merges \u2014 the one error this surface\nmust never make.\n\n`reported_pair_limit == 0` is the fail-closed sentinel, the same one\n`BatchEdgeBudgetView.deep_comparison_limit` uses: it means this batch was\nsealed before pair reporting existed, so the pair lists are UNREPORTED and\nmust never be read as \"no pairs were found\".\n\nIt counts only pairs that were actually compared. Pairs the comparison\nbudget deferred are in `edge_budget.deferred_pairs`; they remain separate\nand are never silently treated as non-matches.",
        "properties": {
          "blocked_found": {
            "default": 0,
            "title": "Blocked Found",
            "type": "integer"
          },
          "blocked_returned": {
            "default": 0,
            "title": "Blocked Returned",
            "type": "integer"
          },
          "blocked_truncated": {
            "default": false,
            "title": "Blocked Truncated",
            "type": "boolean"
          },
          "reported_pair_limit": {
            "default": 0,
            "title": "Reported Pair Limit",
            "type": "integer"
          },
          "withheld_found": {
            "default": 0,
            "title": "Withheld Found",
            "type": "integer"
          },
          "withheld_returned": {
            "default": 0,
            "title": "Withheld Returned",
            "type": "integer"
          },
          "withheld_truncated": {
            "default": false,
            "title": "Withheld Truncated",
            "type": "boolean"
          }
        },
        "title": "BatchPairDisclosureView",
        "type": "object"
      },
      "BatchRequest": {
        "additionalProperties": false,
        "properties": {
          "records": {
            "items": {
              "$ref": "#/components/schemas/ResolveRequest"
            },
            "maxItems": 500,
            "minItems": 1,
            "title": "Records",
            "type": "array"
          }
        },
        "required": [
          "records"
        ],
        "title": "BatchRequest",
        "type": "object"
      },
      "BatchResponse": {
        "properties": {
          "batch_id": {
            "title": "Batch Id",
            "type": "string"
          },
          "blocked_pairs": {
            "items": {
              "$ref": "#/components/schemas/BlockedPairView"
            },
            "title": "Blocked Pairs",
            "type": "array"
          },
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "depth_ceiling": {
            "default": "",
            "description": "The deepest resolution stage any record in this batch was permitted to reach, after the plan ceiling was applied. Empty on a replay sealed before this field existed.",
            "title": "Depth Ceiling",
            "type": "string"
          },
          "edge_budget": {
            "$ref": "#/components/schemas/BatchEdgeBudgetView"
          },
          "outcomes": {
            "items": {
              "$ref": "#/components/schemas/ResolveResponse"
            },
            "title": "Outcomes",
            "type": "array"
          },
          "pair_disclosure": {
            "$ref": "#/components/schemas/BatchPairDisclosureView"
          },
          "replayed": {
            "title": "Replayed",
            "type": "boolean"
          },
          "usage": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/UsageView"
              },
              {
                "type": "null"
              }
            ]
          },
          "withheld_pairs": {
            "items": {
              "$ref": "#/components/schemas/WithheldPairView"
            },
            "title": "Withheld Pairs",
            "type": "array"
          }
        },
        "required": [
          "batch_id",
          "replayed",
          "outcomes",
          "correlation_id"
        ],
        "title": "BatchResponse",
        "type": "object"
      },
      "BlockedPairView": {
        "description": "A merge we proposed and our own merge guard then refused.\n\nThe strongest evidence in this response: the cascade reached a MATCH on\nthese two rows and a guard overrode it because named fields disagree. This\nis a prevented merge, not an abstention \u2014 do not read it as one, and do not\nread a withheld pair as one of these.\n\n`conflict_attributes` names YOUR OWN input fields, never an internal fact\nkey, so a conflict can be checked against the file you sent.\n\n`probability` and `stage` are the PRE-GUARD comparison: they describe the\nmerge the system wanted, which is the point of the row.",
        "properties": {
          "basis": {
            "description": "'decisive_identifier_conflict' when registered identifiers disagree outright, or 'corroborated_weak_evidence' when two or more individually rebuttable signals contradict.",
            "title": "Basis",
            "type": "string"
          },
          "conflict_attributes": {
            "description": "The input fields that disagreed, named as the record fields you submit: lei, duns, registration_number, domain, phone, email or address. 'unmapped' means the guard named a field this version cannot translate; the block still stands.",
            "items": {
              "type": "string"
            },
            "title": "Conflict Attributes",
            "type": "array"
          },
          "decision_id": {
            "description": "The receipt for the refused merge, redeemable at GET /v1/decisions/{decision_id}. It is recorded as `unresolved` with no binding confidence \u2014 the comparison happened, the merge did not \u2014 and carries the pre-guard verdict and the conflicting attributes as features.",
            "title": "Decision Id",
            "type": "string"
          },
          "left_client_ref": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Left Client Ref"
          },
          "left_record_id": {
            "title": "Left Record Id",
            "type": "string"
          },
          "probability": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "description": "The score of the match the guard refused, or null when no score was produced. It is what the cascade believed BEFORE the guard overrode it, and nothing was merged.",
            "title": "Probability"
          },
          "right_client_ref": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Right Client Ref"
          },
          "right_record_id": {
            "title": "Right Record Id",
            "type": "string"
          },
          "stage": {
            "$ref": "#/components/schemas/DecisionStage"
          },
          "strength": {
            "description": "'cannot_link' \u2014 a cited, decisive incompatibility \u2014 or 'advisory', which is corroborated but individually rebuttable evidence and is NOT a proven incompatibility. Only a decisive identifier conflict produces cannot_link.",
            "title": "Strength",
            "type": "string"
          }
        },
        "required": [
          "left_record_id",
          "right_record_id",
          "stage",
          "decision_id",
          "basis",
          "strength"
        ],
        "title": "BlockedPairView",
        "type": "object"
      },
      "BulkErrorView": {
        "description": "Why one item in a bulk submission was not settled.\n\nThe same `code` vocabulary the single-item route raises \u2014\n`review_item_not_found`, `review_already_resolved`, `reviewer_required` \u2014 so\na client handles a failure identically whichever way it submitted. No\ncorrelation id: that is a property of the request, and it is on the response\nonce.",
        "properties": {
          "code": {
            "title": "Code",
            "type": "string"
          },
          "message": {
            "title": "Message",
            "type": "string"
          }
        },
        "required": [
          "code",
          "message"
        ],
        "title": "BulkErrorView",
        "type": "object"
      },
      "BulkReviewDecisionRequest": {
        "additionalProperties": false,
        "description": "A reviewer settling a page of the queue in one call.\n\nCapped at `_BULK_VERDICT_MAX` items: each one applies a merge through the\nguard and writes an audit row, so an unbounded list is an unbounded\ntransaction budget behind a single request. A reviewer works pages, and the\ncap is a page.",
        "properties": {
          "items": {
            "items": {
              "$ref": "#/components/schemas/BulkReviewItemRequest"
            },
            "maxItems": 200,
            "minItems": 1,
            "title": "Items",
            "type": "array"
          },
          "reviewer_id": {
            "anyOf": [
              {
                "maxLength": 255,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Reviewer Id"
          }
        },
        "required": [
          "items"
        ],
        "title": "BulkReviewDecisionRequest",
        "type": "object"
      },
      "BulkReviewDecisionResponse": {
        "description": "What a bulk sweep did, item by item.\n\n`settled` and `failed` are counts of the SAME list, given because the common\nclient behaviour is \"tell me whether to look\" and counting eighty results to\nfind out is work every caller would otherwise repeat.",
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "failed": {
            "title": "Failed",
            "type": "integer"
          },
          "results": {
            "items": {
              "$ref": "#/components/schemas/BulkReviewResultView"
            },
            "title": "Results",
            "type": "array"
          },
          "settled": {
            "title": "Settled",
            "type": "integer"
          }
        },
        "required": [
          "results",
          "settled",
          "failed",
          "correlation_id"
        ],
        "title": "BulkReviewDecisionResponse",
        "type": "object"
      },
      "BulkReviewItemRequest": {
        "additionalProperties": false,
        "description": "One verdict inside a bulk submission.",
        "properties": {
          "decision": {
            "$ref": "#/components/schemas/MatchDecisionType"
          },
          "reason": {
            "anyOf": [
              {
                "maxLength": 2000,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Reason"
          },
          "review_id": {
            "maxLength": 100,
            "title": "Review Id",
            "type": "string"
          }
        },
        "required": [
          "review_id",
          "decision"
        ],
        "title": "BulkReviewItemRequest",
        "type": "object"
      },
      "BulkReviewResultView": {
        "description": "One item's outcome. Exactly one of `item` and `error` is set.\n\nDeclared after `ReviewItemView` deliberately \u2014 a settled item comes back in\nfull, so a sweep needs no follow-up read to see what its verdicts did.",
        "properties": {
          "error": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/BulkErrorView"
              },
              {
                "type": "null"
              }
            ]
          },
          "item": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ReviewItemView"
              },
              {
                "type": "null"
              }
            ]
          },
          "review_id": {
            "title": "Review Id",
            "type": "string"
          }
        },
        "required": [
          "review_id"
        ],
        "title": "BulkReviewResultView",
        "type": "object"
      },
      "CandidateExplanation": {
        "description": "Comparisons of the shortlist's visible fields, never a match verdict.\n\nNormalized equality is a discriminating clue, not calibrated confidence or\nan assertion that two records describe the same organization. Only the\ndisplayed legal name and domain participate; aliases, addresses and other\ncompanies' enrichment remain outside the shortlist visibility boundary.",
        "properties": {
          "displayed_name_role": {
            "default": "unknown",
            "enum": [
              "legal",
              "unknown"
            ],
            "title": "Displayed Name Role",
            "type": "string"
          },
          "domain_comparison": {
            "default": "not_compared",
            "enum": [
              "exact_normalized",
              "different",
              "not_compared"
            ],
            "title": "Domain Comparison",
            "type": "string"
          },
          "name_comparison": {
            "default": "not_compared",
            "enum": [
              "exact_normalized",
              "different",
              "not_compared"
            ],
            "title": "Name Comparison",
            "type": "string"
          }
        },
        "title": "CandidateExplanation",
        "type": "object"
      },
      "CandidateView": {
        "description": "One entity the cascade weighed, with the probability it scored.\n\nEnough to act on and nothing more: an abstention has to hand the caller the\nshortlist it could not choose between, but a full ResolvedEntity per\ncandidate would return other companies' enrichment as a side effect of\nfailing to decide.",
        "properties": {
          "adjudicator_confidence": {
            "anyOf": [
              {
                "maximum": 1.0,
                "minimum": 0.0,
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Adjudicator Confidence"
          },
          "adjudicator_decision": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/MatchDecisionType"
              },
              {
                "type": "null"
              }
            ]
          },
          "city": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "City"
          },
          "country": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Country"
          },
          "domain": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Domain"
          },
          "entity_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Entity Id"
          },
          "explanation": {
            "$ref": "#/components/schemas/CandidateExplanation"
          },
          "external": {
            "default": false,
            "title": "External",
            "type": "boolean"
          },
          "jurisdiction": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Jurisdiction"
          },
          "legal_name": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Legal Name"
          },
          "legal_status": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Legal Status"
          },
          "lei": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Lei"
          },
          "postal_code": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Postal Code"
          },
          "probability": {
            "anyOf": [
              {
                "maximum": 1.0,
                "minimum": 0.0,
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Probability"
          },
          "registered_address": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Registered Address"
          },
          "registration_number": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Registration Number"
          }
        },
        "title": "CandidateView",
        "type": "object"
      },
      "CaptureRequest": {
        "additionalProperties": false,
        "properties": {
          "as_of": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "As Of"
          },
          "capture_id": {
            "anyOf": [
              {
                "maxLength": 64,
                "minLength": 1,
                "pattern": "^[A-Za-z0-9_-]+$",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Capture Id"
          },
          "entity_ids": {
            "items": {
              "type": "string"
            },
            "maxItems": 100,
            "minItems": 1,
            "title": "Entity Ids",
            "type": "array"
          },
          "field_packs": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "maxItems": 8,
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Field Packs"
          },
          "fields": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "maxItems": 64,
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Fields"
          }
        },
        "required": [
          "entity_ids"
        ],
        "title": "CaptureRequest",
        "type": "object"
      },
      "Clarification": {
        "description": "Resubmit an independently known clue; a shortlist never authorizes a bind.",
        "properties": {
          "answer_by": {
            "default": "Resubmit the original record with the answer in the named typed fields. Preserve client_ref; context may add explanation. The normal pipeline checks the answer; candidate options are not verified matches.",
            "title": "Answer By",
            "type": "string"
          },
          "answer_fields": {
            "items": {
              "$ref": "#/components/schemas/ClarificationAnswerField"
            },
            "title": "Answer Fields",
            "type": "array"
          },
          "attribute": {
            "title": "Attribute",
            "type": "string"
          },
          "candidate_options": {
            "items": {
              "$ref": "#/components/schemas/ClarificationCandidateOption"
            },
            "title": "Candidate Options",
            "type": "array"
          },
          "options": {
            "items": {
              "type": "string"
            },
            "title": "Options",
            "type": "array"
          },
          "question": {
            "title": "Question",
            "type": "string"
          },
          "reason": {
            "default": "candidate_ambiguity",
            "enum": [
              "candidate_ambiguity",
              "missing_clue",
              "missing_identifying_input"
            ],
            "title": "Reason",
            "type": "string"
          }
        },
        "required": [
          "attribute",
          "question"
        ],
        "title": "Clarification",
        "type": "object"
      },
      "ClarificationAnswerField": {
        "properties": {
          "field": {
            "enum": [
              "domain",
              "registration_number",
              "jurisdiction",
              "lei",
              "address.line1",
              "address.postal_code",
              "address.city",
              "country",
              "name"
            ],
            "title": "Field",
            "type": "string"
          },
          "label": {
            "title": "Label",
            "type": "string"
          },
          "required": {
            "default": true,
            "title": "Required",
            "type": "boolean"
          },
          "value_type": {
            "const": "text",
            "default": "text",
            "title": "Value Type",
            "type": "string"
          }
        },
        "required": [
          "field",
          "label"
        ],
        "title": "ClarificationAnswerField",
        "type": "object"
      },
      "ClarificationCandidateOption": {
        "description": "A bounded visible clue, never a candidate-selection instruction.",
        "properties": {
          "candidate_index": {
            "minimum": 0.0,
            "title": "Candidate Index",
            "type": "integer"
          },
          "city": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "City"
          },
          "country": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Country"
          },
          "domain": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Domain"
          },
          "jurisdiction": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Jurisdiction"
          },
          "legal_name": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Legal Name"
          },
          "lei": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Lei"
          },
          "postal_code": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Postal Code"
          },
          "registered_address": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Registered Address"
          },
          "registration_number": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Registration Number"
          }
        },
        "required": [
          "candidate_index"
        ],
        "title": "ClarificationCandidateOption",
        "type": "object"
      },
      "ClarificationOrigin": {
        "additionalProperties": false,
        "description": "A tenant-owned unresolved submission, never an admission instruction.",
        "properties": {
          "decision_id": {
            "anyOf": [
              {
                "maxLength": 64,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Decision Id"
          },
          "job_id": {
            "anyOf": [
              {
                "maxLength": 64,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Job Id"
          },
          "record_id": {
            "maxLength": 64,
            "minLength": 1,
            "title": "Record Id",
            "type": "string"
          },
          "record_index": {
            "anyOf": [
              {
                "maximum": 4999.0,
                "minimum": 0.0,
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Record Index"
          }
        },
        "required": [
          "record_id"
        ],
        "title": "ClarificationOrigin",
        "type": "object"
      },
      "ClassificationCatalogue": {
        "description": "An official code vocabulary, separate from a company's assignment evidence.",
        "properties": {
          "attribution": {
            "title": "Attribution",
            "type": "string"
          },
          "describes_codes_only": {
            "const": true,
            "default": true,
            "title": "Describes Codes Only",
            "type": "boolean"
          },
          "downloaded_at": {
            "format": "date-time",
            "title": "Downloaded At",
            "type": "string"
          },
          "entries_sha256": {
            "pattern": "^[0-9a-f]{64}$",
            "title": "Entries Sha256",
            "type": "string"
          },
          "entry_count": {
            "minimum": 1.0,
            "title": "Entry Count",
            "type": "integer"
          },
          "guidance_edition": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Guidance Edition"
          },
          "guidance_published_on": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Guidance Published On"
          },
          "guidance_url": {
            "anyOf": [
              {
                "format": "uri",
                "maxLength": 2083,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Guidance Url"
          },
          "language": {
            "const": "en",
            "title": "Language",
            "type": "string"
          },
          "latest": {
            "title": "Latest",
            "type": "boolean"
          },
          "level_counts": {
            "additionalProperties": {
              "type": "integer"
            },
            "title": "Level Counts",
            "type": "object"
          },
          "licence": {
            "title": "Licence",
            "type": "string"
          },
          "licence_url": {
            "format": "uri",
            "maxLength": 2083,
            "minLength": 1,
            "title": "Licence Url",
            "type": "string"
          },
          "modifications": {
            "title": "Modifications",
            "type": "string"
          },
          "publisher": {
            "title": "Publisher",
            "type": "string"
          },
          "source_url": {
            "format": "uri",
            "maxLength": 2083,
            "minLength": 1,
            "title": "Source Url",
            "type": "string"
          },
          "taxonomy": {
            "const": "NACE",
            "title": "Taxonomy",
            "type": "string"
          },
          "title": {
            "title": "Title",
            "type": "string"
          },
          "version": {
            "enum": [
              "2",
              "2.1"
            ],
            "title": "Version",
            "type": "string"
          }
        },
        "required": [
          "taxonomy",
          "version",
          "latest",
          "title",
          "publisher",
          "language",
          "source_url",
          "licence",
          "licence_url",
          "attribution",
          "modifications",
          "downloaded_at",
          "entries_sha256",
          "entry_count",
          "level_counts"
        ],
        "title": "ClassificationCatalogue",
        "type": "object"
      },
      "ClientRefLinkView": {
        "description": "One submission made under a customer key, and everything it produced.\n\nThe crosswalk a buyer's stated success metric depends on: from a row in\ntheir own system, reach the receipt that explains what we decided about it \u2014\neighteen months later, without a spreadsheet. Every id here is redeemable:\n`decision_id` at `GET /v1/decisions/{id}`, `entity_id` at\n`GET /v1/entities/{id}`, `review_id` at `GET /v1/review-queue/{id}`.",
        "properties": {
          "client_ref": {
            "title": "Client Ref",
            "type": "string"
          },
          "created_at": {
            "anyOf": [
              {
                "format": "date-time",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Created At"
          },
          "decision_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Decision Id"
          },
          "entity_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Entity Id"
          },
          "record_id": {
            "title": "Record Id",
            "type": "string"
          },
          "review_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Review Id"
          }
        },
        "required": [
          "client_ref",
          "record_id"
        ],
        "title": "ClientRefLinkView",
        "type": "object"
      },
      "ClientRefResponse": {
        "description": "Every submission this tenant made under one customer key, oldest first.\n\nA key legitimately appears many times \u2014 a nightly sync re-sends the same row\n\u2014 and each submission is its own decision with its own receipt, so this is a\nlist rather than a single link.",
        "properties": {
          "client_ref": {
            "title": "Client Ref",
            "type": "string"
          },
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "items": {
            "items": {
              "$ref": "#/components/schemas/ClientRefLinkView"
            },
            "title": "Items",
            "type": "array"
          },
          "limit": {
            "title": "Limit",
            "type": "integer"
          },
          "offset": {
            "title": "Offset",
            "type": "integer"
          },
          "total": {
            "title": "Total",
            "type": "integer"
          },
          "usage": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/UsageView"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "required": [
          "client_ref",
          "items",
          "total",
          "limit",
          "offset",
          "correlation_id"
        ],
        "title": "ClientRefResponse",
        "type": "object"
      },
      "CompanyFilter": {
        "additionalProperties": false,
        "properties": {
          "field": {
            "enum": [
              "identity.legal_name",
              "digital.domain",
              "location.country",
              "entity_id",
              "created_at"
            ],
            "title": "Field",
            "type": "string"
          },
          "operator": {
            "enum": [
              "eq",
              "contains",
              "in",
              "gte",
              "lte"
            ],
            "title": "Operator",
            "type": "string"
          },
          "value": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "items": {
                  "type": "string"
                },
                "type": "array"
              }
            ],
            "title": "Value"
          }
        },
        "required": [
          "field",
          "operator",
          "value"
        ],
        "title": "CompanyFilter",
        "type": "object"
      },
      "CompanyReferenceBatchItem": {
        "additionalProperties": false,
        "properties": {
          "client_ref": {
            "anyOf": [
              {
                "maxLength": 256,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Client Ref"
          },
          "country": {
            "anyOf": [
              {
                "maxLength": 32,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Country"
          },
          "domain": {
            "anyOf": [
              {
                "maxLength": 2048,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Domain"
          }
        },
        "title": "CompanyReferenceBatchItem",
        "type": "object"
      },
      "CompanyReferenceBatchRequest": {
        "additionalProperties": false,
        "properties": {
          "limit": {
            "default": 5,
            "maximum": 10.0,
            "minimum": 2.0,
            "title": "Limit",
            "type": "integer"
          },
          "records": {
            "items": {
              "$ref": "#/components/schemas/CompanyReferenceBatchItem"
            },
            "maxItems": 100,
            "minItems": 1,
            "title": "Records",
            "type": "array"
          }
        },
        "required": [
          "records"
        ],
        "title": "CompanyReferenceBatchRequest",
        "type": "object"
      },
      "CompanyReferenceBatchResponse": {
        "additionalProperties": false,
        "properties": {
          "ai_calls": {
            "const": 0,
            "default": 0,
            "title": "Ai Calls",
            "type": "integer"
          },
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "credits_charged": {
            "const": 0,
            "default": 0,
            "title": "Credits Charged",
            "type": "integer"
          },
          "note": {
            "default": "Company-only licensed reference lookup; no AI, commercial provider calls or resolution credits. Every input row is retained, including missing domains, source failures and competing candidates. No candidate is automatically selected or written to a workspace entity. Profiles remain unverified; the source snapshot date is not a field observation or legal verification date.",
            "title": "Note",
            "type": "string"
          },
          "results": {
            "items": {
              "$ref": "#/components/schemas/CompanyReferenceBatchRow"
            },
            "maxItems": 100,
            "minItems": 1,
            "title": "Results",
            "type": "array"
          },
          "summary": {
            "additionalProperties": {
              "type": "integer"
            },
            "title": "Summary",
            "type": "object"
          }
        },
        "required": [
          "results",
          "summary",
          "correlation_id"
        ],
        "title": "CompanyReferenceBatchResponse",
        "type": "object"
      },
      "CompanyReferenceBatchRow": {
        "additionalProperties": false,
        "properties": {
          "input": {
            "$ref": "#/components/schemas/CompanyReferenceBatchItem"
          },
          "reason": {
            "anyOf": [
              {
                "enum": [
                  "missing_domain",
                  "unsupported_country",
                  "invalid_domain",
                  "request_deadline",
                  "not_configured",
                  "timeout",
                  "source_error",
                  "invalid_response"
                ],
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Reason"
          },
          "result": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/TenhawReferenceResult"
              },
              {
                "type": "null"
              }
            ]
          },
          "row_number": {
            "minimum": 1.0,
            "title": "Row Number",
            "type": "integer"
          },
          "status": {
            "enum": [
              "candidates",
              "no_candidates",
              "unavailable",
              "missing_domain",
              "invalid_input"
            ],
            "title": "Status",
            "type": "string"
          }
        },
        "required": [
          "row_number",
          "input",
          "status"
        ],
        "title": "CompanyReferenceBatchRow",
        "type": "object"
      },
      "CompanyReferenceQuery": {
        "additionalProperties": false,
        "properties": {
          "country": {
            "anyOf": [
              {
                "enum": [
                  "US",
                  "GB"
                ],
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Country"
          },
          "domain": {
            "maxLength": 253,
            "minLength": 1,
            "title": "Domain",
            "type": "string"
          },
          "limit": {
            "default": 20,
            "maximum": 50.0,
            "minimum": 1.0,
            "title": "Limit",
            "type": "integer"
          }
        },
        "required": [
          "domain"
        ],
        "title": "CompanyReferenceQuery",
        "type": "object"
      },
      "CompanyReferenceResponse": {
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "note": {
            "default": "Licensed vendor company records for discovery and basic enrichment. A domain hit is not a verified legal identity or an accepted resolution. Shared domains may return several records. Country is vendor-reported geography, not incorporation jurisdiction. Snapshot date is not field observation time. No tenant entities, decisions or usage credits are written by this lookup. Customer use is licensed; onward redistribution rights are not asserted.",
            "title": "Note",
            "type": "string"
          },
          "result": {
            "$ref": "#/components/schemas/TenhawReferenceResult"
          }
        },
        "required": [
          "result",
          "correlation_id"
        ],
        "title": "CompanyReferenceResponse",
        "type": "object"
      },
      "CompanySearch": {
        "additionalProperties": false,
        "properties": {
          "as_of": {
            "anyOf": [
              {
                "format": "date-time",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "As Of"
          },
          "cursor": {
            "anyOf": [
              {
                "maxLength": 2048,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Cursor"
          },
          "direction": {
            "default": "asc",
            "enum": [
              "asc",
              "desc"
            ],
            "title": "Direction",
            "type": "string"
          },
          "filters": {
            "items": {
              "$ref": "#/components/schemas/CompanyFilter"
            },
            "maxItems": 16,
            "title": "Filters",
            "type": "array"
          },
          "limit": {
            "default": 50,
            "maximum": 100.0,
            "minimum": 1.0,
            "title": "Limit",
            "type": "integer"
          },
          "scan_limit": {
            "default": 500,
            "maximum": 1000.0,
            "minimum": 1.0,
            "title": "Scan Limit",
            "type": "integer"
          },
          "sort_by": {
            "default": "created_at",
            "enum": [
              "created_at",
              "entity_id"
            ],
            "title": "Sort By",
            "type": "string"
          }
        },
        "title": "CompanySearch",
        "type": "object"
      },
      "ComparisonEvidenceTier": {
        "description": "Strength of the evidence that actually agrees for one comparison.\n\nPopulated fields are not evidence of a match.  In particular, a legal name,\ncountry and legal form can all be present on both sides while still naming\ntwo unrelated companies.  This tier is derived from agreement features so\nconfidence calibration cannot pool those name-only decisions with pairs\ncorroborated by an independent attribute.",
        "enum": [
          "identifier",
          "corroborated",
          "uncorroborated"
        ],
        "title": "ComparisonEvidenceTier",
        "type": "string"
      },
      "CompletenessReport": {
        "additionalProperties": false,
        "description": "Field fill and independently sourced fill over one explicit selection.",
        "properties": {
          "completeness": {
            "anyOf": [
              {
                "maximum": 1.0,
                "minimum": 0.0,
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Completeness"
          },
          "denominator_policy": {
            "const": "explicit_requested_fields_no_automatic_exclusions",
            "default": "explicit_requested_fields_no_automatic_exclusions",
            "title": "Denominator Policy",
            "type": "string"
          },
          "field_count": {
            "minimum": 0.0,
            "title": "Field Count",
            "type": "integer"
          },
          "filled_completeness": {
            "anyOf": [
              {
                "maximum": 1.0,
                "minimum": 0.0,
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Filled Completeness"
          },
          "filled_fields_count": {
            "minimum": 0.0,
            "title": "Filled Fields Count",
            "type": "integer"
          },
          "limitations": {
            "items": {
              "type": "string"
            },
            "title": "Limitations",
            "type": "array"
          },
          "missing_diagnostics": {
            "additionalProperties": {
              "$ref": "#/components/schemas/ResearchFieldDiagnostic"
            },
            "maxProperties": 22,
            "title": "Missing Diagnostics",
            "type": "object"
          },
          "missing_fields": {
            "items": {
              "type": "string"
            },
            "title": "Missing Fields",
            "type": "array"
          },
          "missing_reasons": {
            "additionalProperties": {
              "type": "string"
            },
            "title": "Missing Reasons",
            "type": "object"
          },
          "requested_fields": {
            "items": {
              "type": "string"
            },
            "title": "Requested Fields",
            "type": "array"
          },
          "sourced_fields_count": {
            "minimum": 0.0,
            "title": "Sourced Fields Count",
            "type": "integer"
          }
        },
        "required": [
          "requested_fields",
          "field_count",
          "filled_fields_count",
          "sourced_fields_count",
          "missing_fields",
          "missing_reasons"
        ],
        "title": "CompletenessReport",
        "type": "object"
      },
      "ConfidenceBasis": {
        "description": "What kind of evidence set `match_confidence` on one response.\n\nThe number means the same thing in every row \u2014 see `domain/confidence.py`\nfor the definition it is held to \u2014 and this says where it came from, which\nis the part a caller cannot recover from the number itself. It exists\nbecause the field it replaces was five different quantities wearing one\nname: a caller reading `0.9` could not tell a calibrated probability from a\nconstant, and the two want different handling on the same threshold.",
        "enum": [
          "calibrated_probability",
          "identifier_rule",
          "adjudicated",
          "human_review",
          "no_candidate_matched",
          "no_candidate_retrieved",
          "inherited_from_binding",
          "no_binding"
        ],
        "title": "ConfidenceBasis",
        "type": "string"
      },
      "CorporateOwnerView": {
        "description": "A company that controls this one, with its own registration where known.",
        "properties": {
          "ceased_on": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Ceased On"
          },
          "country_registered": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Country Registered"
          },
          "legal_form": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Legal Form"
          },
          "name": {
            "title": "Name",
            "type": "string"
          },
          "natures_of_control": {
            "items": {
              "type": "string"
            },
            "title": "Natures Of Control",
            "type": "array"
          },
          "notified_on": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Notified On"
          },
          "place_registered": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Place Registered"
          },
          "registration_number": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Registration Number"
          }
        },
        "required": [
          "name"
        ],
        "title": "CorporateOwnerView",
        "type": "object"
      },
      "CreateInstallTicketRequest": {
        "additionalProperties": false,
        "description": "Mint the proof a person will paste to authorize a connector for a tenant.\n\nThere is no `redirect_uri`, no `client_id` and no scope here on purpose: a\nticket says WHO the install is for and nothing about WHAT is being installed.\nBinding it to one client would mean minting a ticket per connector and would\nmake this endpoint a place where a tenant admin picks OAuth parameters, which\nis the connector's job and the operator's, not theirs.",
        "properties": {
          "tenant_id": {
            "maxLength": 64,
            "title": "Tenant Id",
            "type": "string"
          }
        },
        "required": [
          "tenant_id"
        ],
        "title": "CreateInstallTicketRequest",
        "type": "object"
      },
      "CreateInvestigation": {
        "additionalProperties": false,
        "properties": {
          "acknowledge_data_transfer": {
            "const": true,
            "title": "Acknowledge Data Transfer",
            "type": "boolean"
          },
          "idempotency_key": {
            "maxLength": 128,
            "minLength": 8,
            "title": "Idempotency Key",
            "type": "string"
          },
          "message": {
            "anyOf": [
              {
                "maxLength": 4000,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message"
          },
          "review_id": {
            "maxLength": 100,
            "minLength": 1,
            "title": "Review Id",
            "type": "string"
          }
        },
        "required": [
          "review_id",
          "idempotency_key",
          "acknowledge_data_transfer"
        ],
        "title": "CreateInvestigation",
        "type": "object"
      },
      "CreateKeyRequest": {
        "additionalProperties": false,
        "description": "Mint a customer credential for a tenant the caller administers.\n\nOPERATOR is deliberately absent: it crosses tenant boundaries in the\ninternal workbench and is issuable only from the local maintenance CLI.\n`AccountService` enforces the same boundary behind this schema.",
        "properties": {
          "name": {
            "maxLength": 255,
            "minLength": 1,
            "title": "Name",
            "type": "string"
          },
          "plan": {
            "$ref": "#/components/schemas/PlanTier",
            "default": "free"
          },
          "scope": {
            "default": "resolve",
            "enum": [
              "read",
              "resolve",
              "review",
              "erase",
              "admin"
            ],
            "title": "Scope",
            "type": "string"
          },
          "tenant_id": {
            "maxLength": 64,
            "title": "Tenant Id",
            "type": "string"
          }
        },
        "required": [
          "tenant_id",
          "name"
        ],
        "title": "CreateKeyRequest",
        "type": "object"
      },
      "CreateTenantRequest": {
        "additionalProperties": false,
        "description": "Mint a sub-tenant. The id is DERIVED from `slug`, never supplied.\n\nA caller-chosen tenant id would make \"already exists\" an oracle over every\ncustomer id in the deployment: a reseller could probe for a competitor's\ntenant by watching for a 409. Namespacing under the caller's own tenant\nmeans a collision can only ever be with something they already own.",
        "properties": {
          "name": {
            "maxLength": 255,
            "minLength": 1,
            "title": "Name",
            "type": "string"
          },
          "plan": {
            "$ref": "#/components/schemas/PlanTier",
            "default": "free"
          },
          "slug": {
            "maxLength": 41,
            "pattern": "^[a-z0-9][a-z0-9-]{0,40}$",
            "title": "Slug",
            "type": "string"
          }
        },
        "required": [
          "slug",
          "name"
        ],
        "title": "CreateTenantRequest",
        "type": "object"
      },
      "CreditRule": {
        "properties": {
          "credits": {
            "title": "Credits",
            "type": "integer"
          },
          "explanation": {
            "title": "Explanation",
            "type": "string"
          },
          "outcome": {
            "title": "Outcome",
            "type": "string"
          }
        },
        "required": [
          "outcome",
          "credits",
          "explanation"
        ],
        "title": "CreditRule",
        "type": "object"
      },
      "CreditUsageView": {
        "description": "Where the credits went, and what was served for free.",
        "properties": {
          "charged": {
            "title": "Charged",
            "type": "integer"
          },
          "deep_calls": {
            "title": "Deep Calls",
            "type": "integer"
          },
          "free_abstentions": {
            "title": "Free Abstentions",
            "type": "integer"
          },
          "free_replays": {
            "title": "Free Replays",
            "type": "integer"
          }
        },
        "required": [
          "charged",
          "free_replays",
          "free_abstentions",
          "deep_calls"
        ],
        "title": "CreditUsageView",
        "type": "object"
      },
      "CrosswalkRequest": {
        "additionalProperties": false,
        "description": "A crosswalk lookup with required name/country and optional identifiers.\n\nSubclasses the resolve request because it IS one \u2014 the crosswalk is a\nprojection of a resolution, and a second, subtly different set of input caps\nis a second thing to keep correct.",
        "properties": {
          "address": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/AddressRequest"
              },
              {
                "type": "null"
              }
            ]
          },
          "as_of": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "As Of"
          },
          "clarification_of": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ClarificationOrigin"
              },
              {
                "type": "null"
              }
            ]
          },
          "client_ref": {
            "anyOf": [
              {
                "maxLength": 200,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Client Ref"
          },
          "context": {
            "anyOf": [
              {
                "maxLength": 1000,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "description": "Anything you know about this company in plain language, e.g. 'recruitment company based in the UK, not the pub chain'. Use it when the name alone is ambiguous: it is weighed as evidence alongside the registers, and it is what separates two companies that share a name. It is treated as an unverified claim, so a register that contradicts it wins, and it cannot direct the answer \u2014 asserting the verdict or a confidence here has no effect.",
            "title": "Context"
          },
          "country": {
            "description": "Required country name or ISO country code; a retrieval clue, not legal identity proof.",
            "maxLength": 64,
            "minLength": 1,
            "title": "Country",
            "type": "string"
          },
          "depth": {
            "$ref": "#/components/schemas/ResolutionDepth",
            "default": "research"
          },
          "description": {
            "anyOf": [
              {
                "maxLength": 1000,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "description": "Alias for context: an optional, unverified company description.",
            "title": "Description"
          },
          "domain": {
            "anyOf": [
              {
                "maxLength": 253,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Domain"
          },
          "duns": {
            "anyOf": [
              {
                "maxLength": 16,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Duns"
          },
          "email": {
            "anyOf": [
              {
                "maxLength": 320,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Email"
          },
          "enrich": {
            "default": true,
            "title": "Enrich",
            "type": "boolean"
          },
          "exchange": {
            "anyOf": [
              {
                "maxLength": 64,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Exchange"
          },
          "extra": {
            "additionalProperties": {
              "type": "string"
            },
            "title": "Extra",
            "type": "object"
          },
          "field_packs": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "maxItems": 8,
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "description": "Named groups of returned attributes; combined with fields. Missing values have explicit status rather than invented data.",
            "title": "Field Packs"
          },
          "fields": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "maxItems": 64,
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "description": "Returned entity attributes; discover them at /v1/reference/enrichment-fields. Projection only: does not change identity evidence, acquisition, confidence or billing.",
            "title": "Fields"
          },
          "include_field_status": {
            "default": false,
            "title": "Include Field Status",
            "type": "boolean"
          },
          "incorporation_date": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Incorporation Date"
          },
          "isin": {
            "anyOf": [
              {
                "maxLength": 12,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Isin"
          },
          "jurisdiction": {
            "anyOf": [
              {
                "maxLength": 32,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Jurisdiction"
          },
          "legal_form": {
            "anyOf": [
              {
                "maxLength": 64,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Legal Form"
          },
          "lei": {
            "anyOf": [
              {
                "maxLength": 20,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Lei"
          },
          "max_hops": {
            "default": 1,
            "maximum": 10.0,
            "minimum": 1.0,
            "title": "Max Hops",
            "type": "integer"
          },
          "name": {
            "description": "Company name is required.",
            "maxLength": 500,
            "minLength": 1,
            "title": "Name",
            "type": "string"
          },
          "parent_name": {
            "anyOf": [
              {
                "maxLength": 500,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Parent Name"
          },
          "phone": {
            "anyOf": [
              {
                "maxLength": 64,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Phone"
          },
          "postcode": {
            "anyOf": [
              {
                "maxLength": 32,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "description": "Alias for address.postal_code: an optional postcode or ZIP code.",
            "title": "Postcode"
          },
          "previous_names": {
            "items": {
              "type": "string"
            },
            "maxItems": 10,
            "title": "Previous Names",
            "type": "array"
          },
          "quality_target": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/QualityTarget"
              },
              {
                "type": "null"
              }
            ],
            "description": "Optional delivery target, defaulting to 0.95 calibrated match confidence and 0.95 sourced completeness. Requires explicit nonempty fields or field_packs. At research depth, missing supported descriptive fields may trigger one bounded paid research pass. Unmet targets are reported for review; values are never invented."
          },
          "registration_number": {
            "anyOf": [
              {
                "maxLength": 64,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Registration Number"
          },
          "ticker": {
            "anyOf": [
              {
                "maxLength": 16,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Ticker"
          },
          "trading_names": {
            "items": {
              "type": "string"
            },
            "maxItems": 10,
            "title": "Trading Names",
            "type": "array"
          },
          "vat_number": {
            "anyOf": [
              {
                "maxLength": 32,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Vat Number"
          },
          "website": {
            "anyOf": [
              {
                "maxLength": 500,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Website"
          }
        },
        "required": [
          "name",
          "country"
        ],
        "title": "CrosswalkRequest",
        "type": "object"
      },
      "CrosswalkResolveResponse": {
        "description": "A crosswalk lookup: the resolution that found the company, then the map.\n\nCarries the decision fields as well as the crosswalk because the crosswalk\nis only worth what the match behind it is worth. `crosswalk` is null exactly\nwhen `decision` is `unresolved` \u2014 an abstention hands back `candidates`\ninstead, and inventing an identifier map for a company we could not identify\nis the one thing this surface must never do.",
        "properties": {
          "candidates": {
            "items": {
              "$ref": "#/components/schemas/CandidateView"
            },
            "title": "Candidates",
            "type": "array"
          },
          "client_ref": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Client Ref"
          },
          "confidence": {
            "title": "Confidence",
            "type": "number"
          },
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "crosswalk": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/CrosswalkView"
              },
              {
                "type": "null"
              }
            ]
          },
          "decision": {
            "$ref": "#/components/schemas/MatchDecisionType"
          },
          "decision_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Decision Id"
          },
          "depth_capped": {
            "default": false,
            "title": "Depth Capped",
            "type": "boolean"
          },
          "entity_created": {
            "default": false,
            "title": "Entity Created",
            "type": "boolean"
          },
          "escalation_unavailable": {
            "default": false,
            "title": "Escalation Unavailable",
            "type": "boolean"
          },
          "match_confidence": {
            "title": "Match Confidence",
            "type": "number"
          },
          "match_confidence_basis": {
            "$ref": "#/components/schemas/ConfidenceBasis"
          },
          "pipeline_version": {
            "default": "",
            "title": "Pipeline Version",
            "type": "string"
          },
          "record_id": {
            "title": "Record Id",
            "type": "string"
          },
          "replayed": {
            "default": false,
            "title": "Replayed",
            "type": "boolean"
          },
          "review_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Review Id"
          },
          "stage": {
            "$ref": "#/components/schemas/DecisionStage"
          },
          "usage": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/UsageView"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "required": [
          "record_id",
          "decision",
          "stage",
          "confidence",
          "match_confidence",
          "match_confidence_basis",
          "correlation_id"
        ],
        "title": "CrosswalkResolveResponse",
        "type": "object"
      },
      "CrosswalkResponse": {
        "description": "A crosswalk read back for an entity the caller already owns.",
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "crosswalk": {
            "$ref": "#/components/schemas/CrosswalkView"
          },
          "usage": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/UsageView"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "required": [
          "crosswalk",
          "correlation_id"
        ],
        "title": "CrosswalkResponse",
        "type": "object"
      },
      "CrosswalkView": {
        "description": "The mapping between identifier systems, plus the graph hanging off it.",
        "properties": {
          "checked_and_empty": {
            "items": {
              "$ref": "#/components/schemas/IdentifierGapView"
            },
            "title": "Checked And Empty",
            "type": "array"
          },
          "entity_id": {
            "title": "Entity Id",
            "type": "string"
          },
          "identifiers": {
            "items": {
              "$ref": "#/components/schemas/IdentifierView"
            },
            "title": "Identifiers",
            "type": "array"
          },
          "legal_name": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Legal Name"
          },
          "ownership": {
            "$ref": "#/components/schemas/OwnershipView"
          }
        },
        "required": [
          "entity_id",
          "ownership"
        ],
        "title": "CrosswalkView",
        "type": "object"
      },
      "CustomerFeedbackResponse": {
        "properties": {
          "label_id": {
            "title": "Label Id",
            "type": "string"
          },
          "message": {
            "title": "Message",
            "type": "string"
          },
          "recorded_at": {
            "format": "date-time",
            "title": "Recorded At",
            "type": "string"
          },
          "report": {
            "enum": [
              "correct",
              "wrong"
            ],
            "title": "Report",
            "type": "string"
          }
        },
        "required": [
          "label_id",
          "report",
          "recorded_at",
          "message"
        ],
        "title": "CustomerFeedbackResponse",
        "type": "object"
      },
      "CustomerOutcomeResponse": {
        "properties": {
          "cohort": {
            "additionalProperties": {
              "type": "integer"
            },
            "title": "Cohort",
            "type": "object"
          },
          "credits": {
            "additionalProperties": {
              "anyOf": [
                {
                  "type": "integer"
                },
                {
                  "type": "string"
                }
              ]
            },
            "title": "Credits",
            "type": "object"
          },
          "feedback": {
            "additionalProperties": {
              "anyOf": [
                {
                  "type": "integer"
                },
                {
                  "type": "number"
                },
                {
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ]
            },
            "title": "Feedback",
            "type": "object"
          },
          "field_fill": {
            "items": {
              "additionalProperties": {
                "anyOf": [
                  {
                    "type": "string"
                  },
                  {
                    "type": "integer"
                  }
                ]
              },
              "type": "object"
            },
            "title": "Field Fill",
            "type": "array"
          },
          "latency": {
            "additionalProperties": {
              "anyOf": [
                {
                  "type": "integer"
                },
                {
                  "type": "number"
                },
                {
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ]
            },
            "title": "Latency",
            "type": "object"
          },
          "limitations": {
            "items": {
              "type": "string"
            },
            "title": "Limitations",
            "type": "array"
          },
          "partial": {
            "title": "Partial",
            "type": "boolean"
          },
          "period": {
            "additionalProperties": {
              "type": "string"
            },
            "title": "Period",
            "type": "object"
          }
        },
        "required": [
          "cohort",
          "period",
          "credits",
          "latency",
          "field_fill",
          "feedback",
          "partial",
          "limitations"
        ],
        "title": "CustomerOutcomeResponse",
        "type": "object"
      },
      "DecisionListResponse": {
        "description": "One page of receipts, and the size of the set they were drawn from.\n\nExists for the remediation question a compliance buyer asks by name: \"show\nme every decision taken under the old threshold, or the old pipeline\". Every\nrow already stored both; there was simply no way to ask for more than one id\nat a time, so the answer required an export and a script.",
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "items": {
            "items": {
              "$ref": "#/components/schemas/DecisionView"
            },
            "title": "Items",
            "type": "array"
          },
          "limit": {
            "title": "Limit",
            "type": "integer"
          },
          "offset": {
            "title": "Offset",
            "type": "integer"
          },
          "total": {
            "title": "Total",
            "type": "integer"
          },
          "usage": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/UsageView"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "required": [
          "items",
          "total",
          "limit",
          "offset",
          "correlation_id"
        ],
        "title": "DecisionListResponse",
        "type": "object"
      },
      "DecisionReplayView": {
        "description": "Proof that the stored score still reproduces from the stored features.\n\nThe receipt is only worth anything if it can be checked. Re-running the\nscorer over the features recorded at the time is that check: if the number\ncomes back identical, the probability on the receipt is the probability the\npipeline computed, and neither has been edited since.",
        "properties": {
          "pipeline_version_matches": {
            "title": "Pipeline Version Matches",
            "type": "boolean"
          },
          "recomputed_probability": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Recomputed Probability"
          },
          "reproduced": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Reproduced"
          }
        },
        "required": [
          "pipeline_version_matches"
        ],
        "title": "DecisionReplayView",
        "type": "object"
      },
      "DecisionResponse": {
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "decision": {
            "$ref": "#/components/schemas/DecisionView"
          },
          "usage": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/UsageView"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "required": [
          "decision",
          "correlation_id"
        ],
        "title": "DecisionResponse",
        "type": "object"
      },
      "DecisionStage": {
        "enum": [
          "deterministic",
          "probabilistic",
          "llm_adjudication",
          "agentic_research",
          "human_review"
        ],
        "title": "DecisionStage",
        "type": "string"
      },
      "DecisionUsageView": {
        "properties": {
          "calls": {
            "title": "Calls",
            "type": "integer"
          },
          "credits": {
            "title": "Credits",
            "type": "integer"
          },
          "decision": {
            "$ref": "#/components/schemas/MatchDecisionType"
          }
        },
        "required": [
          "decision",
          "calls",
          "credits"
        ],
        "title": "DecisionUsageView",
        "type": "object"
      },
      "DecisionView": {
        "properties": {
          "acting_key_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Acting Key Id"
          },
          "acting_surface": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ActingSurface"
              },
              {
                "type": "null"
              }
            ]
          },
          "decided_at": {
            "format": "date-time",
            "title": "Decided At",
            "type": "string"
          },
          "decision": {
            "$ref": "#/components/schemas/MatchDecisionType"
          },
          "decision_id": {
            "title": "Decision Id",
            "type": "string"
          },
          "evidence": {
            "items": {
              "$ref": "#/components/schemas/EvidenceView"
            },
            "title": "Evidence",
            "type": "array"
          },
          "features": {
            "additionalProperties": {
              "type": "number"
            },
            "title": "Features",
            "type": "object"
          },
          "identifier_rule": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Identifier Rule"
          },
          "left_record_id": {
            "title": "Left Record Id",
            "type": "string"
          },
          "match_confidence": {
            "anyOf": [
              {
                "maximum": 1.0,
                "minimum": 0.0,
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Match Confidence"
          },
          "match_confidence_basis": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ConfidenceBasis"
              },
              {
                "type": "null"
              }
            ]
          },
          "pipeline_version": {
            "default": "",
            "title": "Pipeline Version",
            "type": "string"
          },
          "probability": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Probability"
          },
          "replay": {
            "$ref": "#/components/schemas/DecisionReplayView"
          },
          "reviewer_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Reviewer Id"
          },
          "reviewer_reason": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Reviewer Reason"
          },
          "right_ref": {
            "title": "Right Ref",
            "type": "string"
          },
          "stage": {
            "$ref": "#/components/schemas/DecisionStage"
          },
          "thresholds": {
            "additionalProperties": {
              "type": "number"
            },
            "title": "Thresholds",
            "type": "object"
          },
          "top_features": {
            "items": {
              "$ref": "#/components/schemas/FeatureContributionView"
            },
            "title": "Top Features",
            "type": "array"
          },
          "verdict": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/VerdictView"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "required": [
          "decision_id",
          "left_record_id",
          "right_ref",
          "decision",
          "stage",
          "decided_at",
          "replay"
        ],
        "title": "DecisionView",
        "type": "object"
      },
      "DetachRecordRequest": {
        "additionalProperties": false,
        "description": "A named human correction of one record's entity membership.",
        "properties": {
          "reason": {
            "maxLength": 2000,
            "minLength": 1,
            "title": "Reason",
            "type": "string"
          },
          "record_id": {
            "maxLength": 100,
            "minLength": 1,
            "title": "Record Id",
            "type": "string"
          },
          "reviewer_id": {
            "anyOf": [
              {
                "maxLength": 255,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Reviewer Id"
          }
        },
        "required": [
          "record_id",
          "reason"
        ],
        "title": "DetachRecordRequest",
        "type": "object"
      },
      "DetachRecordResponse": {
        "description": "Both sides of an applied split and its immutable audit receipt.",
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "decision_id": {
            "title": "Decision Id",
            "type": "string"
          },
          "detached_entity": {
            "$ref": "#/components/schemas/EntityView"
          },
          "record_id": {
            "title": "Record Id",
            "type": "string"
          },
          "source_entity": {
            "$ref": "#/components/schemas/EntityView"
          },
          "usage": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/UsageView"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "required": [
          "record_id",
          "source_entity",
          "detached_entity",
          "decision_id",
          "correlation_id"
        ],
        "title": "DetachRecordResponse",
        "type": "object"
      },
      "EndpointUsageView": {
        "properties": {
          "calls": {
            "title": "Calls",
            "type": "integer"
          },
          "credits": {
            "title": "Credits",
            "type": "integer"
          },
          "endpoint": {
            "title": "Endpoint",
            "type": "string"
          }
        },
        "required": [
          "endpoint",
          "calls",
          "credits"
        ],
        "title": "EndpointUsageView",
        "type": "object"
      },
      "EnrichmentAvailability": {
        "enum": [
          "available",
          "not_configured",
          "unavailable",
          "pass_through_only",
          "not_supported"
        ],
        "title": "EnrichmentAvailability",
        "type": "string"
      },
      "EnrichmentField": {
        "properties": {
          "attribute": {
            "title": "Attribute",
            "type": "string"
          },
          "availability": {
            "$ref": "#/components/schemas/EnrichmentAvailability"
          },
          "cardinality": {
            "default": "unknown",
            "enum": [
              "one",
              "many",
              "source_dependent",
              "unknown"
            ],
            "title": "Cardinality",
            "type": "string"
          },
          "category": {
            "title": "Category",
            "type": "string"
          },
          "dimensions": {
            "default": [],
            "description": "Dimension keys when supplied, not completeness requirements for every source.",
            "items": {
              "type": "string"
            },
            "title": "Dimensions",
            "type": "array"
          },
          "field_packs": {
            "default": [],
            "items": {
              "type": "string"
            },
            "title": "Field Packs",
            "type": "array"
          },
          "ready_sources": {
            "items": {
              "type": "string"
            },
            "title": "Ready Sources",
            "type": "array"
          },
          "reference_catalogues": {
            "description": "Official classification vocabularies; not evidence of a company assignment.",
            "items": {
              "$ref": "#/components/schemas/ClassificationCatalogue"
            },
            "title": "Reference Catalogues",
            "type": "array"
          },
          "resellable_sources": {
            "items": {
              "type": "string"
            },
            "title": "Resellable Sources",
            "type": "array"
          },
          "source_value_schemas": {
            "additionalProperties": {
              "additionalProperties": true,
              "type": "object"
            },
            "description": "Public value schemas keyed by the source that implements them, where available.",
            "title": "Source Value Schemas",
            "type": "object"
          },
          "sources": {
            "items": {
              "type": "string"
            },
            "title": "Sources",
            "type": "array"
          },
          "storable_sources": {
            "items": {
              "type": "string"
            },
            "title": "Storable Sources",
            "type": "array"
          },
          "units": {
            "default": [],
            "description": "Semantic units; currency codes remain attached to actual values.",
            "items": {
              "type": "string"
            },
            "title": "Units",
            "type": "array"
          },
          "value_contract": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Value Contract"
          },
          "value_schema": {
            "anyOf": [
              {
                "additionalProperties": true,
                "type": "object"
              },
              {
                "type": "null"
              }
            ],
            "description": "Conservative common value shape; source-specific schemas carry stricter detail.",
            "title": "Value Schema"
          },
          "value_type": {
            "default": "unknown",
            "enum": [
              "string",
              "number",
              "object",
              "array",
              "source_dependent",
              "unknown"
            ],
            "title": "Value Type",
            "type": "string"
          }
        },
        "required": [
          "attribute",
          "category",
          "availability",
          "sources",
          "ready_sources",
          "storable_sources",
          "resellable_sources"
        ],
        "title": "EnrichmentField",
        "type": "object"
      },
      "EnrichmentFieldsResponse": {
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "field_packs": {
            "items": {
              "$ref": "#/components/schemas/FieldPack"
            },
            "title": "Field Packs",
            "type": "array"
          },
          "note": {
            "title": "Note",
            "type": "string"
          },
          "values": {
            "items": {
              "$ref": "#/components/schemas/EnrichmentField"
            },
            "title": "Values",
            "type": "array"
          }
        },
        "required": [
          "values",
          "note",
          "correlation_id"
        ],
        "title": "EnrichmentFieldsResponse",
        "type": "object"
      },
      "EntityChangeCategory": {
        "enum": [
          "identity",
          "identifiers",
          "legal_status",
          "location",
          "contact",
          "financials",
          "ownership",
          "firmographics",
          "other"
        ],
        "title": "EntityChangeCategory",
        "type": "string"
      },
      "EntityEventsResponse": {
        "properties": {
          "events": {
            "items": {
              "additionalProperties": true,
              "type": "object"
            },
            "title": "Events",
            "type": "array"
          },
          "next_cursor": {
            "title": "Next Cursor",
            "type": "integer"
          },
          "scanned_count": {
            "default": 0,
            "title": "Scanned Count",
            "type": "integer"
          }
        },
        "required": [
          "events",
          "next_cursor"
        ],
        "title": "EntityEventsResponse",
        "type": "object"
      },
      "EntityListResponse": {
        "description": "One page of the tenant's catalogue, with the total the page sits in.\n\nFull entity views rather than the summaries `/v1/entities/search` returns:\nsearch is unbilled triage over companies the caller has NOT been matched to,\nwhile this is the caller's own data, and an enumeration that withheld the\nrecords would not be an export path (GDPR art. 20) or an erasure one.",
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "items": {
            "items": {
              "$ref": "#/components/schemas/EntityView"
            },
            "title": "Items",
            "type": "array"
          },
          "limit": {
            "title": "Limit",
            "type": "integer"
          },
          "next_cursor": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "description": "Opaque continuation for deletion-safe pagination; reuse the same filters.",
            "title": "Next Cursor"
          },
          "offset": {
            "title": "Offset",
            "type": "integer"
          },
          "total": {
            "title": "Total",
            "type": "integer"
          },
          "usage": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/UsageView"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "required": [
          "items",
          "total",
          "limit",
          "offset",
          "correlation_id"
        ],
        "title": "EntityListResponse",
        "type": "object"
      },
      "EntityResponse": {
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "entity": {
            "$ref": "#/components/schemas/EntityView"
          },
          "usage": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/UsageView"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "required": [
          "entity",
          "correlation_id"
        ],
        "title": "EntityResponse",
        "type": "object"
      },
      "EntitySearchResponse": {
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "limit": {
            "title": "Limit",
            "type": "integer"
          },
          "results": {
            "items": {
              "$ref": "#/components/schemas/EntitySummaryView"
            },
            "title": "Results",
            "type": "array"
          },
          "usage": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/UsageView"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "required": [
          "results",
          "limit",
          "correlation_id"
        ],
        "title": "EntitySearchResponse",
        "type": "object"
      },
      "EntitySummaryView": {
        "description": "A search hit: enough to recognise a company, no enrichment.\n\nDeliberately not an EntityView \u2014 search is an unbilled triage lookup over\nentities the caller has not been matched to, and returning the full golden\nrecord would make it a free enrichment endpoint.",
        "properties": {
          "domain": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Domain"
          },
          "entity_id": {
            "title": "Entity Id",
            "type": "string"
          },
          "legal_name": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Legal Name"
          }
        },
        "required": [
          "entity_id"
        ],
        "title": "EntitySummaryView",
        "type": "object"
      },
      "EntityView": {
        "properties": {
          "completeness": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/CompletenessReport"
              },
              {
                "type": "null"
              }
            ]
          },
          "created_at": {
            "anyOf": [
              {
                "format": "date-time",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Created At"
          },
          "entity_id": {
            "title": "Entity Id",
            "type": "string"
          },
          "field_status": {
            "additionalProperties": {
              "$ref": "#/components/schemas/FieldStatus"
            },
            "title": "Field Status",
            "type": "object"
          },
          "last_checked_at": {
            "anyOf": [
              {
                "format": "date-time",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Last Checked At"
          },
          "member_record_ids": {
            "items": {
              "type": "string"
            },
            "title": "Member Record Ids",
            "type": "array"
          },
          "provenance": {
            "additionalProperties": {
              "$ref": "#/components/schemas/ProvenanceView"
            },
            "title": "Provenance",
            "type": "object"
          },
          "record": {
            "additionalProperties": true,
            "title": "Record",
            "type": "object"
          },
          "requested_fields": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Requested Fields"
          },
          "stalest_field_age_days": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Stalest Field Age Days"
          },
          "updated_at": {
            "anyOf": [
              {
                "format": "date-time",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Updated At"
          }
        },
        "required": [
          "entity_id",
          "record",
          "provenance"
        ],
        "title": "EntityView",
        "type": "object"
      },
      "ErrorBody": {
        "properties": {
          "code": {
            "title": "Code",
            "type": "string"
          },
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "details": {
            "anyOf": [
              {
                "additionalProperties": {
                  "type": "string"
                },
                "type": "object"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Details"
          },
          "message": {
            "title": "Message",
            "type": "string"
          }
        },
        "required": [
          "code",
          "message",
          "correlation_id"
        ],
        "title": "ErrorBody",
        "type": "object"
      },
      "ErrorCodeValue": {
        "properties": {
          "description": {
            "title": "Description",
            "type": "string"
          },
          "status": {
            "title": "Status",
            "type": "integer"
          },
          "value": {
            "title": "Value",
            "type": "string"
          }
        },
        "required": [
          "value",
          "status",
          "description"
        ],
        "title": "ErrorCodeValue",
        "type": "object"
      },
      "ErrorCodesResponse": {
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "values": {
            "items": {
              "$ref": "#/components/schemas/ErrorCodeValue"
            },
            "title": "Values",
            "type": "array"
          }
        },
        "required": [
          "values",
          "correlation_id"
        ],
        "title": "ErrorCodesResponse",
        "type": "object"
      },
      "ErrorResponse": {
        "properties": {
          "error": {
            "$ref": "#/components/schemas/ErrorBody"
          }
        },
        "required": [
          "error"
        ],
        "title": "ErrorResponse",
        "type": "object"
      },
      "ErrorView": {
        "properties": {
          "code": {
            "title": "Code",
            "type": "string"
          },
          "message": {
            "title": "Message",
            "type": "string"
          }
        },
        "required": [
          "code",
          "message"
        ],
        "title": "ErrorView",
        "type": "object"
      },
      "EvaluationActivationRequest": {
        "additionalProperties": false,
        "properties": {
          "proof": {
            "maxLength": 4096,
            "minLength": 1,
            "title": "Proof",
            "type": "string"
          }
        },
        "required": [
          "proof"
        ],
        "title": "EvaluationActivationRequest",
        "type": "object"
      },
      "EvaluationActivationResponse": {
        "properties": {
          "api_origin": {
            "title": "Api Origin",
            "type": "string"
          },
          "capabilities": {
            "additionalProperties": true,
            "title": "Capabilities",
            "type": "object"
          },
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "evaluation": {
            "additionalProperties": true,
            "title": "Evaluation",
            "type": "object"
          },
          "grant_id": {
            "title": "Grant Id",
            "type": "string"
          },
          "key": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Key"
          },
          "key_already_issued": {
            "title": "Key Already Issued",
            "type": "boolean"
          },
          "key_id": {
            "title": "Key Id",
            "type": "string"
          },
          "key_shown_once": {
            "title": "Key Shown Once",
            "type": "boolean"
          },
          "mcp_origin": {
            "title": "Mcp Origin",
            "type": "string"
          },
          "recovery": {
            "title": "Recovery",
            "type": "string"
          },
          "retention": {
            "additionalProperties": true,
            "title": "Retention",
            "type": "object"
          },
          "smoke_test": {
            "additionalProperties": {
              "type": "string"
            },
            "title": "Smoke Test",
            "type": "object"
          },
          "tenant_id": {
            "title": "Tenant Id",
            "type": "string"
          }
        },
        "required": [
          "tenant_id",
          "grant_id",
          "key_id",
          "key_shown_once",
          "key_already_issued",
          "evaluation",
          "api_origin",
          "mcp_origin",
          "recovery",
          "capabilities",
          "correlation_id",
          "smoke_test",
          "retention"
        ],
        "title": "EvaluationActivationResponse",
        "type": "object"
      },
      "EvaluationResponse": {
        "description": "Credit-free lifetime entitlement and actual deployment capability discovery.",
        "properties": {
          "capabilities": {
            "additionalProperties": true,
            "title": "Capabilities",
            "type": "object"
          },
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "evaluation": {
            "anyOf": [
              {
                "additionalProperties": true,
                "type": "object"
              },
              {
                "type": "null"
              }
            ],
            "title": "Evaluation"
          },
          "evaluation_enforced": {
            "default": false,
            "title": "Evaluation Enforced",
            "type": "boolean"
          },
          "offer_status": {
            "default": "planned",
            "title": "Offer Status",
            "type": "string"
          }
        },
        "required": [
          "correlation_id"
        ],
        "title": "EvaluationResponse",
        "type": "object"
      },
      "EvidenceChainMetadata": {
        "additionalProperties": false,
        "description": "Retained citation links for admitted descriptive evidence, without page text.",
        "properties": {
          "claim_source_url": {
            "maxLength": 2048,
            "minLength": 8,
            "title": "Claim Source Url",
            "type": "string"
          },
          "identity_source_url": {
            "maxLength": 2048,
            "minLength": 8,
            "title": "Identity Source Url",
            "type": "string"
          },
          "method": {
            "enum": [
              "same_page",
              "registry_domain_and_first_party_anchor"
            ],
            "title": "Method",
            "type": "string"
          },
          "registry_source_url": {
            "anyOf": [
              {
                "maxLength": 2048,
                "minLength": 8,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Registry Source Url"
          },
          "subject_name": {
            "maxLength": 256,
            "minLength": 1,
            "title": "Subject Name",
            "type": "string"
          }
        },
        "required": [
          "method",
          "identity_source_url",
          "claim_source_url",
          "subject_name"
        ],
        "title": "EvidenceChainMetadata",
        "type": "object"
      },
      "EvidenceView": {
        "description": "One cited piece of evidence the decision was taken on.",
        "properties": {
          "licence": {
            "$ref": "#/components/schemas/LicenceTier"
          },
          "retrieved_at": {
            "format": "date-time",
            "title": "Retrieved At",
            "type": "string"
          },
          "source_id": {
            "title": "Source Id",
            "type": "string"
          },
          "source_kind": {
            "$ref": "#/components/schemas/SourceKind"
          },
          "summary": {
            "title": "Summary",
            "type": "string"
          },
          "url": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Url"
          }
        },
        "required": [
          "source_id",
          "source_kind",
          "licence",
          "summary",
          "retrieved_at"
        ],
        "title": "EvidenceView",
        "type": "object"
      },
      "FeatureContributionView": {
        "description": "One feature's log-odds contribution to the score.\n\n`contribution` is value x weight, which is what actually moved the\nprobability: the raw feature value alone does not say whether it argued for\nor against, nor by how much.",
        "properties": {
          "contribution": {
            "title": "Contribution",
            "type": "number"
          },
          "feature": {
            "title": "Feature",
            "type": "string"
          },
          "value": {
            "title": "Value",
            "type": "number"
          }
        },
        "required": [
          "feature",
          "value",
          "contribution"
        ],
        "title": "FeatureContributionView",
        "type": "object"
      },
      "FeedEvidence": {
        "additionalProperties": false,
        "properties": {
          "confidence": {
            "maximum": 1.0,
            "minimum": 0.0,
            "title": "Confidence",
            "type": "number"
          },
          "licence": {
            "$ref": "#/components/schemas/LicenceTier",
            "default": "pass_through"
          },
          "licence_reference": {
            "maxLength": 2000,
            "minLength": 1,
            "title": "Licence Reference",
            "type": "string"
          },
          "observed_at": {
            "format": "date-time",
            "title": "Observed At",
            "type": "string"
          },
          "provider": {
            "anyOf": [
              {
                "maxLength": 128,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Provider"
          },
          "provider_record_id": {
            "anyOf": [
              {
                "maxLength": 256,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Provider Record Id"
          },
          "source_url": {
            "format": "uri",
            "maxLength": 2083,
            "minLength": 1,
            "title": "Source Url",
            "type": "string"
          }
        },
        "required": [
          "source_url",
          "observed_at",
          "licence_reference",
          "confidence"
        ],
        "title": "FeedEvidence",
        "type": "object"
      },
      "FeedbackRequest": {
        "additionalProperties": false,
        "properties": {
          "rationale": {
            "maxLength": 4000,
            "minLength": 1,
            "title": "Rationale",
            "type": "string"
          },
          "report": {
            "enum": [
              "correct",
              "wrong"
            ],
            "title": "Report",
            "type": "string"
          },
          "source_uri": {
            "anyOf": [
              {
                "maxLength": 2000,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Source Uri"
          },
          "supersedes_label_id": {
            "anyOf": [
              {
                "maxLength": 64,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Supersedes Label Id"
          }
        },
        "required": [
          "report",
          "rationale"
        ],
        "title": "FeedbackRequest",
        "type": "object"
      },
      "FieldPack": {
        "properties": {
          "attributes": {
            "items": {
              "type": "string"
            },
            "title": "Attributes",
            "type": "array"
          },
          "description": {
            "title": "Description",
            "type": "string"
          },
          "name": {
            "title": "Name",
            "type": "string"
          }
        },
        "required": [
          "name",
          "description",
          "attributes"
        ],
        "title": "FieldPack",
        "type": "object"
      },
      "FieldStatus": {
        "properties": {
          "detail": {
            "title": "Detail",
            "type": "string"
          },
          "reason": {
            "title": "Reason",
            "type": "string"
          },
          "status": {
            "$ref": "#/components/schemas/FieldStatusCode"
          }
        },
        "required": [
          "status",
          "reason",
          "detail"
        ],
        "title": "FieldStatus",
        "type": "object"
      },
      "FieldStatusCode": {
        "enum": [
          "present",
          "not_supported",
          "not_configured",
          "source_unavailable",
          "not_checked",
          "licence_restricted"
        ],
        "title": "FieldStatusCode",
        "type": "string"
      },
      "FinancialComparisonRequest": {
        "additionalProperties": false,
        "properties": {
          "left_statement_id": {
            "maxLength": 128,
            "minLength": 1,
            "title": "Left Statement Id",
            "type": "string"
          },
          "right_statement_id": {
            "maxLength": 128,
            "minLength": 1,
            "title": "Right Statement Id",
            "type": "string"
          }
        },
        "required": [
          "left_statement_id",
          "right_statement_id"
        ],
        "title": "FinancialComparisonRequest",
        "type": "object"
      },
      "FinancialSelection": {
        "additionalProperties": false,
        "properties": {
          "period_end": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Period End"
          },
          "preferences": {
            "$ref": "#/components/schemas/StatementCriteria"
          },
          "relative_period": {
            "anyOf": [
              {
                "maximum": 20.0,
                "minimum": 0.0,
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Relative Period"
          },
          "requirements": {
            "$ref": "#/components/schemas/StatementCriteria"
          },
          "statement_id": {
            "anyOf": [
              {
                "maxLength": 128,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Statement Id"
          }
        },
        "title": "FinancialSelection",
        "type": "object"
      },
      "FinancialSelectionRequest": {
        "additionalProperties": false,
        "properties": {
          "capture": {
            "default": false,
            "title": "Capture",
            "type": "boolean"
          },
          "capture_id": {
            "anyOf": [
              {
                "maxLength": 64,
                "minLength": 1,
                "pattern": "^[A-Za-z0-9_-]+$",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Capture Id"
          },
          "selection": {
            "$ref": "#/components/schemas/FinancialSelection"
          }
        },
        "title": "FinancialSelectionRequest",
        "type": "object"
      },
      "GapStatus": {
        "description": "Why an identifier system came back with nothing.",
        "enum": [
          "not_found",
          "not_configured",
          "not_checked",
          "source_unavailable"
        ],
        "title": "GapStatus",
        "type": "string"
      },
      "HTTPValidationError": {
        "properties": {
          "detail": {
            "items": {
              "$ref": "#/components/schemas/ValidationError"
            },
            "title": "Detail",
            "type": "array"
          }
        },
        "title": "HTTPValidationError",
        "type": "object"
      },
      "IdentifierGapView": {
        "description": "An identifier system that produced nothing, and why.\n\nThe half a reference-data buyer needs as much as the positives: without it\nevery absent key looks like a system we forgot to ask, and \"GLEIF has no LEI\nfor this company\" is a finding, not a silence.",
        "properties": {
          "detail": {
            "title": "Detail",
            "type": "string"
          },
          "scheme": {
            "title": "Scheme",
            "type": "string"
          },
          "sources": {
            "items": {
              "type": "string"
            },
            "title": "Sources",
            "type": "array"
          },
          "status": {
            "$ref": "#/components/schemas/GapStatus"
          }
        },
        "required": [
          "scheme",
          "status",
          "detail"
        ],
        "title": "IdentifierGapView",
        "type": "object"
      },
      "IdentifierSchemeValue": {
        "properties": {
          "available": {
            "title": "Available",
            "type": "boolean"
          },
          "description": {
            "title": "Description",
            "type": "string"
          },
          "scheme": {
            "title": "Scheme",
            "type": "string"
          },
          "sources": {
            "items": {
              "type": "string"
            },
            "title": "Sources",
            "type": "array"
          }
        },
        "required": [
          "scheme",
          "description",
          "sources",
          "available"
        ],
        "title": "IdentifierSchemeValue",
        "type": "object"
      },
      "IdentifierSchemesResponse": {
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "note": {
            "title": "Note",
            "type": "string"
          },
          "values": {
            "items": {
              "$ref": "#/components/schemas/IdentifierSchemeValue"
            },
            "title": "Values",
            "type": "array"
          }
        },
        "required": [
          "values",
          "note",
          "correlation_id"
        ],
        "title": "IdentifierSchemesResponse",
        "type": "object"
      },
      "IdentifierView": {
        "description": "One identifier, with the citation for that identifier specifically.\n\nNot the entity's provenance and not the crosswalk fact's single citation:\na caller joining a trade file across three systems has to be able to say\nwhere each individual value came from, how fresh it is and whether their\nplan lets them redistribute it.",
        "properties": {
          "attribute": {
            "title": "Attribute",
            "type": "string"
          },
          "provenance": {
            "$ref": "#/components/schemas/ProvenanceView"
          },
          "qualifier": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Qualifier"
          },
          "scheme": {
            "title": "Scheme",
            "type": "string"
          },
          "value": {
            "title": "Value",
            "type": "string"
          }
        },
        "required": [
          "scheme",
          "value",
          "attribute",
          "provenance"
        ],
        "title": "IdentifierView",
        "type": "object"
      },
      "IdentityAliasView": {
        "properties": {
          "name": {
            "title": "Name",
            "type": "string"
          },
          "provenance": {
            "$ref": "#/components/schemas/ProvenanceView"
          },
          "role": {
            "enum": [
              "legal",
              "trading",
              "former"
            ],
            "title": "Role",
            "type": "string"
          },
          "valid_from": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Valid From"
          },
          "valid_to": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Valid To"
          }
        },
        "required": [
          "name",
          "role",
          "provenance"
        ],
        "title": "IdentityAliasView",
        "type": "object"
      },
      "IdentityGap": {
        "properties": {
          "code": {
            "title": "Code",
            "type": "string"
          },
          "detail": {
            "title": "Detail",
            "type": "string"
          }
        },
        "required": [
          "code",
          "detail"
        ],
        "title": "IdentityGap",
        "type": "object"
      },
      "IdentityLocationView": {
        "properties": {
          "address": {
            "title": "Address",
            "type": "string"
          },
          "label": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Label"
          },
          "operating_asserted": {
            "title": "Operating Asserted",
            "type": "boolean"
          },
          "provenance": {
            "$ref": "#/components/schemas/ProvenanceView"
          },
          "role": {
            "enum": [
              "registered",
              "headquarters",
              "mailing",
              "operating"
            ],
            "title": "Role",
            "type": "string"
          },
          "site_id": {
            "title": "Site Id",
            "type": "string"
          },
          "valid_from": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Valid From"
          },
          "valid_to": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Valid To"
          }
        },
        "required": [
          "site_id",
          "role",
          "address",
          "operating_asserted",
          "provenance"
        ],
        "title": "IdentityLocationView",
        "type": "object"
      },
      "IdentityProfileView": {
        "properties": {
          "aliases": {
            "items": {
              "$ref": "#/components/schemas/IdentityAliasView"
            },
            "title": "Aliases",
            "type": "array"
          },
          "as_of": {
            "format": "date",
            "title": "As Of",
            "type": "string"
          },
          "conflicting_authorities": {
            "items": {
              "type": "string"
            },
            "title": "Conflicting Authorities",
            "type": "array"
          },
          "entity_id": {
            "title": "Entity Id",
            "type": "string"
          },
          "gaps": {
            "items": {
              "$ref": "#/components/schemas/IdentityGap"
            },
            "title": "Gaps",
            "type": "array"
          },
          "globally_verified": {
            "const": false,
            "default": false,
            "title": "Globally Verified",
            "type": "boolean"
          },
          "locations": {
            "items": {
              "$ref": "#/components/schemas/IdentityLocationView"
            },
            "title": "Locations",
            "type": "array"
          },
          "public_id_contract": {
            "const": "registry-anchor-v1",
            "default": "registry-anchor-v1",
            "title": "Public Id Contract",
            "type": "string"
          },
          "public_ids": {
            "items": {
              "$ref": "#/components/schemas/PublicIdentityAnchorView"
            },
            "title": "Public Ids",
            "type": "array"
          }
        },
        "required": [
          "entity_id",
          "as_of"
        ],
        "title": "IdentityProfileView",
        "type": "object"
      },
      "IdentityResponse": {
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "identity": {
            "$ref": "#/components/schemas/IdentityProfileView"
          },
          "usage": {
            "$ref": "#/components/schemas/UsageView"
          }
        },
        "required": [
          "identity",
          "correlation_id",
          "usage"
        ],
        "title": "IdentityResponse",
        "type": "object"
      },
      "IndividualOwnerView": {
        "description": "A named person the register lists as a controller.\n\nName and control only. Date of birth and nationality are personal\nidentifiers ADR-0005 keeps out of storage, so there is deliberately no field\nhere that could carry them.",
        "properties": {
          "ceased_on": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Ceased On"
          },
          "name": {
            "title": "Name",
            "type": "string"
          },
          "natures_of_control": {
            "items": {
              "type": "string"
            },
            "title": "Natures Of Control",
            "type": "array"
          },
          "notified_on": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Notified On"
          }
        },
        "required": [
          "name"
        ],
        "title": "IndividualOwnerView",
        "type": "object"
      },
      "InstallTicketResponse": {
        "description": "The one and only response carrying a raw install ticket.\n\nSame rule as a minted API key: only the digest is stored, so this value\ncannot be re-read. It is single-use and expires in minutes, so the remedy\nfor a lost one is to mint another rather than to recover it.",
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "expires_at": {
            "format": "date-time",
            "title": "Expires At",
            "type": "string"
          },
          "install_ticket": {
            "title": "Install Ticket",
            "type": "string"
          },
          "tenant_id": {
            "title": "Tenant Id",
            "type": "string"
          },
          "ticket_id": {
            "title": "Ticket Id",
            "type": "string"
          }
        },
        "required": [
          "ticket_id",
          "tenant_id",
          "install_ticket",
          "expires_at",
          "correlation_id"
        ],
        "title": "InstallTicketResponse",
        "type": "object"
      },
      "IntelligenceResponse": {
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "entity": {
            "$ref": "#/components/schemas/EntityView"
          },
          "evaluated_at": {
            "format": "date-time",
            "title": "Evaluated At",
            "type": "string"
          },
          "local_sources": {
            "items": {
              "additionalProperties": true,
              "type": "object"
            },
            "title": "Local Sources",
            "type": "array"
          },
          "note": {
            "default": "Current stored facts and configured local observations only. No paid calls or writes. Read each field's source date, scope, methodology and rights; missing is not zero. Source refresh does not guarantee new company observations.",
            "title": "Note",
            "type": "string"
          }
        },
        "required": [
          "entity",
          "evaluated_at",
          "local_sources",
          "correlation_id"
        ],
        "title": "IntelligenceResponse",
        "type": "object"
      },
      "IntervalView": {
        "description": "A rate reported with its 95% Wilson interval and the sample behind it.\n\n`point` alone is not evidence: an automation rate of 1.0 over nine calls and\none over nine thousand are the same number and not the same claim. The\ninterval is what makes a figure quotable in a renewal conversation.",
        "properties": {
          "high": {
            "title": "High",
            "type": "number"
          },
          "low": {
            "title": "Low",
            "type": "number"
          },
          "point": {
            "title": "Point",
            "type": "number"
          },
          "successes": {
            "title": "Successes",
            "type": "integer"
          },
          "trials": {
            "title": "Trials",
            "type": "integer"
          }
        },
        "required": [
          "point",
          "low",
          "high",
          "successes",
          "trials"
        ],
        "title": "IntervalView",
        "type": "object"
      },
      "InvestigationList": {
        "properties": {
          "items": {
            "items": {
              "$ref": "#/components/schemas/InvestigationView"
            },
            "title": "Items",
            "type": "array"
          },
          "limit": {
            "title": "Limit",
            "type": "integer"
          },
          "offset": {
            "title": "Offset",
            "type": "integer"
          }
        },
        "required": [
          "items",
          "limit",
          "offset"
        ],
        "title": "InvestigationList",
        "type": "object"
      },
      "InvestigationView": {
        "properties": {
          "created_at": {
            "format": "date-time",
            "title": "Created At",
            "type": "string"
          },
          "decisions": {
            "items": {
              "$ref": "#/components/schemas/DecisionView"
            },
            "title": "Decisions",
            "type": "array"
          },
          "error": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ErrorView"
              },
              {
                "type": "null"
              }
            ]
          },
          "followup_count": {
            "title": "Followup Count",
            "type": "integer"
          },
          "has_more_messages": {
            "default": false,
            "title": "Has More Messages",
            "type": "boolean"
          },
          "id": {
            "title": "Id",
            "type": "string"
          },
          "max_followups": {
            "title": "Max Followups",
            "type": "integer"
          },
          "messages": {
            "items": {
              "$ref": "#/components/schemas/MessageView"
            },
            "title": "Messages",
            "type": "array"
          },
          "messages_after": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Messages After"
          },
          "provider_status": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Provider Status"
          },
          "review": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ReviewItemView"
              },
              {
                "type": "null"
              }
            ]
          },
          "review_id": {
            "title": "Review Id",
            "type": "string"
          },
          "status": {
            "title": "Status",
            "type": "string"
          },
          "turn_status": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Turn Status"
          },
          "updated_at": {
            "format": "date-time",
            "title": "Updated At",
            "type": "string"
          }
        },
        "required": [
          "id",
          "review_id",
          "status",
          "created_at",
          "updated_at",
          "followup_count",
          "max_followups"
        ],
        "title": "InvestigationView",
        "type": "object"
      },
      "IssuedKeyResponse": {
        "description": "The one and only response that ever carries a raw key.\n\n`api_key` is shown here and never again \u2014 it is not stored, so it cannot be\nre-read, only rotated. Callers must persist it at this moment or lose it.",
        "properties": {
          "api_key": {
            "title": "Api Key",
            "type": "string"
          },
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "key": {
            "$ref": "#/components/schemas/ApiKeyView"
          }
        },
        "required": [
          "key",
          "api_key",
          "correlation_id"
        ],
        "title": "IssuedKeyResponse",
        "type": "object"
      },
      "JurisdictionValue": {
        "properties": {
          "name": {
            "title": "Name",
            "type": "string"
          },
          "registry": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Registry"
          },
          "registry_backed": {
            "title": "Registry Backed",
            "type": "boolean"
          },
          "value": {
            "title": "Value",
            "type": "string"
          }
        },
        "required": [
          "value",
          "name",
          "registry_backed"
        ],
        "title": "JurisdictionValue",
        "type": "object"
      },
      "JurisdictionsResponse": {
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "note": {
            "title": "Note",
            "type": "string"
          },
          "values": {
            "items": {
              "$ref": "#/components/schemas/JurisdictionValue"
            },
            "title": "Values",
            "type": "array"
          }
        },
        "required": [
          "values",
          "note",
          "correlation_id"
        ],
        "title": "JurisdictionsResponse",
        "type": "object"
      },
      "LabelDecisionSnapshot": {
        "description": "Server-derived prediction state frozen beside a ground-truth label.\n\nThis is what makes a label export directly evaluable. A caller may name a\ndecision id, but never supplies these values: they are copied from the\ntenant-scoped decision receipt, or from the review item's original\nabstention context. Null means no stored prediction existed, not that the\nprediction was empty.",
        "properties": {
          "decided_at": {
            "format": "date-time",
            "title": "Decided At",
            "type": "string"
          },
          "decision_id": {
            "maxLength": 64,
            "minLength": 1,
            "title": "Decision Id",
            "type": "string"
          },
          "decision_stage": {
            "$ref": "#/components/schemas/DecisionStage"
          },
          "features": {
            "additionalProperties": {
              "type": "number"
            },
            "title": "Features",
            "type": "object"
          },
          "match_confidence": {
            "anyOf": [
              {
                "maximum": 1.0,
                "minimum": 0.0,
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Match Confidence"
          },
          "match_confidence_basis": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ConfidenceBasis"
              },
              {
                "type": "null"
              }
            ]
          },
          "match_confidence_source": {
            "$ref": "#/components/schemas/SnapshotConfidenceSource"
          },
          "model_id": {
            "anyOf": [
              {
                "maxLength": 255,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Model Id"
          },
          "pipeline_version": {
            "maxLength": 64,
            "minLength": 1,
            "title": "Pipeline Version",
            "type": "string"
          },
          "predicted_decision": {
            "$ref": "#/components/schemas/MatchDecisionType"
          },
          "probability": {
            "anyOf": [
              {
                "maximum": 1.0,
                "minimum": 0.0,
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Probability"
          },
          "prompt_version": {
            "anyOf": [
              {
                "maxLength": 255,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Prompt Version"
          },
          "right_ref": {
            "maxLength": 255,
            "minLength": 1,
            "title": "Right Ref",
            "type": "string"
          },
          "scorer_version": {
            "anyOf": [
              {
                "maxLength": 64,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Scorer Version"
          },
          "thresholds": {
            "additionalProperties": {
              "type": "number"
            },
            "title": "Thresholds",
            "type": "object"
          }
        },
        "required": [
          "decision_id",
          "right_ref",
          "predicted_decision",
          "decision_stage",
          "match_confidence_source",
          "pipeline_version",
          "decided_at"
        ],
        "title": "LabelDecisionSnapshot",
        "type": "object"
      },
      "LabelProvenance": {
        "description": "Immutable attribution for one label event.\n\n``source_event_id`` is the producer's idempotency key.  Together with\ntenant and source it names one real-world labelling event, so retrying an\nimport cannot silently create a second training example.  ``acting_key_id``\nis server-derived on API and review paths; it must never be accepted from a\nrequest body.",
        "properties": {
          "acting_key_id": {
            "anyOf": [
              {
                "maxLength": 64,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Acting Key Id"
          },
          "actor_id": {
            "maxLength": 255,
            "minLength": 1,
            "title": "Actor Id",
            "type": "string"
          },
          "rationale": {
            "anyOf": [
              {
                "maxLength": 4000,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Rationale"
          },
          "source_event_id": {
            "maxLength": 255,
            "minLength": 1,
            "title": "Source Event Id",
            "type": "string"
          },
          "source_uri": {
            "anyOf": [
              {
                "maxLength": 2000,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Source Uri"
          }
        },
        "required": [
          "source_event_id",
          "actor_id"
        ],
        "title": "LabelProvenance",
        "type": "object"
      },
      "LicenceTier": {
        "description": "Legal storability of a fact (ADR-0004).\n\nOPEN: public-domain / open-licensed / self-derived \u2014 storable and resellable.\nLICENSED: storable during an active data licence (e.g. PDL data licence).\nPASS_THROUGH: contractually prohibited from warehousing \u2014 return-only.",
        "enum": [
          "open",
          "licensed",
          "pass_through"
        ],
        "title": "LicenceTier",
        "type": "string"
      },
      "LimitsResponse": {
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "deployment_replicas": {
            "title": "Deployment Replicas",
            "type": "integer"
          },
          "max_batch_deep_comparisons": {
            "title": "Max Batch Deep Comparisons",
            "type": "integer"
          },
          "max_batch_size": {
            "title": "Max Batch Size",
            "type": "integer"
          },
          "max_concurrent_deep_resolutions_deployment": {
            "title": "Max Concurrent Deep Resolutions Deployment",
            "type": "integer"
          },
          "max_concurrent_deep_resolutions_per_replica": {
            "title": "Max Concurrent Deep Resolutions Per Replica",
            "type": "integer"
          },
          "max_page_size": {
            "title": "Max Page Size",
            "type": "integer"
          },
          "max_request_bytes": {
            "title": "Max Request Bytes",
            "type": "integer"
          },
          "max_request_seconds": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Max Request Seconds"
          },
          "plan": {
            "title": "Plan",
            "type": "string"
          },
          "rate_limit_multiplier": {
            "title": "Rate Limit Multiplier",
            "type": "number"
          },
          "rate_limits": {
            "items": {
              "$ref": "#/components/schemas/RateLimitValue"
            },
            "title": "Rate Limits",
            "type": "array"
          },
          "resale_rights": {
            "title": "Resale Rights",
            "type": "boolean"
          }
        },
        "required": [
          "rate_limits",
          "plan",
          "rate_limit_multiplier",
          "resale_rights",
          "max_batch_size",
          "max_page_size",
          "max_request_bytes",
          "max_request_seconds",
          "max_batch_deep_comparisons",
          "deployment_replicas",
          "max_concurrent_deep_resolutions_per_replica",
          "max_concurrent_deep_resolutions_deployment",
          "correlation_id"
        ],
        "title": "LimitsResponse",
        "type": "object"
      },
      "MarketCapGap": {
        "additionalProperties": false,
        "properties": {
          "code": {
            "title": "Code",
            "type": "string"
          },
          "detail": {
            "title": "Detail",
            "type": "string"
          },
          "source_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Source Id"
          }
        },
        "required": [
          "code",
          "detail"
        ],
        "title": "MarketCapGap",
        "type": "object"
      },
      "MarketCapHistoryResponse": {
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "history": {
            "$ref": "#/components/schemas/MarketCapHistoryView"
          },
          "usage": {
            "$ref": "#/components/schemas/UsageView"
          }
        },
        "required": [
          "history",
          "correlation_id",
          "usage"
        ],
        "title": "MarketCapHistoryResponse",
        "type": "object"
      },
      "MarketCapHistoryView": {
        "additionalProperties": false,
        "properties": {
          "as_of": {
            "format": "date",
            "title": "As Of",
            "type": "string"
          },
          "available_months": {
            "title": "Available Months",
            "type": "integer"
          },
          "complete": {
            "title": "Complete",
            "type": "boolean"
          },
          "convention": {
            "const": "month_end",
            "default": "month_end",
            "title": "Convention",
            "type": "string"
          },
          "currency": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Currency"
          },
          "entity_id": {
            "title": "Entity Id",
            "type": "string"
          },
          "external_lookup_performed": {
            "const": false,
            "default": false,
            "title": "External Lookup Performed",
            "type": "boolean"
          },
          "gaps": {
            "default": [],
            "items": {
              "$ref": "#/components/schemas/MarketCapGap"
            },
            "title": "Gaps",
            "type": "array"
          },
          "months": {
            "title": "Months",
            "type": "integer"
          },
          "note": {
            "default": "Completed calendar months before the as_of month, using source-asserted month-end closes only. Values are base currency units. No interpolation, forward fill, currency conversion, share-class aggregation or provider calls. Complete describes this requested local window, not global data coverage.",
            "title": "Note",
            "type": "string"
          },
          "publication_date_policy": {
            "default": "Actual source publication timestamps are returned when supplied; an unknown publication date stays null. Calendar month-end is a valuation reference, not an invented publication timestamp.",
            "title": "Publication Date Policy",
            "type": "string"
          },
          "rows": {
            "items": {
              "$ref": "#/components/schemas/MarketCapMonthView"
            },
            "title": "Rows",
            "type": "array"
          },
          "scope": {
            "enum": [
              "issuer",
              "share_class"
            ],
            "title": "Scope",
            "type": "string"
          },
          "share_class": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Share Class"
          },
          "status": {
            "enum": [
              "available",
              "partial",
              "unavailable"
            ],
            "title": "Status",
            "type": "string"
          },
          "window_end": {
            "format": "date",
            "title": "Window End",
            "type": "string"
          },
          "window_start": {
            "format": "date",
            "title": "Window Start",
            "type": "string"
          }
        },
        "required": [
          "entity_id",
          "as_of",
          "months",
          "window_start",
          "window_end",
          "status",
          "available_months",
          "complete",
          "scope",
          "rows"
        ],
        "title": "MarketCapHistoryView",
        "type": "object"
      },
      "MarketCapMonthView": {
        "properties": {
          "notes": {
            "items": {
              "type": "string"
            },
            "title": "Notes",
            "type": "array"
          },
          "observations": {
            "items": {
              "$ref": "#/components/schemas/MarketCapObservationView"
            },
            "title": "Observations",
            "type": "array"
          },
          "reference_date": {
            "format": "date",
            "title": "Reference Date",
            "type": "string"
          },
          "selected": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/MarketCapObservationView"
              },
              {
                "type": "null"
              }
            ]
          },
          "status": {
            "enum": [
              "available",
              "missing",
              "conflicting",
              "stale",
              "ineligible"
            ],
            "title": "Status",
            "type": "string"
          },
          "truncated": {
            "default": false,
            "title": "Truncated",
            "type": "boolean"
          }
        },
        "required": [
          "reference_date",
          "status"
        ],
        "title": "MarketCapMonthView",
        "type": "object"
      },
      "MarketCapObservationView": {
        "properties": {
          "basis": {
            "default": "reported",
            "enum": [
              "reported",
              "derived"
            ],
            "title": "Basis",
            "type": "string"
          },
          "calculated_at": {
            "anyOf": [
              {
                "format": "date-time",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Calculated At"
          },
          "captured_at": {
            "format": "date-time",
            "title": "Captured At",
            "type": "string"
          },
          "currency": {
            "title": "Currency",
            "type": "string"
          },
          "input_evidence": {
            "items": {
              "$ref": "#/components/schemas/ValuationInputEvidence"
            },
            "title": "Input Evidence",
            "type": "array"
          },
          "methodology": {
            "title": "Methodology",
            "type": "string"
          },
          "observation_id": {
            "title": "Observation Id",
            "type": "string"
          },
          "price_basis": {
            "enum": [
              "unadjusted",
              "adjusted",
              "unknown"
            ],
            "title": "Price Basis",
            "type": "string"
          },
          "provenance": {
            "$ref": "#/components/schemas/ProvenanceView"
          },
          "published_at": {
            "anyOf": [
              {
                "format": "date-time",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Published At"
          },
          "reference_date": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Reference Date"
          },
          "scope": {
            "enum": [
              "issuer",
              "share_class"
            ],
            "title": "Scope",
            "type": "string"
          },
          "share_class": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Share Class"
          },
          "valuation_at": {
            "format": "date-time",
            "title": "Valuation At",
            "type": "string"
          },
          "valuation_date": {
            "format": "date",
            "title": "Valuation Date",
            "type": "string"
          },
          "value": {
            "title": "Value",
            "type": "number"
          }
        },
        "required": [
          "observation_id",
          "value",
          "currency",
          "scope",
          "valuation_at",
          "valuation_date",
          "captured_at",
          "price_basis",
          "methodology",
          "provenance"
        ],
        "title": "MarketCapObservationView",
        "type": "object"
      },
      "MatchDecisionType": {
        "enum": [
          "match",
          "new_entity",
          "no_match",
          "unresolved"
        ],
        "title": "MatchDecisionType",
        "type": "string"
      },
      "MatchRequest": {
        "additionalProperties": false,
        "properties": {
          "depth": {
            "$ref": "#/components/schemas/ResolutionDepth",
            "default": "research"
          },
          "left": {
            "$ref": "#/components/schemas/ResolveRequest"
          },
          "right": {
            "$ref": "#/components/schemas/ResolveRequest"
          }
        },
        "required": [
          "left",
          "right"
        ],
        "title": "MatchRequest",
        "type": "object"
      },
      "MatchResponse": {
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "decision": {
            "$ref": "#/components/schemas/MatchDecisionType"
          },
          "depth_capped": {
            "default": false,
            "title": "Depth Capped",
            "type": "boolean"
          },
          "escalation_unavailable": {
            "default": false,
            "title": "Escalation Unavailable",
            "type": "boolean"
          },
          "match_confidence": {
            "default": 0.0,
            "maximum": 1.0,
            "minimum": 0.0,
            "title": "Match Confidence",
            "type": "number"
          },
          "match_confidence_basis": {
            "$ref": "#/components/schemas/ConfidenceBasis",
            "default": "no_binding"
          },
          "no_identifying_signal": {
            "default": false,
            "title": "No Identifying Signal",
            "type": "boolean"
          },
          "probability": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Probability"
          },
          "rationale": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Rationale"
          },
          "stage": {
            "$ref": "#/components/schemas/DecisionStage"
          },
          "usage": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/UsageView"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "required": [
          "decision",
          "stage",
          "correlation_id"
        ],
        "title": "MatchResponse",
        "type": "object"
      },
      "MemberRequest": {
        "additionalProperties": false,
        "properties": {
          "customer_reference": {
            "anyOf": [
              {
                "maxLength": 256,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Customer Reference"
          },
          "role": {
            "anyOf": [
              {
                "maxLength": 64,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Role"
          }
        },
        "title": "MemberRequest",
        "type": "object"
      },
      "MessageView": {
        "properties": {
          "id": {
            "title": "Id",
            "type": "string"
          },
          "role": {
            "enum": [
              "user",
              "assistant"
            ],
            "title": "Role",
            "type": "string"
          },
          "text": {
            "title": "Text",
            "type": "string"
          }
        },
        "required": [
          "id",
          "role",
          "text"
        ],
        "title": "MessageView",
        "type": "object"
      },
      "OAuthGrantListResponse": {
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "grants": {
            "items": {
              "$ref": "#/components/schemas/OAuthGrantView"
            },
            "title": "Grants",
            "type": "array"
          }
        },
        "required": [
          "grants",
          "correlation_id"
        ],
        "title": "OAuthGrantListResponse",
        "type": "object"
      },
      "OAuthGrantView": {
        "description": "One live connector authorization, as the tenant's administrator sees it.",
        "properties": {
          "client_id": {
            "title": "Client Id",
            "type": "string"
          },
          "client_name": {
            "title": "Client Name",
            "type": "string"
          },
          "created_at": {
            "format": "date-time",
            "title": "Created At",
            "type": "string"
          },
          "grant_id": {
            "title": "Grant Id",
            "type": "string"
          },
          "scopes": {
            "items": {
              "type": "string"
            },
            "title": "Scopes",
            "type": "array"
          },
          "tenant_id": {
            "title": "Tenant Id",
            "type": "string"
          }
        },
        "required": [
          "grant_id",
          "client_id",
          "client_name",
          "tenant_id",
          "scopes",
          "created_at"
        ],
        "title": "OAuthGrantView",
        "type": "object"
      },
      "ObservedControllerView": {
        "properties": {
          "entity_id": {
            "title": "Entity Id",
            "type": "string"
          },
          "evidence": {
            "items": {
              "$ref": "#/components/schemas/OwnershipPathEdgeView"
            },
            "title": "Evidence",
            "type": "array"
          },
          "identifiers": {
            "items": {
              "$ref": "#/components/schemas/OrganizationIdentifier"
            },
            "title": "Identifiers",
            "type": "array"
          },
          "name": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Name"
          },
          "path": {
            "items": {
              "type": "string"
            },
            "title": "Path",
            "type": "array"
          },
          "path_relationships": {
            "items": {
              "type": "string"
            },
            "title": "Path Relationships",
            "type": "array"
          },
          "valid_from": {
            "format": "date",
            "title": "Valid From",
            "type": "string"
          },
          "valid_to": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Valid To"
          }
        },
        "required": [
          "entity_id",
          "name",
          "identifiers",
          "path",
          "path_relationships",
          "valid_from",
          "evidence"
        ],
        "title": "ObservedControllerView",
        "type": "object"
      },
      "OrganizationIdentifier": {
        "additionalProperties": false,
        "properties": {
          "qualifier": {
            "anyOf": [
              {
                "maxLength": 200,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Qualifier"
          },
          "scheme": {
            "enum": [
              "lei",
              "company_number"
            ],
            "title": "Scheme",
            "type": "string"
          },
          "value": {
            "maxLength": 200,
            "minLength": 1,
            "title": "Value",
            "type": "string"
          }
        },
        "required": [
          "scheme",
          "value"
        ],
        "title": "OrganizationIdentifier",
        "type": "object"
      },
      "OrganizationalUltimateOwnerView": {
        "properties": {
          "control_basis": {
            "enum": [
              "share_ownership",
              "control"
            ],
            "title": "Control Basis",
            "type": "string"
          },
          "identifiers": {
            "items": {
              "$ref": "#/components/schemas/OrganizationIdentifier"
            },
            "title": "Identifiers",
            "type": "array"
          },
          "name": {
            "title": "Name",
            "type": "string"
          },
          "owner_type": {
            "const": "organization",
            "default": "organization",
            "title": "Owner Type",
            "type": "string"
          },
          "provenance": {
            "$ref": "#/components/schemas/ProvenanceView"
          },
          "source_entity_id": {
            "title": "Source Entity Id",
            "type": "string"
          },
          "valid_from": {
            "format": "date",
            "title": "Valid From",
            "type": "string"
          },
          "valid_to": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Valid To"
          }
        },
        "required": [
          "name",
          "identifiers",
          "control_basis",
          "source_entity_id",
          "valid_from",
          "provenance"
        ],
        "title": "OrganizationalUltimateOwnerView",
        "type": "object"
      },
      "OwnershipEdgeView": {
        "properties": {
          "attribute": {
            "title": "Attribute",
            "type": "string"
          },
          "depth": {
            "title": "Depth",
            "type": "integer"
          },
          "provenance": {
            "$ref": "#/components/schemas/ProvenanceView"
          },
          "qualifier": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Qualifier"
          },
          "relationship": {
            "title": "Relationship",
            "type": "string"
          },
          "relationship_basis": {
            "default": "control",
            "title": "Relationship Basis",
            "type": "string"
          },
          "scheme": {
            "title": "Scheme",
            "type": "string"
          },
          "source_entity_id": {
            "title": "Source Entity Id",
            "type": "string"
          },
          "target_entity_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Target Entity Id"
          },
          "valid_from": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Valid From"
          },
          "valid_to": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Valid To"
          },
          "value": {
            "title": "Value",
            "type": "string"
          }
        },
        "required": [
          "source_entity_id",
          "relationship",
          "scheme",
          "value",
          "attribute",
          "depth",
          "provenance"
        ],
        "title": "OwnershipEdgeView",
        "type": "object"
      },
      "OwnershipLinkView": {
        "description": "One ownership edge, cited. The parent is named by LEI and not resolved.",
        "properties": {
          "attribute": {
            "title": "Attribute",
            "type": "string"
          },
          "provenance": {
            "$ref": "#/components/schemas/ProvenanceView"
          },
          "relationship": {
            "title": "Relationship",
            "type": "string"
          },
          "scheme": {
            "title": "Scheme",
            "type": "string"
          },
          "value": {
            "title": "Value",
            "type": "string"
          }
        },
        "required": [
          "relationship",
          "scheme",
          "value",
          "attribute",
          "provenance"
        ],
        "title": "OwnershipLinkView",
        "type": "object"
      },
      "OwnershipNextStepView": {
        "properties": {
          "action": {
            "enum": [
              "resolve_identifier",
              "review_evidence"
            ],
            "title": "Action",
            "type": "string"
          },
          "entity_id": {
            "title": "Entity Id",
            "type": "string"
          },
          "provenance": {
            "$ref": "#/components/schemas/ProvenanceView"
          },
          "reason": {
            "title": "Reason",
            "type": "string"
          },
          "relationship": {
            "title": "Relationship",
            "type": "string"
          },
          "suggested_resolve": {
            "anyOf": [
              {
                "additionalProperties": {
                  "type": "string"
                },
                "type": "object"
              },
              {
                "type": "null"
              }
            ],
            "title": "Suggested Resolve"
          }
        },
        "required": [
          "entity_id",
          "relationship",
          "action",
          "reason",
          "provenance"
        ],
        "title": "OwnershipNextStepView",
        "type": "object"
      },
      "OwnershipNodeView": {
        "properties": {
          "depth": {
            "title": "Depth",
            "type": "integer"
          },
          "entity_id": {
            "title": "Entity Id",
            "type": "string"
          },
          "identifiers": {
            "items": {
              "$ref": "#/components/schemas/IdentifierView"
            },
            "title": "Identifiers",
            "type": "array"
          },
          "legal_name": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Legal Name"
          }
        },
        "required": [
          "entity_id",
          "depth"
        ],
        "title": "OwnershipNodeView",
        "type": "object"
      },
      "OwnershipPathEdgeView": {
        "properties": {
          "provenance": {
            "$ref": "#/components/schemas/ProvenanceView"
          },
          "qualifier": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Qualifier"
          },
          "relationship": {
            "const": "corporate_controller",
            "default": "corporate_controller",
            "title": "Relationship",
            "type": "string"
          },
          "relationship_basis": {
            "const": "control",
            "default": "control",
            "title": "Relationship Basis",
            "type": "string"
          },
          "scheme": {
            "title": "Scheme",
            "type": "string"
          },
          "source_entity_id": {
            "title": "Source Entity Id",
            "type": "string"
          },
          "target_entity_id": {
            "title": "Target Entity Id",
            "type": "string"
          },
          "valid_from": {
            "format": "date",
            "title": "Valid From",
            "type": "string"
          },
          "valid_to": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Valid To"
          },
          "value": {
            "title": "Value",
            "type": "string"
          }
        },
        "required": [
          "source_entity_id",
          "target_entity_id",
          "scheme",
          "value",
          "valid_from",
          "provenance"
        ],
        "title": "OwnershipPathEdgeView",
        "type": "object"
      },
      "OwnershipPlanResponse": {
        "properties": {
          "as_of": {
            "format": "date",
            "title": "As Of",
            "type": "string"
          },
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "coverage_complete": {
            "const": false,
            "default": false,
            "title": "Coverage Complete",
            "type": "boolean"
          },
          "entity_id": {
            "title": "Entity Id",
            "type": "string"
          },
          "external_lookup_performed": {
            "const": false,
            "default": false,
            "title": "External Lookup Performed",
            "type": "boolean"
          },
          "local_graph_complete": {
            "title": "Local Graph Complete",
            "type": "boolean"
          },
          "max_hops": {
            "title": "Max Hops",
            "type": "integer"
          },
          "next_steps": {
            "items": {
              "$ref": "#/components/schemas/OwnershipNextStepView"
            },
            "title": "Next Steps",
            "type": "array"
          },
          "remaining_gaps": {
            "items": {
              "$ref": "#/components/schemas/IdentityGap"
            },
            "title": "Remaining Gaps",
            "type": "array"
          },
          "usage": {
            "$ref": "#/components/schemas/UsageView"
          }
        },
        "required": [
          "entity_id",
          "as_of",
          "max_hops",
          "local_graph_complete",
          "next_steps",
          "remaining_gaps",
          "correlation_id",
          "usage"
        ],
        "title": "OwnershipPlanResponse",
        "type": "object"
      },
      "OwnershipView": {
        "description": "Bounded, tenant-local ownership over facts the entity already holds.\n\n`max_hops` is caller-configurable from 1 to 10. Local traversal completeness\nnever establishes global beneficial-ownership coverage; accounting\nconsolidation remains distinct from share ownership and control.",
        "properties": {
          "as_of": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "As Of"
          },
          "corporate_owners": {
            "items": {
              "$ref": "#/components/schemas/CorporateOwnerView"
            },
            "title": "Corporate Owners",
            "type": "array"
          },
          "coverage_complete": {
            "default": false,
            "title": "Coverage Complete",
            "type": "boolean"
          },
          "cycles": {
            "items": {
              "$ref": "#/components/schemas/resolvd__api__schemas__OwnershipCycleView"
            },
            "title": "Cycles",
            "type": "array"
          },
          "direct_parent": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/OwnershipLinkView"
              },
              {
                "type": "null"
              }
            ]
          },
          "edges": {
            "items": {
              "$ref": "#/components/schemas/OwnershipEdgeView"
            },
            "title": "Edges",
            "type": "array"
          },
          "external_lookup_performed": {
            "default": false,
            "title": "External Lookup Performed",
            "type": "boolean"
          },
          "hops_attempted": {
            "default": 0,
            "title": "Hops Attempted",
            "type": "integer"
          },
          "hops_traversed": {
            "title": "Hops Traversed",
            "type": "integer"
          },
          "individual_owners": {
            "items": {
              "$ref": "#/components/schemas/IndividualOwnerView"
            },
            "title": "Individual Owners",
            "type": "array"
          },
          "local_graph_complete": {
            "default": false,
            "title": "Local Graph Complete",
            "type": "boolean"
          },
          "max_hops": {
            "title": "Max Hops",
            "type": "integer"
          },
          "nodes": {
            "items": {
              "$ref": "#/components/schemas/OwnershipNodeView"
            },
            "title": "Nodes",
            "type": "array"
          },
          "not_traversed": {
            "items": {
              "$ref": "#/components/schemas/TraversalGapView"
            },
            "title": "Not Traversed",
            "type": "array"
          },
          "owners_provenance": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ProvenanceView"
              },
              {
                "type": "null"
              }
            ]
          },
          "ubo_candidates": {
            "items": {
              "$ref": "#/components/schemas/UBOCandidateView"
            },
            "title": "Ubo Candidates",
            "type": "array"
          },
          "ultimate_parent": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/OwnershipLinkView"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "required": [
          "max_hops",
          "hops_traversed"
        ],
        "title": "OwnershipView",
        "type": "object"
      },
      "PepRole": {
        "additionalProperties": false,
        "properties": {
          "ended_on": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Ended On"
          },
          "jurisdiction": {
            "maxLength": 500,
            "minLength": 1,
            "title": "Jurisdiction",
            "type": "string"
          },
          "organization": {
            "anyOf": [
              {
                "maxLength": 500,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Organization"
          },
          "role": {
            "maxLength": 500,
            "minLength": 1,
            "title": "Role",
            "type": "string"
          },
          "source_url": {
            "format": "uri",
            "maxLength": 2083,
            "minLength": 1,
            "title": "Source Url",
            "type": "string"
          },
          "started_on": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Started On"
          }
        },
        "required": [
          "role",
          "jurisdiction",
          "source_url"
        ],
        "title": "PepRole",
        "type": "object"
      },
      "PlanTier": {
        "enum": [
          "free",
          "starter",
          "growth",
          "scale"
        ],
        "title": "PlanTier",
        "type": "string"
      },
      "PlanValue": {
        "properties": {
          "deep_attempts": {
            "title": "Deep Attempts",
            "type": "integer"
          },
          "included_credits": {
            "title": "Included Credits",
            "type": "integer"
          },
          "max_depth": {
            "$ref": "#/components/schemas/ResolutionDepth"
          },
          "monthly_usd": {
            "title": "Monthly Usd",
            "type": "number"
          },
          "resale_rights": {
            "title": "Resale Rights",
            "type": "boolean"
          },
          "tier": {
            "title": "Tier",
            "type": "string"
          }
        },
        "required": [
          "tier",
          "monthly_usd",
          "included_credits",
          "deep_attempts",
          "max_depth",
          "resale_rights"
        ],
        "title": "PlanValue",
        "type": "object"
      },
      "PortfolioRename": {
        "additionalProperties": false,
        "properties": {
          "name": {
            "maxLength": 120,
            "minLength": 1,
            "title": "Name",
            "type": "string"
          }
        },
        "required": [
          "name"
        ],
        "title": "PortfolioRename",
        "type": "object"
      },
      "PortfolioRequest": {
        "additionalProperties": false,
        "properties": {
          "name": {
            "maxLength": 120,
            "minLength": 1,
            "title": "Name",
            "type": "string"
          },
          "portfolio_id": {
            "anyOf": [
              {
                "maxLength": 64,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Portfolio Id"
          }
        },
        "required": [
          "name"
        ],
        "title": "PortfolioRequest",
        "type": "object"
      },
      "PricingResponse": {
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "credit_rules": {
            "items": {
              "$ref": "#/components/schemas/CreditRule"
            },
            "title": "Credit Rules",
            "type": "array"
          },
          "enforced": {
            "title": "Enforced",
            "type": "boolean"
          },
          "plans": {
            "items": {
              "$ref": "#/components/schemas/PlanValue"
            },
            "title": "Plans",
            "type": "array"
          }
        },
        "required": [
          "credit_rules",
          "plans",
          "enforced",
          "correlation_id"
        ],
        "title": "PricingResponse",
        "type": "object"
      },
      "ProvenanceView": {
        "description": "Where a value came from, and how current it is.\n\n`retrieved_at` is when we got it; `last_checked_at` is when a source last\nre-confirmed it and `checks` is how many times. A caller deciding whether to\ntrust a value needs the second pair, not the first: a value first seen a\nyear ago and re-confirmed this morning is current, and one retrieved\nyesterday from a single sighting is not the same thing (ADR-0013).",
        "properties": {
          "age_days": {
            "title": "Age Days",
            "type": "number"
          },
          "checks": {
            "title": "Checks",
            "type": "integer"
          },
          "confidence": {
            "title": "Confidence",
            "type": "number"
          },
          "evidence_chain": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/EvidenceChainMetadata"
              },
              {
                "type": "null"
              }
            ]
          },
          "first_seen_at": {
            "format": "date-time",
            "title": "First Seen At",
            "type": "string"
          },
          "last_checked_at": {
            "format": "date-time",
            "title": "Last Checked At",
            "type": "string"
          },
          "licence": {
            "$ref": "#/components/schemas/LicenceTier"
          },
          "licence_permits_resale": {
            "default": false,
            "title": "Licence Permits Resale",
            "type": "boolean"
          },
          "licence_reference": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Licence Reference"
          },
          "provider": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Provider"
          },
          "provider_record_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Provider Record Id"
          },
          "resellable": {
            "default": false,
            "title": "Resellable",
            "type": "boolean"
          },
          "retrieved_at": {
            "format": "date-time",
            "title": "Retrieved At",
            "type": "string"
          },
          "source_as_of": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Source As Of"
          },
          "source_id": {
            "title": "Source Id",
            "type": "string"
          },
          "source_kind": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/SourceKind"
              },
              {
                "type": "null"
              }
            ]
          },
          "source_url": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Source Url"
          },
          "valid_from": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Valid From"
          },
          "valid_to": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Valid To"
          }
        },
        "required": [
          "source_id",
          "retrieved_at",
          "confidence",
          "licence",
          "first_seen_at",
          "last_checked_at",
          "checks",
          "age_days"
        ],
        "title": "ProvenanceView",
        "type": "object"
      },
      "PublicIdentityAnchorView": {
        "properties": {
          "authority": {
            "title": "Authority",
            "type": "string"
          },
          "provenance": {
            "$ref": "#/components/schemas/ProvenanceView"
          },
          "public_id": {
            "title": "Public Id",
            "type": "string"
          },
          "status": {
            "enum": [
              "current",
              "historical"
            ],
            "title": "Status",
            "type": "string"
          },
          "valid_from": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Valid From"
          },
          "valid_to": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Valid To"
          },
          "value": {
            "title": "Value",
            "type": "string"
          }
        },
        "required": [
          "public_id",
          "authority",
          "value",
          "status",
          "provenance"
        ],
        "title": "PublicIdentityAnchorView",
        "type": "object"
      },
      "QualityReport": {
        "additionalProperties": false,
        "description": "Whether a returned candidate-backed match satisfies the explicit target.",
        "properties": {
          "accepted_match": {
            "title": "Accepted Match",
            "type": "boolean"
          },
          "completeness": {
            "$ref": "#/components/schemas/CompletenessReport"
          },
          "completeness_target_met": {
            "title": "Completeness Target Met",
            "type": "boolean"
          },
          "confidence_target_met": {
            "title": "Confidence Target Met",
            "type": "boolean"
          },
          "limitations": {
            "items": {
              "type": "string"
            },
            "title": "Limitations",
            "type": "array"
          },
          "match_confidence": {
            "maximum": 1.0,
            "minimum": 0.0,
            "title": "Match Confidence",
            "type": "number"
          },
          "match_confidence_basis": {
            "$ref": "#/components/schemas/ConfidenceBasis"
          },
          "quality_research_attempted": {
            "default": false,
            "title": "Quality Research Attempted",
            "type": "boolean"
          },
          "quality_research_unavailable": {
            "default": false,
            "title": "Quality Research Unavailable",
            "type": "boolean"
          },
          "reasons": {
            "items": {
              "type": "string"
            },
            "title": "Reasons",
            "type": "array"
          },
          "status": {
            "enum": [
              "met",
              "review_required"
            ],
            "title": "Status",
            "type": "string"
          },
          "target": {
            "$ref": "#/components/schemas/QualityTarget"
          }
        },
        "required": [
          "target",
          "status",
          "match_confidence",
          "match_confidence_basis",
          "accepted_match",
          "confidence_target_met",
          "completeness_target_met",
          "completeness",
          "reasons"
        ],
        "title": "QualityReport",
        "type": "object"
      },
      "QualityTarget": {
        "additionalProperties": false,
        "description": "An opt-in delivery requirement, never a dial for changing confidence.",
        "properties": {
          "minimum_completeness": {
            "default": 0.95,
            "exclusiveMinimum": 0.0,
            "maximum": 1.0,
            "title": "Minimum Completeness",
            "type": "number"
          },
          "minimum_match_confidence": {
            "default": 0.95,
            "maximum": 1.0,
            "minimum": 0.9,
            "title": "Minimum Match Confidence",
            "type": "number"
          }
        },
        "title": "QualityTarget",
        "type": "object"
      },
      "RateLimitValue": {
        "properties": {
          "base_requests_per_minute": {
            "title": "Base Requests Per Minute",
            "type": "integer"
          },
          "requests_per_minute": {
            "title": "Requests Per Minute",
            "type": "integer"
          },
          "scope": {
            "title": "Scope",
            "type": "string"
          }
        },
        "required": [
          "scope",
          "requests_per_minute",
          "base_requests_per_minute"
        ],
        "title": "RateLimitValue",
        "type": "object"
      },
      "ReconcileKeyRequest": {
        "additionalProperties": false,
        "description": "One identifier to reconcile, and the caller's own key for the row it repairs.\n\n`client_ref` is echoed back verbatim and is the only thing joining a result\nto the row it belongs to: the whole motion is \"repair a page of foreign\nkeys\", and a positional answer would put the repair on the wrong row the\nfirst time anything is filtered. Larger catalogues page at the deployment's\npublished batch ceiling.",
        "properties": {
          "client_ref": {
            "anyOf": [
              {
                "maxLength": 200,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Client Ref"
          },
          "domain": {
            "anyOf": [
              {
                "maxLength": 253,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Domain"
          },
          "jurisdiction": {
            "anyOf": [
              {
                "maxLength": 32,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Jurisdiction"
          },
          "lei": {
            "anyOf": [
              {
                "maxLength": 20,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Lei"
          },
          "registration_number": {
            "anyOf": [
              {
                "maxLength": 64,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Registration Number"
          }
        },
        "title": "ReconcileKeyRequest",
        "type": "object"
      },
      "ReconcileRequest": {
        "additionalProperties": false,
        "properties": {
          "keys": {
            "items": {
              "$ref": "#/components/schemas/ReconcileKeyRequest"
            },
            "maxItems": 500,
            "minItems": 1,
            "title": "Keys",
            "type": "array"
          }
        },
        "required": [
          "keys"
        ],
        "title": "ReconcileRequest",
        "type": "object"
      },
      "ReconcileResponse": {
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "results": {
            "items": {
              "$ref": "#/components/schemas/ReconciledKeyView"
            },
            "title": "Results",
            "type": "array"
          },
          "usage": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/UsageView"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "required": [
          "results",
          "correlation_id"
        ],
        "title": "ReconcileResponse",
        "type": "object"
      },
      "ReconcileStatus": {
        "enum": [
          "matched",
          "not_found",
          "ambiguous"
        ],
        "title": "ReconcileStatus",
        "type": "string"
      },
      "ReconciledKeyView": {
        "properties": {
          "ambiguous_entity_ids": {
            "items": {
              "type": "string"
            },
            "title": "Ambiguous Entity Ids",
            "type": "array"
          },
          "client_ref": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Client Ref"
          },
          "entity_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Entity Id"
          },
          "matched_on": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Matched On"
          },
          "status": {
            "$ref": "#/components/schemas/ReconcileStatus"
          }
        },
        "required": [
          "status"
        ],
        "title": "ReconciledKeyView",
        "type": "object"
      },
      "ReferenceListResponse": {
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "values": {
            "items": {
              "$ref": "#/components/schemas/ReferenceValue"
            },
            "title": "Values",
            "type": "array"
          }
        },
        "required": [
          "values",
          "correlation_id"
        ],
        "title": "ReferenceListResponse",
        "type": "object"
      },
      "ReferenceValue": {
        "properties": {
          "description": {
            "title": "Description",
            "type": "string"
          },
          "value": {
            "title": "Value",
            "type": "string"
          }
        },
        "required": [
          "value",
          "description"
        ],
        "title": "ReferenceValue",
        "type": "object"
      },
      "RegistriesResponse": {
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "values": {
            "items": {
              "$ref": "#/components/schemas/RegistryValue"
            },
            "title": "Values",
            "type": "array"
          }
        },
        "required": [
          "values",
          "correlation_id"
        ],
        "title": "RegistriesResponse",
        "type": "object"
      },
      "RegistryValue": {
        "properties": {
          "configured": {
            "title": "Configured",
            "type": "boolean"
          },
          "coverage": {
            "title": "Coverage",
            "type": "string"
          },
          "licence": {
            "$ref": "#/components/schemas/LicenceTier"
          },
          "name": {
            "title": "Name",
            "type": "string"
          },
          "source_id": {
            "title": "Source Id",
            "type": "string"
          }
        },
        "required": [
          "source_id",
          "name",
          "licence",
          "coverage",
          "configured"
        ],
        "title": "RegistryValue",
        "type": "object"
      },
      "RelationshipRequest": {
        "additionalProperties": false,
        "properties": {
          "as_of": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "As Of"
          },
          "capture": {
            "default": false,
            "title": "Capture",
            "type": "boolean"
          },
          "capture_id": {
            "anyOf": [
              {
                "maxLength": 64,
                "minLength": 1,
                "pattern": "^[A-Za-z0-9_-]+$",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Capture Id"
          },
          "left_entity_id": {
            "maxLength": 64,
            "minLength": 1,
            "title": "Left Entity Id",
            "type": "string"
          },
          "limit": {
            "default": 10,
            "maximum": 20.0,
            "minimum": 1.0,
            "title": "Limit",
            "type": "integer"
          },
          "max_hops": {
            "default": 3,
            "maximum": 10.0,
            "minimum": 1.0,
            "title": "Max Hops",
            "type": "integer"
          },
          "right_entity_id": {
            "maxLength": 64,
            "minLength": 1,
            "title": "Right Entity Id",
            "type": "string"
          }
        },
        "required": [
          "left_entity_id",
          "right_entity_id"
        ],
        "title": "RelationshipRequest",
        "type": "object"
      },
      "ResearchFieldDiagnostic": {
        "additionalProperties": false,
        "description": "Closed vocabulary; no URLs, names, prompts, page text or model prose.",
        "properties": {
          "attribute": {
            "enum": [
              "industry.description",
              "location.hq_address",
              "digital.linkedin",
              "contact.email",
              "industry.services",
              "industry.tags",
              "industry.sectors",
              "location.operating_addresses",
              "technology.stack",
              "financials.ebitda",
              "financials.enterprise_value",
              "financials.market_cap",
              "financials.income",
              "financials.expenditure",
              "financials.revenue_history",
              "financials.revenue_growth",
              "registration.charity_number",
              "ownership.ultimate_owner",
              "funding.rounds",
              "intangible.trademarks",
              "intangible.trademark_holders",
              "intent.events"
            ],
            "title": "Attribute",
            "type": "string"
          },
          "basis": {
            "enum": [
              "execution",
              "admission",
              "model_reported"
            ],
            "title": "Basis",
            "type": "string"
          },
          "reason": {
            "enum": [
              "no_supported_finding",
              "evidence_not_found",
              "identity_not_anchored",
              "subject_not_supported",
              "source_not_fetched",
              "field_semantics_not_supported",
              "invalid_finding",
              "research_timed_out",
              "research_cancelled",
              "research_failed",
              "invalid_research_response"
            ],
            "title": "Reason",
            "type": "string"
          },
          "status": {
            "enum": [
              "not_returned",
              "withheld",
              "unavailable",
              "invalid_response"
            ],
            "title": "Status",
            "type": "string"
          }
        },
        "required": [
          "attribute",
          "status",
          "reason",
          "basis"
        ],
        "title": "ResearchFieldDiagnostic",
        "type": "object"
      },
      "ResolutionDepth": {
        "description": "How far down the cascade a caller is willing to pay to go.\n\nThe cascade costs orders of magnitude more at the bottom than at the top\n(docs/COMMERCIAL-MODEL.md \u00a72), so the depth cap is simultaneously the\ncaller's price ceiling and our cost ceiling. Capping does not lower\nprecision \u2014 a capped record abstains instead of being decided cheaply.",
        "enum": [
          "probabilistic",
          "adjudication",
          "research"
        ],
        "title": "ResolutionDepth",
        "type": "string"
      },
      "ResolutionLabel": {
        "description": "One append-only label and its place in an optional correction chain.\n\nCorrections never update an old row.  They append a new row naming\n``supersedes_label_id``; the repository assigns the next ``revision``.\n``provenance_sha256`` seals every field other than the seal itself, making\naccidental mutation detectable on export and read-back.",
        "properties": {
          "candidate_ref": {
            "anyOf": [
              {
                "maxLength": 255,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Candidate Ref"
          },
          "decision_id": {
            "anyOf": [
              {
                "maxLength": 64,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Decision Id"
          },
          "decision_snapshot": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/LabelDecisionSnapshot"
              },
              {
                "type": "null"
              }
            ]
          },
          "entity_id": {
            "anyOf": [
              {
                "maxLength": 64,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Entity Id"
          },
          "evidence_tier": {
            "$ref": "#/components/schemas/ComparisonEvidenceTier"
          },
          "label": {
            "$ref": "#/components/schemas/ResolutionLabelValue"
          },
          "label_id": {
            "maxLength": 64,
            "minLength": 1,
            "title": "Label Id",
            "type": "string"
          },
          "labelled_at": {
            "format": "date-time",
            "title": "Labelled At",
            "type": "string"
          },
          "model_id": {
            "anyOf": [
              {
                "maxLength": 255,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Model Id"
          },
          "pipeline_version": {
            "maxLength": 64,
            "minLength": 1,
            "title": "Pipeline Version",
            "type": "string"
          },
          "prompt_version": {
            "anyOf": [
              {
                "maxLength": 255,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Prompt Version"
          },
          "provenance": {
            "$ref": "#/components/schemas/LabelProvenance"
          },
          "provenance_sha256": {
            "default": "",
            "maxLength": 64,
            "title": "Provenance Sha256",
            "type": "string"
          },
          "record_fingerprint": {
            "anyOf": [
              {
                "maxLength": 64,
                "minLength": 64,
                "pattern": "^[0-9a-f]{64}$",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Record Fingerprint"
          },
          "record_id": {
            "maxLength": 64,
            "minLength": 1,
            "title": "Record Id",
            "type": "string"
          },
          "recorded_at": {
            "format": "date-time",
            "title": "Recorded At",
            "type": "string"
          },
          "review_id": {
            "anyOf": [
              {
                "maxLength": 64,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Review Id"
          },
          "revision": {
            "default": 1,
            "minimum": 1.0,
            "title": "Revision",
            "type": "integer"
          },
          "schema_version": {
            "default": 1,
            "minimum": 1.0,
            "title": "Schema Version",
            "type": "integer"
          },
          "source": {
            "$ref": "#/components/schemas/ResolutionLabelSource"
          },
          "supersedes_label_id": {
            "anyOf": [
              {
                "maxLength": 64,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Supersedes Label Id"
          },
          "tenant_id": {
            "maxLength": 64,
            "minLength": 1,
            "title": "Tenant Id",
            "type": "string"
          }
        },
        "required": [
          "tenant_id",
          "record_id",
          "label",
          "source",
          "evidence_tier",
          "pipeline_version",
          "labelled_at",
          "recorded_at",
          "provenance"
        ],
        "title": "ResolutionLabel",
        "type": "object"
      },
      "ResolutionLabelListResponse": {
        "description": "One page of a tenant's current label heads (or full revision history).",
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "items": {
            "items": {
              "$ref": "#/components/schemas/ResolutionLabel"
            },
            "title": "Items",
            "type": "array"
          },
          "limit": {
            "title": "Limit",
            "type": "integer"
          },
          "offset": {
            "title": "Offset",
            "type": "integer"
          },
          "total": {
            "title": "Total",
            "type": "integer"
          }
        },
        "required": [
          "items",
          "total",
          "limit",
          "offset",
          "correlation_id"
        ],
        "title": "ResolutionLabelListResponse",
        "type": "object"
      },
      "ResolutionLabelResponse": {
        "description": "One immutable label, including its verifiable provenance seal.",
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "item": {
            "$ref": "#/components/schemas/ResolutionLabel"
          }
        },
        "required": [
          "item",
          "correlation_id"
        ],
        "title": "ResolutionLabelResponse",
        "type": "object"
      },
      "ResolutionLabelSource": {
        "description": "Which independently attributable channel supplied a label.",
        "enum": [
          "reviewer",
          "customer",
          "import"
        ],
        "title": "ResolutionLabelSource",
        "type": "string"
      },
      "ResolutionLabelSubmitRequest": {
        "additionalProperties": false,
        "description": "Independent truth supplied by a customer or curated import.\n\nReviewer labels cannot be submitted here: they are derived from a settled\nreview item so their four-eyes provenance cannot be forged in JSON.\n``source_event_id`` is the producer's idempotency key and must be stable\nacross retries.",
        "properties": {
          "actor_id": {
            "maxLength": 255,
            "minLength": 1,
            "title": "Actor Id",
            "type": "string"
          },
          "candidate_ref": {
            "anyOf": [
              {
                "maxLength": 255,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Candidate Ref"
          },
          "decision_id": {
            "anyOf": [
              {
                "maxLength": 64,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Decision Id"
          },
          "entity_id": {
            "anyOf": [
              {
                "maxLength": 64,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Entity Id"
          },
          "evidence_tier": {
            "$ref": "#/components/schemas/ComparisonEvidenceTier"
          },
          "label": {
            "$ref": "#/components/schemas/ResolutionLabelValue"
          },
          "labelled_at": {
            "anyOf": [
              {
                "format": "date-time",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Labelled At"
          },
          "model_id": {
            "anyOf": [
              {
                "maxLength": 255,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Model Id"
          },
          "pipeline_version": {
            "anyOf": [
              {
                "maxLength": 64,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Pipeline Version"
          },
          "prompt_version": {
            "anyOf": [
              {
                "maxLength": 255,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Prompt Version"
          },
          "rationale": {
            "anyOf": [
              {
                "maxLength": 4000,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Rationale"
          },
          "record_id": {
            "maxLength": 64,
            "minLength": 1,
            "title": "Record Id",
            "type": "string"
          },
          "source": {
            "$ref": "#/components/schemas/ResolutionLabelSource",
            "default": "customer"
          },
          "source_event_id": {
            "maxLength": 255,
            "minLength": 1,
            "title": "Source Event Id",
            "type": "string"
          },
          "source_uri": {
            "anyOf": [
              {
                "maxLength": 2000,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Source Uri"
          },
          "supersedes_label_id": {
            "anyOf": [
              {
                "maxLength": 64,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Supersedes Label Id"
          }
        },
        "required": [
          "label",
          "record_id",
          "evidence_tier",
          "source_event_id",
          "actor_id"
        ],
        "title": "ResolutionLabelSubmitRequest",
        "type": "object"
      },
      "ResolutionLabelValue": {
        "description": "The externally supplied truth about one resolution question.",
        "enum": [
          "match",
          "no_match",
          "new_entity",
          "ambiguous"
        ],
        "title": "ResolutionLabelValue",
        "type": "string"
      },
      "ResolveRequest": {
        "additionalProperties": false,
        "description": "Mirrors CompanyRecord's caller-suppliable fields with hard input caps.\n\nWHAT MAY BE ADDED HERE, and where it goes. Every field below that describes\nthe company is mapped onto `CompanyRecord` and is therefore inside the\ncontent fingerprint \u2014 see that class for the rule and why both halves of it\nmatter. Fields that describe the CALL rather than the company (`depth`,\n`enrich`, `client_ref`) stay on this request and never reach the record.\n\nThe identifiers are two classes and the distinction decides where in the\ncascade they may ever be used:\n\n* STRONG IDENTIFIER \u2014 one value, one company, issued by a body that\n  guarantees it. `lei`, `registration_number` + `jurisdiction`, `duns`, and\n  `ticker` + `exchange`. These are the only kind that could justify a\n  deterministic short-circuit.\n* CORROBORATING SIGNAL \u2014 narrows the field, settles nothing alone.\n  `vat_number`, `isin`, `incorporation_date`, `legal_form`, `trading_names`,\n  `previous_names`, `parent_name`, `context`, `extra`.\n\nTwo of these look strong and are not, which is the whole reason the\ndistinction is written down rather than inferred from the field name:\n\n* `vat_number` \u2014 group VAT registration is MANY companies to ONE number, so\n  equal VAT numbers do not imply one company. It may corroborate a merge and\n  may never carry one.\n* `isin` \u2014 identifies a security, not an issuer. One company has many, and a\n  financing subsidiary issues under itself. It becomes strong only once\n  GLEIF's ISIN->LEI mapping resolves it to an LEI, which already is.\n\nREJECTED, with the reason, because a wide schema nobody populates is worse\nthan a narrow one:\n\n* `employee_count` \u2014 self-reported, ranges disagree between every source\n  that publishes one, and it moves monthly. Enrichment already carries\n  `financials.employees_range`; a caller-supplied count would contradict it\n  routinely and the contradiction would mean nothing.\n* `industry_code` \u2014 not comparable without also negotiating a scheme (SIC\n  62020 and NAICS 541512 are the same activity and share no characters), and\n  every member of a group files the same code, so it separates nothing.\n  `context` carries the same intent \u2014 \"IT consultancy, not the pub of\n  the same name\" \u2014 with no scheme to agree on.\n* `company_status` \u2014 a register-derived attribute we already fetch\n  (`registration.status` in `llm.prompts.ENRICHMENT_ATTRIBUTES`). A caller\n  asserting it adds no information and can only contradict the register,\n  which is the one source that outranks them.",
        "properties": {
          "address": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/AddressRequest"
              },
              {
                "type": "null"
              }
            ]
          },
          "clarification_of": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ClarificationOrigin"
              },
              {
                "type": "null"
              }
            ]
          },
          "client_ref": {
            "anyOf": [
              {
                "maxLength": 200,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Client Ref"
          },
          "context": {
            "anyOf": [
              {
                "maxLength": 1000,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "description": "Anything you know about this company in plain language, e.g. 'recruitment company based in the UK, not the pub chain'. Use it when the name alone is ambiguous: it is weighed as evidence alongside the registers, and it is what separates two companies that share a name. It is treated as an unverified claim, so a register that contradicts it wins, and it cannot direct the answer \u2014 asserting the verdict or a confidence here has no effect.",
            "title": "Context"
          },
          "country": {
            "description": "Required country name or ISO country code; a retrieval clue, not legal identity proof.",
            "maxLength": 64,
            "minLength": 1,
            "title": "Country",
            "type": "string"
          },
          "depth": {
            "$ref": "#/components/schemas/ResolutionDepth",
            "default": "research"
          },
          "description": {
            "anyOf": [
              {
                "maxLength": 1000,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "description": "Alias for context: an optional, unverified company description.",
            "title": "Description"
          },
          "domain": {
            "anyOf": [
              {
                "maxLength": 253,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Domain"
          },
          "duns": {
            "anyOf": [
              {
                "maxLength": 16,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Duns"
          },
          "email": {
            "anyOf": [
              {
                "maxLength": 320,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Email"
          },
          "enrich": {
            "default": true,
            "title": "Enrich",
            "type": "boolean"
          },
          "exchange": {
            "anyOf": [
              {
                "maxLength": 64,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Exchange"
          },
          "extra": {
            "additionalProperties": {
              "type": "string"
            },
            "title": "Extra",
            "type": "object"
          },
          "field_packs": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "maxItems": 8,
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "description": "Named groups of returned attributes; combined with fields. Missing values have explicit status rather than invented data.",
            "title": "Field Packs"
          },
          "fields": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "maxItems": 64,
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "description": "Returned entity attributes; discover them at /v1/reference/enrichment-fields. Projection only: does not change identity evidence, acquisition, confidence or billing.",
            "title": "Fields"
          },
          "include_field_status": {
            "default": false,
            "title": "Include Field Status",
            "type": "boolean"
          },
          "incorporation_date": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Incorporation Date"
          },
          "isin": {
            "anyOf": [
              {
                "maxLength": 12,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Isin"
          },
          "jurisdiction": {
            "anyOf": [
              {
                "maxLength": 32,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Jurisdiction"
          },
          "legal_form": {
            "anyOf": [
              {
                "maxLength": 64,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Legal Form"
          },
          "lei": {
            "anyOf": [
              {
                "maxLength": 20,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Lei"
          },
          "name": {
            "description": "Company name is required.",
            "maxLength": 500,
            "minLength": 1,
            "title": "Name",
            "type": "string"
          },
          "parent_name": {
            "anyOf": [
              {
                "maxLength": 500,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Parent Name"
          },
          "phone": {
            "anyOf": [
              {
                "maxLength": 64,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Phone"
          },
          "postcode": {
            "anyOf": [
              {
                "maxLength": 32,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "description": "Alias for address.postal_code: an optional postcode or ZIP code.",
            "title": "Postcode"
          },
          "previous_names": {
            "items": {
              "type": "string"
            },
            "maxItems": 10,
            "title": "Previous Names",
            "type": "array"
          },
          "quality_target": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/QualityTarget"
              },
              {
                "type": "null"
              }
            ],
            "description": "Optional delivery target, defaulting to 0.95 calibrated match confidence and 0.95 sourced completeness. Requires explicit nonempty fields or field_packs. At research depth, missing supported descriptive fields may trigger one bounded paid research pass. Unmet targets are reported for review; values are never invented."
          },
          "registration_number": {
            "anyOf": [
              {
                "maxLength": 64,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Registration Number"
          },
          "ticker": {
            "anyOf": [
              {
                "maxLength": 16,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Ticker"
          },
          "trading_names": {
            "items": {
              "type": "string"
            },
            "maxItems": 10,
            "title": "Trading Names",
            "type": "array"
          },
          "vat_number": {
            "anyOf": [
              {
                "maxLength": 32,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Vat Number"
          },
          "website": {
            "anyOf": [
              {
                "maxLength": 500,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Website"
          }
        },
        "required": [
          "name",
          "country"
        ],
        "title": "ResolveRequest",
        "type": "object"
      },
      "ResolveResponse": {
        "properties": {
          "candidate": {
            "anyOf": [
              {
                "additionalProperties": true,
                "type": "object"
              },
              {
                "type": "null"
              }
            ],
            "title": "Candidate"
          },
          "candidates": {
            "items": {
              "$ref": "#/components/schemas/CandidateView"
            },
            "title": "Candidates",
            "type": "array"
          },
          "candidates_considered": {
            "title": "Candidates Considered",
            "type": "integer"
          },
          "clarification": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/Clarification"
              },
              {
                "type": "null"
              }
            ]
          },
          "clarification_of": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ClarificationOrigin"
              },
              {
                "type": "null"
              }
            ]
          },
          "client_ref": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Client Ref"
          },
          "confidence": {
            "title": "Confidence",
            "type": "number"
          },
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "decision": {
            "$ref": "#/components/schemas/MatchDecisionType"
          },
          "decision_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Decision Id"
          },
          "depth_capped": {
            "default": false,
            "title": "Depth Capped",
            "type": "boolean"
          },
          "entity": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/EntityView"
              },
              {
                "type": "null"
              }
            ]
          },
          "entity_created": {
            "default": false,
            "title": "Entity Created",
            "type": "boolean"
          },
          "escalation_unavailable": {
            "default": false,
            "title": "Escalation Unavailable",
            "type": "boolean"
          },
          "match_confidence": {
            "title": "Match Confidence",
            "type": "number"
          },
          "match_confidence_basis": {
            "$ref": "#/components/schemas/ConfidenceBasis"
          },
          "more_input_needed": {
            "default": false,
            "title": "More Input Needed",
            "type": "boolean"
          },
          "no_identifying_signal": {
            "default": false,
            "title": "No Identifying Signal",
            "type": "boolean"
          },
          "pipeline_version": {
            "default": "",
            "title": "Pipeline Version",
            "type": "string"
          },
          "quality": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/QualityReport"
              },
              {
                "type": "null"
              }
            ]
          },
          "quality_field_diagnostics": {
            "items": {
              "$ref": "#/components/schemas/ResearchFieldDiagnostic"
            },
            "maxItems": 22,
            "title": "Quality Field Diagnostics",
            "type": "array"
          },
          "quality_research_attempted": {
            "default": false,
            "title": "Quality Research Attempted",
            "type": "boolean"
          },
          "quality_research_unavailable": {
            "default": false,
            "title": "Quality Research Unavailable",
            "type": "boolean"
          },
          "record_id": {
            "title": "Record Id",
            "type": "string"
          },
          "replayed": {
            "default": false,
            "title": "Replayed",
            "type": "boolean"
          },
          "review_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Review Id"
          },
          "run_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Run Id"
          },
          "stage": {
            "$ref": "#/components/schemas/DecisionStage"
          },
          "usage": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/UsageView"
              },
              {
                "type": "null"
              }
            ]
          },
          "verification": {
            "$ref": "#/components/schemas/VerificationFreshness",
            "description": "Freshness of source identity evidence at resolution; independent of cached match confidence and each returned field's observation dates."
          }
        },
        "required": [
          "record_id",
          "decision",
          "stage",
          "confidence",
          "match_confidence",
          "match_confidence_basis",
          "candidates_considered",
          "correlation_id"
        ],
        "title": "ResolveResponse",
        "type": "object"
      },
      "ReviewDecisionRequest": {
        "additionalProperties": false,
        "description": "A reviewer's verdict, tied to an authenticated review credential.\n\n`reviewer_id` remains as a transition assertion, but it cannot choose the\naudit principal: the server derives that from the REVIEW key's immutable\nhuman-assigned name. If supplied, it must equal that authenticated name.",
        "properties": {
          "decision": {
            "$ref": "#/components/schemas/MatchDecisionType"
          },
          "reason": {
            "anyOf": [
              {
                "maxLength": 2000,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Reason"
          },
          "reviewer_id": {
            "anyOf": [
              {
                "maxLength": 255,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Reviewer Id"
          }
        },
        "required": [
          "decision"
        ],
        "title": "ReviewDecisionRequest",
        "type": "object"
      },
      "ReviewItemView": {
        "properties": {
          "applied": {
            "default": false,
            "title": "Applied",
            "type": "boolean"
          },
          "applied_entity_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Applied Entity Id"
          },
          "blocked_reason": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Blocked Reason"
          },
          "candidate": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/EntitySummaryView"
              },
              {
                "type": "null"
              }
            ]
          },
          "candidate_domain": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Candidate Domain"
          },
          "candidate_entity_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Candidate Entity Id"
          },
          "candidate_name": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Candidate Name"
          },
          "candidates": {
            "items": {
              "$ref": "#/components/schemas/CandidateView"
            },
            "title": "Candidates",
            "type": "array"
          },
          "created_at": {
            "format": "date-time",
            "title": "Created At",
            "type": "string"
          },
          "decision": {
            "$ref": "#/components/schemas/MatchDecisionType"
          },
          "decision_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Decision Id"
          },
          "evidence": {
            "items": {
              "$ref": "#/components/schemas/EvidenceView"
            },
            "title": "Evidence",
            "type": "array"
          },
          "evidence_tier": {
            "$ref": "#/components/schemas/ComparisonEvidenceTier"
          },
          "label_capture_pending": {
            "default": false,
            "title": "Label Capture Pending",
            "type": "boolean"
          },
          "probability": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Probability"
          },
          "redacted_at": {
            "anyOf": [
              {
                "format": "date-time",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Redacted At"
          },
          "resolution_label_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Resolution Label Id"
          },
          "resolved": {
            "title": "Resolved",
            "type": "boolean"
          },
          "review_id": {
            "title": "Review Id",
            "type": "string"
          },
          "reviewer_decision": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/MatchDecisionType"
              },
              {
                "type": "null"
              }
            ]
          },
          "reviewer_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Reviewer Id"
          },
          "reviewer_reason": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Reviewer Reason"
          },
          "right_ref": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Right Ref"
          },
          "settlement_pending": {
            "default": false,
            "title": "Settlement Pending",
            "type": "boolean"
          },
          "settlement_started_at": {
            "anyOf": [
              {
                "format": "date-time",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Settlement Started At"
          },
          "stage": {
            "$ref": "#/components/schemas/DecisionStage"
          },
          "submitted_record": {
            "additionalProperties": {
              "type": "string"
            },
            "title": "Submitted Record",
            "type": "object"
          },
          "thresholds": {
            "additionalProperties": {
              "type": "number"
            },
            "title": "Thresholds",
            "type": "object"
          },
          "top_features": {
            "items": {
              "$ref": "#/components/schemas/FeatureContributionView"
            },
            "title": "Top Features",
            "type": "array"
          },
          "verdict_decision_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Verdict Decision Id"
          }
        },
        "required": [
          "review_id",
          "submitted_record",
          "decision",
          "stage",
          "evidence_tier",
          "created_at",
          "resolved"
        ],
        "title": "ReviewItemView",
        "type": "object"
      },
      "ReviewQueueResponse": {
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "items": {
            "items": {
              "$ref": "#/components/schemas/ReviewItemView"
            },
            "title": "Items",
            "type": "array"
          },
          "limit": {
            "title": "Limit",
            "type": "integer"
          },
          "offset": {
            "title": "Offset",
            "type": "integer"
          },
          "open_backlog": {
            "title": "Open Backlog",
            "type": "integer"
          },
          "total": {
            "title": "Total",
            "type": "integer"
          }
        },
        "required": [
          "items",
          "total",
          "open_backlog",
          "limit",
          "offset",
          "correlation_id"
        ],
        "title": "ReviewQueueResponse",
        "type": "object"
      },
      "ReviewSort": {
        "description": "The orders a reviewer may walk the abstention queue in.\n\nA StrEnum so callers above this layer need not import from infrastructure:\nthe API defines its own query enum and hands the store its string value, the\nsame way `ReviewStatus` arrives here already reduced to `resolved: bool`.",
        "enum": [
          "oldest_first",
          "newest_first",
          "confidence_desc",
          "confidence_asc"
        ],
        "title": "ReviewSort",
        "type": "string"
      },
      "ReviewStatus": {
        "description": "Which slice of the queue a listing asks for.",
        "enum": [
          "open",
          "resolved",
          "all"
        ],
        "title": "ReviewStatus",
        "type": "string"
      },
      "RotateKeyRequest": {
        "additionalProperties": false,
        "description": "Replace a credential, optionally overriding the deployment's grace window.",
        "properties": {
          "grace_seconds": {
            "anyOf": [
              {
                "maximum": 2592000.0,
                "minimum": 0.0,
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Grace Seconds"
          }
        },
        "title": "RotateKeyRequest",
        "type": "object"
      },
      "RotatedKeyResponse": {
        "description": "A rotation: the new credential, plus what became of the old one.",
        "properties": {
          "api_key": {
            "title": "Api Key",
            "type": "string"
          },
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "key": {
            "$ref": "#/components/schemas/ApiKeyView"
          },
          "superseded": {
            "$ref": "#/components/schemas/ApiKeyView"
          }
        },
        "required": [
          "key",
          "api_key",
          "correlation_id",
          "superseded"
        ],
        "title": "RotatedKeyResponse",
        "type": "object"
      },
      "RunRoomAccountingReceipt": {
        "additionalProperties": false,
        "description": "Application-credit evidence, not a provider invoice or execution outcome.",
        "properties": {
          "basis": {
            "enum": [
              "credit_settled",
              "shadow_ledger_confirmed",
              "enforced_ledger_confirmed"
            ],
            "title": "Basis",
            "type": "string"
          },
          "credits": {
            "maximum": 5.0,
            "minimum": 0.0,
            "title": "Credits",
            "type": "integer"
          },
          "deep": {
            "title": "Deep",
            "type": "boolean"
          },
          "enforced": {
            "title": "Enforced",
            "type": "boolean"
          },
          "ledger_write_confirmed": {
            "title": "Ledger Write Confirmed",
            "type": "boolean"
          },
          "metered_at": {
            "format": "date-time",
            "title": "Metered At",
            "type": "string"
          },
          "operation_sha256": {
            "anyOf": [
              {
                "pattern": "^[a-f0-9]{64}$",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Operation Sha256"
          },
          "provider_usage_status": {
            "const": "unknown",
            "default": "unknown",
            "title": "Provider Usage Status",
            "type": "string"
          },
          "usage_event_id": {
            "anyOf": [
              {
                "pattern": "^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Usage Event Id"
          }
        },
        "required": [
          "basis",
          "ledger_write_confirmed",
          "credits",
          "deep",
          "enforced",
          "metered_at"
        ],
        "title": "RunRoomAccountingReceipt",
        "type": "object"
      },
      "RunRoomContext": {
        "additionalProperties": false,
        "properties": {
          "record_id": {
            "pattern": "^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$",
            "title": "Record Id",
            "type": "string"
          },
          "run_id": {
            "pattern": "^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$",
            "title": "Run Id",
            "type": "string"
          },
          "tenant_id": {
            "pattern": "^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$",
            "title": "Tenant Id",
            "type": "string"
          }
        },
        "required": [
          "tenant_id",
          "run_id",
          "record_id"
        ],
        "title": "RunRoomContext",
        "type": "object"
      },
      "RunRoomExecutionManifest": {
        "additionalProperties": false,
        "properties": {
          "accounting": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/RunRoomAccountingReceipt"
              },
              {
                "type": "null"
              }
            ]
          },
          "accounting_status": {
            "default": "pending",
            "enum": [
              "pending",
              "recorded"
            ],
            "title": "Accounting Status",
            "type": "string"
          },
          "context": {
            "$ref": "#/components/schemas/RunRoomContext"
          },
          "created_at": {
            "format": "date-time",
            "title": "Created At",
            "type": "string"
          },
          "events": {
            "default": [],
            "items": {
              "$ref": "#/components/schemas/RunRoomStageEvent"
            },
            "maxItems": 128,
            "title": "Events",
            "type": "array"
          },
          "events_omitted": {
            "default": 0,
            "minimum": 0.0,
            "title": "Events Omitted",
            "type": "integer"
          },
          "input_sha256": {
            "pattern": "^[a-f0-9]{64}$",
            "title": "Input Sha256",
            "type": "string"
          },
          "normalized_input_refs": {
            "default": [],
            "items": {
              "type": "string"
            },
            "maxItems": 32,
            "title": "Normalized Input Refs",
            "type": "array"
          },
          "output": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/RunRoomStageMetadata"
              },
              {
                "type": "null"
              }
            ]
          },
          "status": {
            "default": "pending",
            "enum": [
              "pending",
              "completed",
              "failed"
            ],
            "title": "Status",
            "type": "string"
          },
          "updated_at": {
            "format": "date-time",
            "title": "Updated At",
            "type": "string"
          }
        },
        "required": [
          "context",
          "input_sha256",
          "created_at",
          "updated_at"
        ],
        "title": "RunRoomExecutionManifest",
        "type": "object"
      },
      "RunRoomManifest": {
        "additionalProperties": false,
        "description": "Protected metadata; raw/extracted object locations are never exposed.",
        "properties": {
          "artifact_id": {
            "pattern": "^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$",
            "title": "Artifact Id",
            "type": "string"
          },
          "created_at": {
            "format": "date-time",
            "title": "Created At",
            "type": "string"
          },
          "event_ordinal": {
            "maximum": 32.0,
            "minimum": 1.0,
            "title": "Event Ordinal",
            "type": "integer"
          },
          "expires_at": {
            "format": "date-time",
            "title": "Expires At",
            "type": "string"
          },
          "extracted_bytes": {
            "maximum": 1000000.0,
            "minimum": 0.0,
            "title": "Extracted Bytes",
            "type": "integer"
          },
          "extracted_sha256": {
            "pattern": "^[a-f0-9]{64}$",
            "title": "Extracted Sha256",
            "type": "string"
          },
          "extraction_reason": {
            "enum": [
              "complete",
              "text_limit",
              "page_limit",
              "no_text",
              "unsupported_shape",
              "invalid_base64",
              "input_limit",
              "encrypted_pdf",
              "invalid_pdf",
              "parser_timeout",
              "parser_cpu_budget",
              "parser_failed",
              "parser_unavailable",
              "cache_limit",
              "invalid_url",
              "structure_limit"
            ],
            "title": "Extraction Reason",
            "type": "string"
          },
          "extraction_status": {
            "enum": [
              "ready",
              "partial",
              "unavailable"
            ],
            "title": "Extraction Status",
            "type": "string"
          },
          "markdown_bytes": {
            "maximum": 1000000.0,
            "minimum": 0.0,
            "title": "Markdown Bytes",
            "type": "integer"
          },
          "markdown_sha256": {
            "pattern": "^[a-f0-9]{64}$",
            "title": "Markdown Sha256",
            "type": "string"
          },
          "policy": {
            "$ref": "#/components/schemas/RunRoomPolicy"
          },
          "raw_bytes": {
            "maximum": 5242880.0,
            "minimum": 0.0,
            "title": "Raw Bytes",
            "type": "integer"
          },
          "raw_sha256": {
            "pattern": "^[a-f0-9]{64}$",
            "title": "Raw Sha256",
            "type": "string"
          },
          "record_id": {
            "pattern": "^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$",
            "title": "Record Id",
            "type": "string"
          },
          "representation": {
            "enum": [
              "native_pdf",
              "native_text"
            ],
            "title": "Representation",
            "type": "string"
          },
          "retained_chars": {
            "maximum": 64000.0,
            "minimum": 0.0,
            "title": "Retained Chars",
            "type": "integer"
          },
          "retained_segments": {
            "maximum": 32.0,
            "minimum": 0.0,
            "title": "Retained Segments",
            "type": "integer"
          },
          "run_id": {
            "pattern": "^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$",
            "title": "Run Id",
            "type": "string"
          },
          "source_url": {
            "maxLength": 2048,
            "title": "Source Url",
            "type": "string"
          },
          "status": {
            "enum": [
              "pending",
              "stored",
              "deleting"
            ],
            "title": "Status",
            "type": "string"
          },
          "tenant_id": {
            "pattern": "^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$",
            "title": "Tenant Id",
            "type": "string"
          },
          "truncated": {
            "title": "Truncated",
            "type": "boolean"
          }
        },
        "required": [
          "artifact_id",
          "tenant_id",
          "run_id",
          "record_id",
          "event_ordinal",
          "status",
          "source_url",
          "representation",
          "policy",
          "raw_sha256",
          "extracted_sha256",
          "markdown_sha256",
          "markdown_bytes",
          "raw_bytes",
          "extracted_bytes",
          "extraction_status",
          "extraction_reason",
          "retained_segments",
          "retained_chars",
          "truncated",
          "created_at",
          "expires_at"
        ],
        "title": "RunRoomManifest",
        "type": "object"
      },
      "RunRoomPolicy": {
        "additionalProperties": false,
        "description": "An application-vetted purpose receipt, never supplied by model output.\n\nAn owner's temporary first-party diagnostic permission does not relicense\nthe source or allow redistribution. Known pass-through restrictions still\nprohibit storage. Missing permission/host proof is a skip, not inference.",
        "properties": {
          "official_registry_hosts": {
            "default": [],
            "items": {
              "type": "string"
            },
            "maxItems": 16,
            "title": "Official Registry Hosts",
            "type": "array"
          },
          "policy_reference": {
            "maxLength": 128,
            "minLength": 1,
            "pattern": "^[A-Za-z0-9_.:/-]+$",
            "title": "Policy Reference",
            "type": "string"
          },
          "proven_target_host": {
            "anyOf": [
              {
                "maxLength": 253,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Proven Target Host"
          },
          "purpose": {
            "const": "temporary_first_party_research",
            "default": "temporary_first_party_research",
            "title": "Purpose",
            "type": "string"
          },
          "source_licence": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/LicenceTier"
              },
              {
                "type": "null"
              }
            ]
          },
          "storage_permitted": {
            "default": false,
            "title": "Storage Permitted",
            "type": "boolean"
          }
        },
        "required": [
          "policy_reference"
        ],
        "title": "RunRoomPolicy",
        "type": "object"
      },
      "RunRoomResponse": {
        "additionalProperties": false,
        "properties": {
          "artifacts": {
            "items": {
              "$ref": "#/components/schemas/RunRoomManifest"
            },
            "maxItems": 32,
            "title": "Artifacts",
            "type": "array"
          },
          "run": {
            "$ref": "#/components/schemas/RunRoomExecutionManifest"
          }
        },
        "required": [
          "run"
        ],
        "title": "RunRoomResponse",
        "type": "object"
      },
      "RunRoomStageEvent": {
        "additionalProperties": false,
        "properties": {
          "at": {
            "format": "date-time",
            "title": "At",
            "type": "string"
          },
          "attempt": {
            "default": 1,
            "maximum": 32.0,
            "minimum": 1.0,
            "title": "Attempt",
            "type": "integer"
          },
          "metadata": {
            "$ref": "#/components/schemas/RunRoomStageMetadata"
          },
          "ordinal": {
            "maximum": 128.0,
            "minimum": 1.0,
            "title": "Ordinal",
            "type": "integer"
          },
          "stage": {
            "enum": [
              "input",
              "reference_discovery",
              "identity",
              "sources",
              "research",
              "extraction",
              "validation",
              "delivery",
              "accounting"
            ],
            "title": "Stage",
            "type": "string"
          },
          "status": {
            "enum": [
              "pending",
              "completed",
              "failed",
              "skipped"
            ],
            "title": "Status",
            "type": "string"
          }
        },
        "required": [
          "ordinal",
          "stage",
          "status",
          "at"
        ],
        "title": "RunRoomStageEvent",
        "type": "object"
      },
      "RunRoomStageMetadata": {
        "additionalProperties": false,
        "description": "Closed operational facts, never arbitrary model/tool payloads.",
        "properties": {
          "artifact_observations_omitted": {
            "default": 0,
            "minimum": 0.0,
            "title": "Artifact Observations Omitted",
            "type": "integer"
          },
          "artifact_refs": {
            "default": [],
            "items": {
              "type": "string"
            },
            "maxItems": 32,
            "title": "Artifact Refs",
            "type": "array"
          },
          "candidate_count": {
            "anyOf": [
              {
                "maximum": 10000.0,
                "minimum": 0.0,
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Candidate Count"
          },
          "decision_ref": {
            "anyOf": [
              {
                "pattern": "^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Decision Ref"
          },
          "error": {
            "anyOf": [
              {
                "enum": [
                  "unavailable",
                  "timeout",
                  "cancelled",
                  "invalid_response",
                  "storage_failed",
                  "erased"
                ],
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Error"
          },
          "input_refs": {
            "default": [],
            "items": {
              "type": "string"
            },
            "maxItems": 32,
            "title": "Input Refs",
            "type": "array"
          },
          "input_sha256": {
            "anyOf": [
              {
                "pattern": "^[a-f0-9]{64}$",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Input Sha256"
          },
          "journal_ref": {
            "anyOf": [
              {
                "pattern": "^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Journal Ref"
          },
          "provider_usage_complete": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Provider Usage Complete"
          },
          "quality_met": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Quality Met"
          },
          "requested_fields": {
            "anyOf": [
              {
                "maximum": 1000.0,
                "minimum": 0.0,
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Requested Fields"
          },
          "skip_reason": {
            "anyOf": [
              {
                "enum": [
                  "not_requested",
                  "depth_cap",
                  "not_configured",
                  "no_identifier"
                ],
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Skip Reason"
          },
          "source_count": {
            "anyOf": [
              {
                "maximum": 10000.0,
                "minimum": 0.0,
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Source Count"
          },
          "source_id": {
            "anyOf": [
              {
                "pattern": "^[a-z][a-z0-9_-]{0,63}$",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Source Id"
          },
          "source_status": {
            "anyOf": [
              {
                "enum": [
                  "found",
                  "not_found",
                  "unavailable",
                  "skipped"
                ],
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Source Status"
          },
          "sourced_fields": {
            "anyOf": [
              {
                "maximum": 1000.0,
                "minimum": 0.0,
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Sourced Fields"
          },
          "stage_events_omitted": {
            "default": 0,
            "minimum": 0.0,
            "title": "Stage Events Omitted",
            "type": "integer"
          }
        },
        "title": "RunRoomStageMetadata",
        "type": "object"
      },
      "ScreeningCoverage": {
        "additionalProperties": false,
        "properties": {
          "entry_count": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Entry Count"
          },
          "expires_at": {
            "anyOf": [
              {
                "format": "date-time",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Expires At"
          },
          "generated_at": {
            "anyOf": [
              {
                "format": "date-time",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Generated At"
          },
          "kind": {
            "anyOf": [
              {
                "enum": [
                  "sanctions",
                  "pep",
                  "adverse_media"
                ],
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Kind"
          },
          "license": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "License"
          },
          "published_at": {
            "anyOf": [
              {
                "format": "date-time",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Published At"
          },
          "retrieved_at": {
            "anyOf": [
              {
                "format": "date-time",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Retrieved At"
          },
          "snapshot_sha256": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Snapshot Sha256"
          },
          "source_id": {
            "pattern": "^[a-z0-9][a-z0-9_-]{0,79}$",
            "title": "Source Id",
            "type": "string"
          },
          "source_url": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Source Url"
          },
          "state": {
            "enum": [
              "fresh",
              "stale",
              "missing",
              "invalid",
              "future"
            ],
            "title": "State",
            "type": "string"
          },
          "version": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Version"
          }
        },
        "required": [
          "source_id",
          "kind",
          "state"
        ],
        "title": "ScreeningCoverage",
        "type": "object"
      },
      "ScreeningIdentifier": {
        "additionalProperties": false,
        "description": "Scheme and issuing jurisdiction are part of an identifier's meaning.",
        "properties": {
          "country": {
            "anyOf": [
              {
                "maxLength": 500,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Country"
          },
          "scheme": {
            "maxLength": 500,
            "minLength": 1,
            "title": "Scheme",
            "type": "string"
          },
          "value": {
            "maxLength": 500,
            "minLength": 1,
            "title": "Value",
            "type": "string"
          }
        },
        "required": [
          "scheme",
          "value"
        ],
        "title": "ScreeningIdentifier",
        "type": "object"
      },
      "ScreeningKindResult": {
        "additionalProperties": false,
        "properties": {
          "coverage": {
            "items": {
              "$ref": "#/components/schemas/ScreeningCoverage"
            },
            "title": "Coverage",
            "type": "array"
          },
          "coverage_complete": {
            "title": "Coverage Complete",
            "type": "boolean"
          },
          "kind": {
            "enum": [
              "sanctions",
              "pep",
              "adverse_media"
            ],
            "title": "Kind",
            "type": "string"
          },
          "matches": {
            "items": {
              "$ref": "#/components/schemas/ScreeningMatch"
            },
            "title": "Matches",
            "type": "array"
          },
          "reasons": {
            "items": {
              "type": "string"
            },
            "title": "Reasons",
            "type": "array"
          },
          "state": {
            "enum": [
              "potential_match",
              "no_match",
              "not_screened"
            ],
            "title": "State",
            "type": "string"
          },
          "total_matches": {
            "title": "Total Matches",
            "type": "integer"
          },
          "truncated": {
            "title": "Truncated",
            "type": "boolean"
          }
        },
        "required": [
          "kind",
          "state",
          "coverage_complete",
          "reasons",
          "coverage",
          "matches",
          "total_matches",
          "truncated"
        ],
        "title": "ScreeningKindResult",
        "type": "object"
      },
      "ScreeningMatch": {
        "additionalProperties": false,
        "properties": {
          "adverse_events": {
            "items": {
              "$ref": "#/components/schemas/AdverseEvent"
            },
            "title": "Adverse Events",
            "type": "array"
          },
          "adverse_summary": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Adverse Summary"
          },
          "alias_quality": {
            "anyOf": [
              {
                "enum": [
                  "strong",
                  "weak",
                  "unspecified"
                ],
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Alias Quality"
          },
          "conflicting_evidence": {
            "items": {
              "type": "string"
            },
            "title": "Conflicting Evidence",
            "type": "array"
          },
          "entry_id": {
            "title": "Entry Id",
            "type": "string"
          },
          "listed_name": {
            "title": "Listed Name",
            "type": "string"
          },
          "match_basis": {
            "items": {
              "type": "string"
            },
            "title": "Match Basis",
            "type": "array"
          },
          "matched_name": {
            "title": "Matched Name",
            "type": "string"
          },
          "name_similarity": {
            "title": "Name Similarity",
            "type": "number"
          },
          "pep_roles": {
            "items": {
              "$ref": "#/components/schemas/PepRole"
            },
            "title": "Pep Roles",
            "type": "array"
          },
          "programs": {
            "items": {
              "type": "string"
            },
            "title": "Programs",
            "type": "array"
          },
          "requires_additional_identification": {
            "default": true,
            "title": "Requires Additional Identification",
            "type": "boolean"
          },
          "snapshot_version": {
            "title": "Snapshot Version",
            "type": "string"
          },
          "source_id": {
            "pattern": "^[a-z0-9][a-z0-9_-]{0,79}$",
            "title": "Source Id",
            "type": "string"
          },
          "source_url": {
            "title": "Source Url",
            "type": "string"
          },
          "subject_type": {
            "enum": [
              "organization",
              "person",
              "vessel",
              "aircraft",
              "unknown"
            ],
            "title": "Subject Type",
            "type": "string"
          }
        },
        "required": [
          "source_id",
          "snapshot_version",
          "entry_id",
          "listed_name",
          "subject_type",
          "matched_name",
          "name_similarity",
          "match_basis",
          "conflicting_evidence",
          "programs",
          "source_url",
          "pep_roles",
          "adverse_events"
        ],
        "title": "ScreeningMatch",
        "type": "object"
      },
      "ScreeningRequest": {
        "additionalProperties": false,
        "properties": {
          "aliases": {
            "items": {
              "maxLength": 500,
              "minLength": 1,
              "type": "string"
            },
            "maxItems": 20,
            "title": "Aliases",
            "type": "array"
          },
          "country": {
            "anyOf": [
              {
                "maxLength": 500,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Country"
          },
          "date_of_birth": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Date Of Birth"
          },
          "identifiers": {
            "items": {
              "$ref": "#/components/schemas/ScreeningIdentifier"
            },
            "maxItems": 20,
            "title": "Identifiers",
            "type": "array"
          },
          "kinds": {
            "items": {
              "enum": [
                "sanctions",
                "pep",
                "adverse_media"
              ],
              "type": "string"
            },
            "maxItems": 3,
            "minItems": 1,
            "title": "Kinds",
            "type": "array"
          },
          "max_matches_per_kind": {
            "default": 20,
            "maximum": 100.0,
            "minimum": 1.0,
            "title": "Max Matches Per Kind",
            "type": "integer"
          },
          "min_name_similarity": {
            "default": 0.82,
            "maximum": 1.0,
            "minimum": 0.65,
            "title": "Min Name Similarity",
            "type": "number"
          },
          "name": {
            "maxLength": 500,
            "minLength": 1,
            "title": "Name",
            "type": "string"
          },
          "sources": {
            "anyOf": [
              {
                "additionalProperties": {
                  "items": {
                    "pattern": "^[a-z0-9][a-z0-9_-]{0,79}$",
                    "type": "string"
                  },
                  "type": "array"
                },
                "propertyNames": {
                  "enum": [
                    "sanctions",
                    "pep",
                    "adverse_media"
                  ]
                },
                "type": "object"
              },
              {
                "type": "null"
              }
            ],
            "title": "Sources"
          },
          "subject_type": {
            "default": "organization",
            "enum": [
              "organization",
              "person",
              "vessel",
              "aircraft",
              "unknown"
            ],
            "title": "Subject Type",
            "type": "string"
          }
        },
        "required": [
          "name"
        ],
        "title": "ScreeningRequest",
        "type": "object"
      },
      "ScreeningResponse": {
        "additionalProperties": false,
        "properties": {
          "algorithm_version": {
            "default": "evidence-screening-v1",
            "title": "Algorithm Version",
            "type": "string"
          },
          "limitations": {
            "items": {
              "type": "string"
            },
            "title": "Limitations",
            "type": "array"
          },
          "results": {
            "items": {
              "$ref": "#/components/schemas/ScreeningKindResult"
            },
            "title": "Results",
            "type": "array"
          },
          "screened_at": {
            "format": "date-time",
            "title": "Screened At",
            "type": "string"
          }
        },
        "required": [
          "screened_at",
          "results"
        ],
        "title": "ScreeningResponse",
        "type": "object"
      },
      "SendMessage": {
        "additionalProperties": false,
        "properties": {
          "idempotency_key": {
            "maxLength": 128,
            "minLength": 8,
            "title": "Idempotency Key",
            "type": "string"
          },
          "message": {
            "maxLength": 4000,
            "minLength": 1,
            "title": "Message",
            "type": "string"
          }
        },
        "required": [
          "message",
          "idempotency_key"
        ],
        "title": "SendMessage",
        "type": "object"
      },
      "SnapshotConfidenceSource": {
        "description": "Where a frozen decision snapshot obtained match confidence.",
        "enum": [
          "no_binding",
          "decision_receipt",
          "unavailable"
        ],
        "title": "SnapshotConfidenceSource",
        "type": "string"
      },
      "SourceAccess": {
        "description": "How this deployment obtains access to the source.",
        "enum": [
          "public",
          "keyed_public",
          "commercial"
        ],
        "title": "SourceAccess",
        "type": "string"
      },
      "SourceCapabilitiesResponse": {
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "note": {
            "title": "Note",
            "type": "string"
          },
          "values": {
            "items": {
              "$ref": "#/components/schemas/SourceCapabilityValue"
            },
            "title": "Values",
            "type": "array"
          }
        },
        "required": [
          "values",
          "note",
          "correlation_id"
        ],
        "title": "SourceCapabilitiesResponse",
        "type": "object"
      },
      "SourceCapability": {
        "description": "Static connector contract, declared next to the adapter implementation.",
        "properties": {
          "access": {
            "$ref": "#/components/schemas/SourceAccess"
          },
          "attributes": {
            "default": [],
            "items": {
              "type": "string"
            },
            "title": "Attributes",
            "type": "array"
          },
          "credential_required": {
            "default": false,
            "title": "Credential Required",
            "type": "boolean"
          },
          "display_name": {
            "minLength": 1,
            "title": "Display Name",
            "type": "string"
          },
          "freshness_target_seconds": {
            "anyOf": [
              {
                "minimum": 0.0,
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Freshness Target Seconds"
          },
          "identifiers": {
            "default": [],
            "items": {
              "type": "string"
            },
            "title": "Identifiers",
            "type": "array"
          },
          "operations": {
            "items": {
              "$ref": "#/components/schemas/SourceOperation"
            },
            "title": "Operations",
            "type": "array"
          },
          "ownership_hops": {
            "default": 0,
            "minimum": 0.0,
            "title": "Ownership Hops",
            "type": "integer"
          },
          "post_match_enrichment": {
            "default": false,
            "title": "Post Match Enrichment",
            "type": "boolean"
          },
          "temporal_history": {
            "default": false,
            "title": "Temporal History",
            "type": "boolean"
          }
        },
        "required": [
          "display_name",
          "access",
          "operations"
        ],
        "title": "SourceCapability",
        "type": "object"
      },
      "SourceCapabilityValue": {
        "description": "A connector contract and its process-local observed state.",
        "properties": {
          "attribute_licences": {
            "additionalProperties": {
              "$ref": "#/components/schemas/LicenceTier"
            },
            "default": {},
            "title": "Attribute Licences",
            "type": "object"
          },
          "available_attributes": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Available Attributes"
          },
          "capability": {
            "$ref": "#/components/schemas/SourceCapability"
          },
          "configured": {
            "title": "Configured",
            "type": "boolean"
          },
          "countries": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Countries"
          },
          "licence": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/LicenceTier"
              },
              {
                "type": "null"
              }
            ]
          },
          "runtime": {
            "$ref": "#/components/schemas/SourceRuntimeStatus"
          },
          "source_id": {
            "title": "Source Id",
            "type": "string"
          },
          "source_kind": {
            "title": "Source Kind",
            "type": "string"
          }
        },
        "required": [
          "source_id",
          "source_kind",
          "configured",
          "capability",
          "runtime"
        ],
        "title": "SourceCapabilityValue",
        "type": "object"
      },
      "SourceComparisonRequest": {
        "additionalProperties": false,
        "properties": {
          "capture": {
            "default": false,
            "title": "Capture",
            "type": "boolean"
          },
          "capture_id": {
            "anyOf": [
              {
                "maxLength": 64,
                "minLength": 1,
                "pattern": "^[A-Za-z0-9_-]+$",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Capture Id"
          },
          "fields": {
            "items": {
              "type": "string"
            },
            "maxItems": 64,
            "minItems": 1,
            "title": "Fields",
            "type": "array"
          },
          "include_history": {
            "default": false,
            "title": "Include History",
            "type": "boolean"
          }
        },
        "required": [
          "fields"
        ],
        "title": "SourceComparisonRequest",
        "type": "object"
      },
      "SourceKind": {
        "description": "Where a fact came from \u2014 drives survivorship precedence.",
        "enum": [
          "registry",
          "filing",
          "web",
          "commercial",
          "customer",
          "reviewer",
          "inferred"
        ],
        "title": "SourceKind",
        "type": "string"
      },
      "SourceOperation": {
        "description": "Operations a connector can perform without implying data coverage.",
        "enum": [
          "exact_lookup",
          "candidate_search",
          "enrichment",
          "financial_history",
          "ownership"
        ],
        "title": "SourceOperation",
        "type": "string"
      },
      "SourceRuntimeState": {
        "description": "Locally observed state; this is not a synthetic upstream health probe.",
        "enum": [
          "disabled",
          "unobserved",
          "healthy",
          "degraded"
        ],
        "title": "SourceRuntimeState",
        "type": "string"
      },
      "SourceRuntimeStatus": {
        "description": "What this process has actually observed about one configured source.",
        "properties": {
          "attempts": {
            "default": 0,
            "minimum": 0.0,
            "title": "Attempts",
            "type": "integer"
          },
          "consecutive_failures": {
            "default": 0,
            "minimum": 0.0,
            "title": "Consecutive Failures",
            "type": "integer"
          },
          "failures": {
            "default": 0,
            "minimum": 0.0,
            "title": "Failures",
            "type": "integer"
          },
          "last_attempt_at": {
            "anyOf": [
              {
                "format": "date-time",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Last Attempt At"
          },
          "last_failure_at": {
            "anyOf": [
              {
                "format": "date-time",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Last Failure At"
          },
          "last_success_at": {
            "anyOf": [
              {
                "format": "date-time",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Last Success At"
          },
          "ready": {
            "title": "Ready",
            "type": "boolean"
          },
          "reason": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Reason"
          },
          "state": {
            "$ref": "#/components/schemas/SourceRuntimeState"
          },
          "successes": {
            "default": 0,
            "minimum": 0.0,
            "title": "Successes",
            "type": "integer"
          }
        },
        "required": [
          "state",
          "ready"
        ],
        "title": "SourceRuntimeStatus",
        "type": "object"
      },
      "StageUsageView": {
        "properties": {
          "calls": {
            "title": "Calls",
            "type": "integer"
          },
          "credits": {
            "title": "Credits",
            "type": "integer"
          },
          "stage": {
            "$ref": "#/components/schemas/DecisionStage"
          }
        },
        "required": [
          "stage",
          "calls",
          "credits"
        ],
        "title": "StageUsageView",
        "type": "object"
      },
      "StatementCriteria": {
        "additionalProperties": false,
        "properties": {
          "attributes": {
            "default": [],
            "items": {
              "maxLength": 128,
              "minLength": 12,
              "pattern": "^financials\\.[a-z][a-z0-9_]*$",
              "type": "string"
            },
            "maxItems": 64,
            "title": "Attributes",
            "type": "array"
          },
          "basis": {
            "anyOf": [
              {
                "enum": [
                  "reported",
                  "derived",
                  "estimated",
                  "average",
                  "point_in_time",
                  "unknown"
                ],
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Basis"
          },
          "currency": {
            "anyOf": [
              {
                "pattern": "^[A-Z]{3}$",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Currency"
          },
          "scope": {
            "anyOf": [
              {
                "enum": [
                  "legal_entity",
                  "consolidated_group",
                  "unknown"
                ],
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Scope"
          },
          "source_id": {
            "anyOf": [
              {
                "maxLength": 128,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Source Id"
          }
        },
        "title": "StatementCriteria",
        "type": "object"
      },
      "SubmittedRecordView": {
        "description": "One record as it was submitted, and its id.\n\nThe non-empty fields only, exactly as a review item renders a submission:\nthis is a triage view for deciding whether a record is the one an erasure\nrequest is about, not a second export format.",
        "properties": {
          "record_id": {
            "title": "Record Id",
            "type": "string"
          },
          "submitted_record": {
            "additionalProperties": {
              "type": "string"
            },
            "title": "Submitted Record",
            "type": "object"
          }
        },
        "required": [
          "record_id",
          "submitted_record"
        ],
        "title": "SubmittedRecordView",
        "type": "object"
      },
      "TenantListResponse": {
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "tenants": {
            "items": {
              "$ref": "#/components/schemas/TenantView"
            },
            "title": "Tenants",
            "type": "array"
          }
        },
        "required": [
          "tenants",
          "correlation_id"
        ],
        "title": "TenantListResponse",
        "type": "object"
      },
      "TenantView": {
        "description": "A tenant as its administrator may see it.",
        "properties": {
          "created_at": {
            "format": "date-time",
            "title": "Created At",
            "type": "string"
          },
          "name": {
            "title": "Name",
            "type": "string"
          },
          "parent_tenant_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Parent Tenant Id"
          },
          "plan": {
            "title": "Plan",
            "type": "string"
          },
          "tenant_id": {
            "title": "Tenant Id",
            "type": "string"
          }
        },
        "required": [
          "tenant_id",
          "name",
          "plan",
          "created_at"
        ],
        "title": "TenantView",
        "type": "object"
      },
      "TenhawCompanyCandidate": {
        "properties": {
          "company_record_id": {
            "title": "Company Record Id",
            "type": "string"
          },
          "country": {
            "title": "Country",
            "type": "string"
          },
          "domain": {
            "title": "Domain",
            "type": "string"
          },
          "employee_band": {
            "title": "Employee Band",
            "type": "string"
          },
          "industry": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Industry"
          },
          "name": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Name"
          },
          "services": {
            "items": {
              "type": "string"
            },
            "title": "Services",
            "type": "array"
          },
          "source_record_ref": {
            "title": "Source Record Ref",
            "type": "string"
          },
          "verification_status": {
            "const": "unverified",
            "default": "unverified",
            "title": "Verification Status",
            "type": "string"
          }
        },
        "required": [
          "company_record_id",
          "source_record_ref",
          "name",
          "domain",
          "industry",
          "services",
          "country",
          "employee_band"
        ],
        "title": "TenhawCompanyCandidate",
        "type": "object"
      },
      "TenhawReferenceResult": {
        "properties": {
          "build_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Build Id"
          },
          "candidates": {
            "default": [],
            "items": {
              "$ref": "#/components/schemas/TenhawCompanyCandidate"
            },
            "title": "Candidates",
            "type": "array"
          },
          "country": {
            "anyOf": [
              {
                "enum": [
                  "US",
                  "GB"
                ],
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Country"
          },
          "licence": {
            "const": "licensed",
            "default": "licensed",
            "title": "Licence",
            "type": "string"
          },
          "normalized_domain": {
            "title": "Normalized Domain",
            "type": "string"
          },
          "reason": {
            "anyOf": [
              {
                "enum": [
                  "not_configured",
                  "timeout",
                  "source_error",
                  "invalid_response"
                ],
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Reason"
          },
          "snapshot_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Snapshot Id"
          },
          "source": {
            "const": "tenhaw_market",
            "default": "tenhaw_market",
            "title": "Source",
            "type": "string"
          },
          "source_snapshot_date": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Source Snapshot Date"
          },
          "status": {
            "enum": [
              "candidates",
              "no_candidates",
              "unavailable"
            ],
            "title": "Status",
            "type": "string"
          },
          "truncated": {
            "default": false,
            "title": "Truncated",
            "type": "boolean"
          }
        },
        "required": [
          "status",
          "normalized_domain",
          "country"
        ],
        "title": "TenhawReferenceResult",
        "type": "object"
      },
      "TraversalGapView": {
        "description": "A hop this response did not take.",
        "properties": {
          "depth": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Depth"
          },
          "entity_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Entity Id"
          },
          "identifier": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Identifier"
          },
          "reason": {
            "title": "Reason",
            "type": "string"
          },
          "step": {
            "title": "Step",
            "type": "string"
          }
        },
        "required": [
          "step",
          "reason"
        ],
        "title": "TraversalGapView",
        "type": "object"
      },
      "UBOCandidateView": {
        "properties": {
          "includes_accounting_consolidation": {
            "default": false,
            "title": "Includes Accounting Consolidation",
            "type": "boolean"
          },
          "name": {
            "title": "Name",
            "type": "string"
          },
          "natures_of_control": {
            "items": {
              "type": "string"
            },
            "title": "Natures Of Control",
            "type": "array"
          },
          "notified_on": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Notified On"
          },
          "path": {
            "items": {
              "type": "string"
            },
            "title": "Path",
            "type": "array"
          },
          "path_relationships": {
            "items": {
              "type": "string"
            },
            "title": "Path Relationships",
            "type": "array"
          },
          "provenance": {
            "$ref": "#/components/schemas/ProvenanceView"
          },
          "source_entity_id": {
            "title": "Source Entity Id",
            "type": "string"
          },
          "valid_from": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Valid From"
          },
          "valid_to": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Valid To"
          }
        },
        "required": [
          "name",
          "source_entity_id",
          "provenance"
        ],
        "title": "UBOCandidateView",
        "type": "object"
      },
      "UltimateOwnerResponse": {
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "ultimate_owner": {
            "$ref": "#/components/schemas/UltimateOwnershipView"
          },
          "usage": {
            "$ref": "#/components/schemas/UsageView"
          }
        },
        "required": [
          "ultimate_owner",
          "correlation_id",
          "usage"
        ],
        "title": "UltimateOwnerResponse",
        "type": "object"
      },
      "UltimateOwnershipView": {
        "properties": {
          "accounting_ultimate_parents": {
            "items": {
              "$ref": "#/components/schemas/AccountingUltimateParentView"
            },
            "title": "Accounting Ultimate Parents",
            "type": "array"
          },
          "as_of": {
            "format": "date",
            "title": "As Of",
            "type": "string"
          },
          "calibrated_confidence": {
            "title": "Calibrated Confidence",
            "type": "null"
          },
          "conflicts": {
            "items": {
              "$ref": "#/components/schemas/IdentityGap"
            },
            "title": "Conflicts",
            "type": "array"
          },
          "coverage_complete": {
            "const": false,
            "default": false,
            "title": "Coverage Complete",
            "type": "boolean"
          },
          "cycles": {
            "items": {
              "$ref": "#/components/schemas/resolvd__api__routes__identity__OwnershipCycleView"
            },
            "title": "Cycles",
            "type": "array"
          },
          "entity_id": {
            "title": "Entity Id",
            "type": "string"
          },
          "external_lookup_performed": {
            "const": false,
            "default": false,
            "title": "External Lookup Performed",
            "type": "boolean"
          },
          "gaps": {
            "items": {
              "$ref": "#/components/schemas/IdentityGap"
            },
            "title": "Gaps",
            "type": "array"
          },
          "globally_verified": {
            "const": false,
            "default": false,
            "title": "Globally Verified",
            "type": "boolean"
          },
          "max_hops": {
            "title": "Max Hops",
            "type": "integer"
          },
          "observed_top_controllers": {
            "items": {
              "$ref": "#/components/schemas/ObservedControllerView"
            },
            "title": "Observed Top Controllers",
            "type": "array"
          },
          "organizational_ultimate_owners": {
            "items": {
              "$ref": "#/components/schemas/OrganizationalUltimateOwnerView"
            },
            "title": "Organizational Ultimate Owners",
            "type": "array"
          },
          "status": {
            "enum": [
              "not_available",
              "source_reported",
              "partial",
              "conflicting"
            ],
            "title": "Status",
            "type": "string"
          }
        },
        "required": [
          "entity_id",
          "as_of",
          "max_hops",
          "status",
          "organizational_ultimate_owners",
          "observed_top_controllers",
          "accounting_ultimate_parents",
          "gaps",
          "conflicts",
          "cycles"
        ],
        "title": "UltimateOwnershipView",
        "type": "object"
      },
      "UnboundRecordListResponse": {
        "description": "Records this tenant owns that belong to no entity.\n\nThe other half of enumeration. `GET /v1/entities` can only show what the\ncascade BOUND, so a submission that abstained or replayed appears in neither\nthe listing nor the export \u2014 and erasure per entity cannot reach it. These\nare those records, and `DELETE /v1/records/{record_id}` is how they go.",
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "items": {
            "items": {
              "$ref": "#/components/schemas/SubmittedRecordView"
            },
            "title": "Items",
            "type": "array"
          },
          "limit": {
            "title": "Limit",
            "type": "integer"
          },
          "offset": {
            "title": "Offset",
            "type": "integer"
          },
          "total": {
            "title": "Total",
            "type": "integer"
          },
          "usage": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/UsageView"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "required": [
          "items",
          "total",
          "limit",
          "offset",
          "correlation_id"
        ],
        "title": "UnboundRecordListResponse",
        "type": "object"
      },
      "UsageLimitationView": {
        "description": "A metric this report does not carry, and why it cannot.",
        "properties": {
          "metric": {
            "title": "Metric",
            "type": "string"
          },
          "reason": {
            "title": "Reason",
            "type": "string"
          }
        },
        "required": [
          "metric",
          "reason"
        ],
        "title": "UsageLimitationView",
        "type": "object"
      },
      "UsagePeriodView": {
        "description": "The window a usage report covers, half-open: [since, until).",
        "properties": {
          "days": {
            "title": "Days",
            "type": "number"
          },
          "since": {
            "format": "date-time",
            "title": "Since",
            "type": "string"
          },
          "until": {
            "format": "date-time",
            "title": "Until",
            "type": "string"
          }
        },
        "required": [
          "since",
          "until",
          "days"
        ],
        "title": "UsagePeriodView",
        "type": "object"
      },
      "UsageResponse": {
        "description": "One tenant's period over their own ledger.\n\nCarries what it can prove and names what it cannot: `not_measured` lists the\naccuracy metrics that are undefined per tenant, with the reason, so nothing\nhere can be mistaken for a precision claim.",
        "properties": {
          "abstention_rate": {
            "$ref": "#/components/schemas/IntervalView"
          },
          "abstentions": {
            "$ref": "#/components/schemas/AbstentionOutcomesView"
          },
          "automation_rate": {
            "$ref": "#/components/schemas/IntervalView"
          },
          "by_decision": {
            "items": {
              "$ref": "#/components/schemas/DecisionUsageView"
            },
            "title": "By Decision",
            "type": "array"
          },
          "by_endpoint": {
            "items": {
              "$ref": "#/components/schemas/EndpointUsageView"
            },
            "title": "By Endpoint",
            "type": "array"
          },
          "by_stage": {
            "items": {
              "$ref": "#/components/schemas/StageUsageView"
            },
            "title": "By Stage",
            "type": "array"
          },
          "calls": {
            "title": "Calls",
            "type": "integer"
          },
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "credits": {
            "$ref": "#/components/schemas/CreditUsageView"
          },
          "evaluation": {
            "anyOf": [
              {
                "additionalProperties": true,
                "type": "object"
              },
              {
                "type": "null"
              }
            ],
            "title": "Evaluation"
          },
          "not_measured": {
            "items": {
              "$ref": "#/components/schemas/UsageLimitationView"
            },
            "title": "Not Measured",
            "type": "array"
          },
          "period": {
            "$ref": "#/components/schemas/UsagePeriodView"
          },
          "usage": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/UsageView"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "required": [
          "period",
          "calls",
          "automation_rate",
          "abstention_rate",
          "credits",
          "by_stage",
          "by_decision",
          "by_endpoint",
          "abstentions",
          "not_measured",
          "correlation_id"
        ],
        "title": "UsageResponse",
        "type": "object"
      },
      "UsageView": {
        "description": "What this call cost and what is left (docs/COMMERCIAL-MODEL.md \u00a75.2).\n\nReturned on every response so charge-on-success is verifiable per call\nrather than being a claim on a pricing page. `enforced` is false while\nbilling runs in shadow mode: the figures are real, the deduction is not.",
        "properties": {
          "billing_enforced": {
            "default": false,
            "title": "Billing Enforced",
            "type": "boolean"
          },
          "credit_budget": {
            "anyOf": [
              {
                "additionalProperties": true,
                "type": "object"
              },
              {
                "type": "null"
              }
            ],
            "title": "Credit Budget"
          },
          "credits_charged": {
            "title": "Credits Charged",
            "type": "integer"
          },
          "credits_remaining": {
            "title": "Credits Remaining",
            "type": "integer"
          },
          "deep_attempts_remaining": {
            "title": "Deep Attempts Remaining",
            "type": "integer"
          },
          "enforced": {
            "title": "Enforced",
            "type": "boolean"
          },
          "evaluation": {
            "anyOf": [
              {
                "additionalProperties": true,
                "type": "object"
              },
              {
                "type": "null"
              }
            ],
            "title": "Evaluation"
          },
          "evaluation_enforced": {
            "default": false,
            "title": "Evaluation Enforced",
            "type": "boolean"
          },
          "plan": {
            "title": "Plan",
            "type": "string"
          }
        },
        "required": [
          "credits_charged",
          "credits_remaining",
          "deep_attempts_remaining",
          "plan",
          "enforced"
        ],
        "title": "UsageView",
        "type": "object"
      },
      "ValidationError": {
        "properties": {
          "ctx": {
            "title": "Context",
            "type": "object"
          },
          "input": {
            "title": "Input"
          },
          "loc": {
            "items": {
              "anyOf": [
                {
                  "type": "string"
                },
                {
                  "type": "integer"
                }
              ]
            },
            "title": "Location",
            "type": "array"
          },
          "msg": {
            "title": "Message",
            "type": "string"
          },
          "type": {
            "title": "Error Type",
            "type": "string"
          }
        },
        "required": [
          "loc",
          "msg",
          "type"
        ],
        "title": "ValidationError",
        "type": "object"
      },
      "ValuationInputEvidence": {
        "additionalProperties": false,
        "description": "Original supporting observations, never re-dated by our calculation.",
        "properties": {
          "complete_issuer_class_set_attestation": {
            "anyOf": [
              {
                "const": true,
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Complete Issuer Class Set Attestation"
          },
          "currency": {
            "anyOf": [
              {
                "pattern": "^[A-Z]{3}$",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Currency"
          },
          "measurement_at": {
            "anyOf": [
              {
                "format": "date-time",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Measurement At"
          },
          "measurement_date": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Measurement Date"
          },
          "month_end_closing_attestation": {
            "anyOf": [
              {
                "const": true,
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Month End Closing Attestation"
          },
          "price_basis": {
            "anyOf": [
              {
                "const": "unadjusted",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Price Basis"
          },
          "published_at": {
            "anyOf": [
              {
                "format": "date-time",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Published At"
          },
          "reference_date": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Reference Date"
          },
          "role": {
            "enum": [
              "closing_price",
              "outstanding_shares",
              "issuer_class_set"
            ],
            "title": "Role",
            "type": "string"
          },
          "share_basis": {
            "anyOf": [
              {
                "const": "outstanding",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Share Basis"
          },
          "share_class": {
            "anyOf": [
              {
                "maxLength": 2000,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Share Class"
          },
          "share_classes": {
            "items": {
              "maxLength": 2000,
              "minLength": 1,
              "type": "string"
            },
            "maxItems": 40,
            "title": "Share Classes",
            "type": "array"
          },
          "source": {
            "$ref": "#/components/schemas/FeedEvidence"
          },
          "valid_from": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Valid From"
          },
          "valid_to": {
            "anyOf": [
              {
                "format": "date",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Valid To"
          },
          "value": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Value"
          }
        },
        "required": [
          "role",
          "source"
        ],
        "title": "ValuationInputEvidence",
        "type": "object"
      },
      "VerdictView": {
        "description": "The adjudicator's structured verdict, when one was involved.",
        "properties": {
          "confidence": {
            "title": "Confidence",
            "type": "number"
          },
          "decision": {
            "$ref": "#/components/schemas/MatchDecisionType"
          },
          "model_id": {
            "title": "Model Id",
            "type": "string"
          },
          "prompt_version": {
            "title": "Prompt Version",
            "type": "string"
          },
          "rationale": {
            "title": "Rationale",
            "type": "string"
          }
        },
        "required": [
          "decision",
          "confidence",
          "rationale",
          "model_id",
          "prompt_version"
        ],
        "title": "VerdictView",
        "type": "object"
      },
      "VerificationFreshness": {
        "description": "Age of a cited source identity check, separate from binding confidence.\n\nA fresh check concerns a legal identifier and name, not every enriched field\nand not a new adjudication of the customer's link to that company.",
        "properties": {
          "expires_at": {
            "anyOf": [
              {
                "format": "date-time",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Expires At"
          },
          "refresh_attempted": {
            "default": false,
            "title": "Refresh Attempted",
            "type": "boolean"
          },
          "refreshed": {
            "default": false,
            "title": "Refreshed",
            "type": "boolean"
          },
          "source_ids": {
            "items": {
              "type": "string"
            },
            "title": "Source Ids",
            "type": "array"
          },
          "status": {
            "default": "unverified",
            "enum": [
              "fresh",
              "stale",
              "unverified"
            ],
            "title": "Status",
            "type": "string"
          },
          "verified_at": {
            "anyOf": [
              {
                "format": "date-time",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Verified At"
          }
        },
        "title": "VerificationFreshness",
        "type": "object"
      },
      "WatchPageRequest": {
        "additionalProperties": false,
        "properties": {
          "cursor": {
            "anyOf": [
              {
                "maxLength": 2048,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Cursor"
          },
          "interval_seconds": {
            "default": 86400,
            "maximum": 86400.0,
            "minimum": 300.0,
            "title": "Interval Seconds",
            "type": "integer"
          },
          "limit": {
            "default": 100,
            "maximum": 100.0,
            "minimum": 1.0,
            "title": "Limit",
            "type": "integer"
          }
        },
        "title": "WatchPageRequest",
        "type": "object"
      },
      "WatchRequest": {
        "additionalProperties": false,
        "properties": {
          "interval_seconds": {
            "default": 86400,
            "maximum": 86400.0,
            "minimum": 300.0,
            "title": "Interval Seconds",
            "type": "integer"
          }
        },
        "title": "WatchRequest",
        "type": "object"
      },
      "WatchView": {
        "properties": {
          "checked_at": {
            "format": "date-time",
            "title": "Checked At",
            "type": "string"
          },
          "created_at": {
            "format": "date-time",
            "title": "Created At",
            "type": "string"
          },
          "entity_id": {
            "title": "Entity Id",
            "type": "string"
          },
          "interval_seconds": {
            "title": "Interval Seconds",
            "type": "integer"
          },
          "next_check_at": {
            "format": "date-time",
            "title": "Next Check At",
            "type": "string"
          }
        },
        "required": [
          "entity_id",
          "interval_seconds",
          "created_at",
          "checked_at",
          "next_check_at"
        ],
        "title": "WatchView",
        "type": "object"
      },
      "WebhookCreate": {
        "additionalProperties": false,
        "properties": {
          "event_types": {
            "items": {
              "enum": [
                "batch.succeeded",
                "batch.failed",
                "batch.cancelled",
                "batch.reconciliation_required",
                "batch.erased",
                "entity.intelligence_changed"
              ],
              "type": "string"
            },
            "maxItems": 6,
            "minItems": 1,
            "title": "Event Types",
            "type": "array"
          },
          "url": {
            "description": "Public HTTPS destination, port 443; redirects are never followed.",
            "maxLength": 2048,
            "minLength": 1,
            "title": "Url",
            "type": "string"
          }
        },
        "required": [
          "url",
          "event_types"
        ],
        "title": "WebhookCreate",
        "type": "object"
      },
      "WebhookCreated": {
        "properties": {
          "active": {
            "title": "Active",
            "type": "boolean"
          },
          "created_at": {
            "title": "Created At",
            "type": "string"
          },
          "event_types": {
            "items": {
              "type": "string"
            },
            "title": "Event Types",
            "type": "array"
          },
          "signing_secret": {
            "description": "Standard Webhooks whsec_ secret; store securely. Returned on idempotent creation only.",
            "title": "Signing Secret",
            "type": "string"
          },
          "url": {
            "title": "Url",
            "type": "string"
          },
          "webhook_id": {
            "title": "Webhook Id",
            "type": "string"
          }
        },
        "required": [
          "webhook_id",
          "url",
          "event_types",
          "active",
          "created_at",
          "signing_secret"
        ],
        "title": "WebhookCreated",
        "type": "object"
      },
      "WebhookDeliveryView": {
        "properties": {
          "attempts": {
            "title": "Attempts",
            "type": "integer"
          },
          "delivery_id": {
            "title": "Delivery Id",
            "type": "string"
          },
          "event_id": {
            "title": "Event Id",
            "type": "string"
          },
          "last_error": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Last Error"
          },
          "last_status": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Last Status"
          },
          "next_attempt_at": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Next Attempt At"
          },
          "state": {
            "enum": [
              "pending",
              "delivering",
              "delivered",
              "failed",
              "cancelled"
            ],
            "title": "State",
            "type": "string"
          }
        },
        "required": [
          "delivery_id",
          "event_id",
          "state",
          "attempts",
          "next_attempt_at",
          "last_status",
          "last_error"
        ],
        "title": "WebhookDeliveryView",
        "type": "object"
      },
      "WebhookView": {
        "properties": {
          "active": {
            "title": "Active",
            "type": "boolean"
          },
          "created_at": {
            "title": "Created At",
            "type": "string"
          },
          "event_types": {
            "items": {
              "type": "string"
            },
            "title": "Event Types",
            "type": "array"
          },
          "url": {
            "title": "Url",
            "type": "string"
          },
          "webhook_id": {
            "title": "Webhook Id",
            "type": "string"
          }
        },
        "required": [
          "webhook_id",
          "url",
          "event_types",
          "active",
          "created_at"
        ],
        "title": "WebhookView",
        "type": "object"
      },
      "WithheldPairView": {
        "description": "Two of your rows we compared and deliberately did not merge.\n\nAn ABSTENTION at pair grain, not a verdict. Blocking proposed the pair, the\ncascade compared it, and policy would not admit the merge \u2014 so this says\nnothing about whether the two rows are the same company. Neither side was\ndecided, and a later submission carrying one more identifier may settle it.\n\nEvery pair is intra-batch: both record ids were rows of the request that\nreturned them.\n\n`probability` is the pair score and nothing bound, so this view carries no\n`match_confidence` and never will. A binding confidence on a comparison that\nbound nothing is the one number a reader would act on (ADR-0021).",
        "properties": {
          "decision_id": {
            "description": "The receipt for the comparison that was withheld. Redeem it at GET /v1/decisions/{decision_id} to see the evidence behind it.",
            "title": "Decision Id",
            "type": "string"
          },
          "left_client_ref": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Left Client Ref"
          },
          "left_record_id": {
            "title": "Left Record Id",
            "type": "string"
          },
          "probability": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "description": "The scorer's probability for this pair, or null when no score was produced. It is a pair score, not a confidence in any binding: nothing was merged.",
            "title": "Probability"
          },
          "reason_code": {
            "description": "Why the cascade could not call the pair: 'no_identifying_signal' (nothing comparable survived normalisation), 'deep_budget_exhausted' (the batch's deep-comparison budget ran out before this pair), 'depth_capped' (the requested depth stopped the pair short) or 'cascade_undecided' (the evidence itself was not conclusive). Only the first three are worth resubmitting.",
            "title": "Reason Code",
            "type": "string"
          },
          "review_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "description": "The queue item a reviewer will act on, pollable at GET /v1/review-queue/{review_id}. Null when `settled_by_cluster`.",
            "title": "Review Id"
          },
          "right_client_ref": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Right Client Ref"
          },
          "right_record_id": {
            "title": "Right Record Id",
            "type": "string"
          },
          "settled_by_cluster": {
            "default": false,
            "description": "True when other evidence in the same batch already placed these two rows, so the undecided pair needed no reviewer. False means it was routed to the review queue and `review_id` is set.",
            "title": "Settled By Cluster",
            "type": "boolean"
          },
          "stage": {
            "$ref": "#/components/schemas/DecisionStage"
          }
        },
        "required": [
          "left_record_id",
          "right_record_id",
          "stage",
          "decision_id",
          "reason_code"
        ],
        "title": "WithheldPairView",
        "type": "object"
      },
      "YahooImmediateValue": {
        "additionalProperties": false,
        "description": "A bounded raw provider observation, never a canonical financial fact.\n\nYahoo's quote currency and price timestamp do not prove the currency or\nvaluation instant of monetary totals. Those unknowns remain explicit.",
        "properties": {
          "attribute": {
            "enum": [
              "financials.market_cap",
              "financials.enterprise_value"
            ],
            "title": "Attribute",
            "type": "string"
          },
          "currency": {
            "anyOf": [
              {
                "pattern": "^[A-Z]{3}$",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Currency"
          },
          "missing_context_reasons": {
            "default": [],
            "items": {
              "maxLength": 2000,
              "minLength": 1,
              "type": "string"
            },
            "maxItems": 8,
            "title": "Missing Context Reasons",
            "type": "array"
          },
          "provider_as_of": {
            "anyOf": [
              {
                "format": "date-time",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Provider As Of"
          },
          "value": {
            "maximum": 1e+24,
            "minimum": -1e+24,
            "title": "Value",
            "type": "number"
          }
        },
        "required": [
          "attribute",
          "value"
        ],
        "title": "YahooImmediateValue",
        "type": "object"
      },
      "YahooObservationResult": {
        "additionalProperties": false,
        "description": "Immediate pass-through only; not SourceFindings, persisted facts or AI input.",
        "properties": {
          "authorization_reference": {
            "anyOf": [
              {
                "maxLength": 2000,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Authorization Reference"
          },
          "captured_at": {
            "anyOf": [
              {
                "format": "date-time",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Captured At"
          },
          "financial_currency": {
            "anyOf": [
              {
                "pattern": "^[A-Z]{3}$",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Financial Currency"
          },
          "licence": {
            "const": "pass_through",
            "default": "pass_through",
            "title": "Licence",
            "type": "string"
          },
          "mic": {
            "anyOf": [
              {
                "pattern": "^[A-Z0-9]{4}$",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Mic"
          },
          "missing_context_reasons": {
            "default": [],
            "items": {
              "maxLength": 2000,
              "minLength": 1,
              "type": "string"
            },
            "maxItems": 12,
            "title": "Missing Context Reasons",
            "type": "array"
          },
          "observations": {
            "default": [],
            "items": {
              "$ref": "#/components/schemas/YahooImmediateValue"
            },
            "maxItems": 2,
            "title": "Observations",
            "type": "array"
          },
          "provider": {
            "const": "Yahoo Finance",
            "default": "Yahoo Finance",
            "title": "Provider",
            "type": "string"
          },
          "provider_as_of": {
            "anyOf": [
              {
                "format": "date-time",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Provider As Of"
          },
          "provider_record_id": {
            "anyOf": [
              {
                "maxLength": 40,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Provider Record Id"
          },
          "quote_currency": {
            "anyOf": [
              {
                "pattern": "^(?:[A-Z]{3}|GBp)$",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Quote Currency"
          },
          "reason": {
            "anyOf": [
              {
                "maxLength": 2000,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Reason"
          },
          "resale_authorized": {
            "const": false,
            "default": false,
            "title": "Resale Authorized",
            "type": "boolean"
          },
          "source_id": {
            "const": "yahoo_finance",
            "default": "yahoo_finance",
            "title": "Source Id",
            "type": "string"
          },
          "source_url": {
            "anyOf": [
              {
                "format": "uri",
                "maxLength": 2083,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Source Url"
          },
          "statement_diagnostics": {
            "default": [],
            "items": {
              "$ref": "#/components/schemas/YahooStatementDiagnostic"
            },
            "maxItems": 4,
            "title": "Statement Diagnostics",
            "type": "array"
          },
          "statement_observations": {
            "default": [],
            "items": {
              "$ref": "#/components/schemas/YahooStatementValue"
            },
            "maxItems": 56,
            "title": "Statement Observations",
            "type": "array"
          },
          "statement_source_url": {
            "anyOf": [
              {
                "format": "uri",
                "maxLength": 2083,
                "minLength": 1,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Statement Source Url"
          },
          "status": {
            "enum": [
              "observed",
              "unavailable",
              "withheld"
            ],
            "title": "Status",
            "type": "string"
          },
          "storage_authorized": {
            "const": false,
            "default": false,
            "title": "Storage Authorized",
            "type": "boolean"
          },
          "symbol": {
            "anyOf": [
              {
                "pattern": "^[A-Z0-9][A-Z0-9.\\-^]{0,31}$",
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Symbol"
          }
        },
        "required": [
          "status"
        ],
        "title": "YahooObservationResult",
        "type": "object"
      },
      "YahooObservationsResponse": {
        "properties": {
          "correlation_id": {
            "title": "Correlation Id",
            "type": "string"
          },
          "entity_id": {
            "title": "Entity Id",
            "type": "string"
          },
          "yahoo": {
            "$ref": "#/components/schemas/YahooObservationResult"
          }
        },
        "required": [
          "entity_id",
          "yahoo",
          "correlation_id"
        ],
        "title": "YahooObservationsResponse",
        "type": "object"
      },
      "YahooStatementDiagnostic": {
        "additionalProperties": false,
        "description": "Closed method metadata only; no SDK exception or response fragments.",
        "properties": {
          "observation_count": {
            "default": 0,
            "maximum": 20.0,
            "minimum": 0.0,
            "title": "Observation Count",
            "type": "integer"
          },
          "period_count": {
            "default": 0,
            "maximum": 4.0,
            "minimum": 0.0,
            "title": "Period Count",
            "type": "integer"
          },
          "provider_frequency": {
            "enum": [
              "yearly",
              "quarterly"
            ],
            "title": "Provider Frequency",
            "type": "string"
          },
          "reason": {
            "enum": [
              "provider_statement_available",
              "provider_statement_empty",
              "provider_statement_failed",
              "provider_statement_invalid",
              "caller_stopped"
            ],
            "title": "Reason",
            "type": "string"
          },
          "statement": {
            "enum": [
              "income",
              "balance"
            ],
            "title": "Statement",
            "type": "string"
          },
          "status": {
            "enum": [
              "available",
              "empty",
              "unavailable",
              "stopped"
            ],
            "title": "Status",
            "type": "string"
          }
        },
        "required": [
          "statement",
          "provider_frequency",
          "status",
          "reason"
        ],
        "title": "YahooStatementDiagnostic",
        "type": "object"
      },
      "YahooStatementValue": {
        "additionalProperties": false,
        "description": "A raw statement cell and its provider label, not an admitted metric.\n\nA yearly/quarterly API label and a column date do not establish actual\nreporting boundaries, standalone scope, unit scale or EBITDA definition.",
        "properties": {
          "attribute": {
            "enum": [
              "financials.revenue",
              "financials.gross_profit",
              "financials.operating_profit",
              "financials.profit_loss",
              "financials.ebitda",
              "financials.total_assets",
              "financials.equity"
            ],
            "title": "Attribute",
            "type": "string"
          },
          "currency": {
            "title": "Currency",
            "type": "null"
          },
          "definition": {
            "title": "Definition",
            "type": "null"
          },
          "missing_context_reasons": {
            "items": {
              "enum": [
                "actual_period_start_not_established",
                "legal_entity_or_group_scope_not_established",
                "statement_currency_and_unit_scale_not_established",
                "ebitda_definition_not_established"
              ],
              "type": "string"
            },
            "maxItems": 4,
            "title": "Missing Context Reasons",
            "type": "array"
          },
          "period_kind": {
            "enum": [
              "duration",
              "instant"
            ],
            "title": "Period Kind",
            "type": "string"
          },
          "period_start": {
            "title": "Period Start",
            "type": "null"
          },
          "provider_frequency": {
            "enum": [
              "yearly",
              "quarterly"
            ],
            "title": "Provider Frequency",
            "type": "string"
          },
          "provider_period_end": {
            "format": "date",
            "title": "Provider Period End",
            "type": "string"
          },
          "scope": {
            "const": "unknown",
            "default": "unknown",
            "title": "Scope",
            "type": "string"
          },
          "unit": {
            "const": "unknown",
            "default": "unknown",
            "title": "Unit",
            "type": "string"
          },
          "value": {
            "maximum": 1e+24,
            "minimum": -1e+24,
            "title": "Value",
            "type": "number"
          }
        },
        "required": [
          "attribute",
          "value",
          "provider_frequency",
          "provider_period_end",
          "period_kind",
          "missing_context_reasons"
        ],
        "title": "YahooStatementValue",
        "type": "object"
      },
      "resolvd__api__routes__identity__OwnershipCycleView": {
        "properties": {
          "path": {
            "items": {
              "type": "string"
            },
            "title": "Path",
            "type": "array"
          },
          "repeated_entity_id": {
            "title": "Repeated Entity Id",
            "type": "string"
          }
        },
        "required": [
          "path",
          "repeated_entity_id"
        ],
        "title": "OwnershipCycleView",
        "type": "object"
      },
      "resolvd__api__schemas__OwnershipCycleView": {
        "properties": {
          "path": {
            "items": {
              "type": "string"
            },
            "title": "Path",
            "type": "array"
          },
          "repeated_entity_id": {
            "title": "Repeated Entity Id",
            "type": "string"
          }
        },
        "required": [
          "repeated_entity_id"
        ],
        "title": "OwnershipCycleView",
        "type": "object"
      }
    },
    "securitySchemes": {
      "BearerAuth": {
        "bearerFormat": "rk_ API key or OAuth access token",
        "description": "Send Authorization: Bearer <credential>. API-key scopes are disjoint; each operation's x-accepted-key-scopes list names the scopes accepted as alternatives. OAuth access tokens carry read or resolve permission; inspect the granted scope instead of assuming a write permission.",
        "scheme": "bearer",
        "type": "http",
        "x-key-scopes": [
          "read",
          "resolve",
          "review",
          "erase",
          "admin",
          "metrics",
          "operator"
        ]
      }
    }
  },
  "info": {
    "description": "Company entity resolution with an honest abstention tier.\n\n**Billing is charge-on-success.** A `match` or `no_match` costs credits; an\n`unresolved` outcome costs nothing at any stage, and a byte-identical\nre-submission is a free replay on every plan. Resolve, match and completed batch\nresponses carry the operation's `usage` receipt. A keyed retry returns that\noriginal receipt without a new ledger charge. Control and read operations state\ntheir billing rules on each operation below.\n\nEvery resolution returns a `decision_id`; `GET /v1/decisions/{decision_id}`\nreturns the features, thresholds, cited evidence and a replay of the score.\n`POST /v1/match` is stateless and mints no such receipt.\n",
    "title": "Resolvd API",
    "version": "2026.09.0"
  },
  "openapi": "3.1.0",
  "paths": {
    "/api/demo": {
      "get": {
        "operationId": "demo_index_api_demo_get",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "additionalProperties": true,
                  "title": "Response Demo Index Api Demo Get",
                  "type": "object"
                }
              }
            },
            "description": "Successful Response"
          }
        },
        "summary": "Demo Index",
        "tags": [
          "public documentation"
        ]
      }
    },
    "/api/demo/{case_id}": {
      "get": {
        "operationId": "demo_case_api_demo__case_id__get",
        "parameters": [
          {
            "in": "path",
            "name": "case_id",
            "required": true,
            "schema": {
              "title": "Case Id",
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "additionalProperties": true,
                  "title": "Response Demo Case Api Demo  Case Id  Get",
                  "type": "object"
                }
              }
            },
            "description": "Successful Response"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          }
        },
        "summary": "Demo Case",
        "tags": [
          "public documentation"
        ]
      }
    },
    "/api/docs": {
      "get": {
        "operationId": "public_docs_api_docs_get",
        "responses": {
          "200": {
            "content": {
              "text/html": {
                "schema": {
                  "type": "string"
                }
              }
            },
            "description": "Successful Response"
          }
        },
        "summary": "Public Docs",
        "tags": [
          "public documentation"
        ]
      }
    },
    "/api/evidence": {
      "get": {
        "operationId": "evidence_api_evidence_get",
        "responses": {
          "200": {
            "content": {
              "text/plain": {
                "schema": {
                  "type": "string"
                }
              }
            },
            "description": "Successful Response"
          }
        },
        "summary": "Evidence",
        "tags": [
          "public documentation"
        ]
      }
    },
    "/api/mcp": {
      "get": {
        "operationId": "public_mcp_guide_api_mcp_get",
        "responses": {
          "200": {
            "content": {
              "text/plain": {
                "schema": {
                  "type": "string"
                }
              }
            },
            "description": "Successful Response"
          }
        },
        "summary": "Public Mcp Guide",
        "tags": [
          "public documentation"
        ]
      }
    },
    "/api/mcp/tools.json": {
      "get": {
        "operationId": "public_mcp_catalogue_api_mcp_tools_json_get",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response"
          }
        },
        "summary": "Public Mcp Catalogue",
        "tags": [
          "public documentation"
        ]
      }
    },
    "/api/operations": {
      "get": {
        "operationId": "public_operations_guide_api_operations_get",
        "responses": {
          "200": {
            "content": {
              "text/plain": {
                "schema": {
                  "type": "string"
                }
              }
            },
            "description": "Successful Response"
          }
        },
        "summary": "Public Operations Guide",
        "tags": [
          "public documentation"
        ]
      }
    },
    "/api/pricing": {
      "get": {
        "operationId": "pricing_api_pricing_get",
        "responses": {
          "200": {
            "content": {
              "text/plain": {
                "schema": {
                  "type": "string"
                }
              }
            },
            "description": "Successful Response"
          }
        },
        "summary": "Pricing",
        "tags": [
          "public documentation"
        ]
      }
    },
    "/api/quickstart.txt": {
      "get": {
        "operationId": "quickstart_api_quickstart_txt_get",
        "responses": {
          "200": {
            "content": {
              "text/plain": {
                "schema": {
                  "type": "string"
                }
              }
            },
            "description": "Successful Response"
          }
        },
        "summary": "Quickstart",
        "tags": [
          "public documentation"
        ]
      }
    },
    "/api/sandbox": {
      "get": {
        "operationId": "public_sandbox_guide_api_sandbox_get",
        "responses": {
          "200": {
            "content": {
              "text/plain": {
                "schema": {
                  "type": "string"
                }
              }
            },
            "description": "Successful Response"
          }
        },
        "summary": "Public Sandbox Guide",
        "tags": [
          "public documentation"
        ]
      }
    },
    "/healthz": {
      "get": {
        "operationId": "healthz_healthz_get",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "additionalProperties": {
                    "type": "string"
                  },
                  "title": "Response Healthz Healthz Get",
                  "type": "object"
                }
              }
            },
            "description": "Successful Response"
          }
        },
        "summary": "Healthz",
        "tags": [
          "system"
        ]
      }
    },
    "/llms-full.txt": {
      "get": {
        "operationId": "agent_corpus_llms_full_txt_get",
        "responses": {
          "200": {
            "content": {
              "text/plain": {
                "schema": {
                  "type": "string"
                }
              }
            },
            "description": "Successful Response"
          }
        },
        "summary": "Agent Corpus",
        "tags": [
          "public documentation"
        ]
      }
    },
    "/llms.txt": {
      "get": {
        "operationId": "agent_index_llms_txt_get",
        "responses": {
          "200": {
            "content": {
              "text/plain": {
                "schema": {
                  "type": "string"
                }
              }
            },
            "description": "Successful Response"
          }
        },
        "summary": "Agent Index",
        "tags": [
          "public documentation"
        ]
      }
    },
    "/metrics": {
      "get": {
        "operationId": "metrics_metrics_get",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response"
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Metrics",
        "tags": [
          "system"
        ],
        "x-accepted-key-scopes": [
          "metrics"
        ]
      }
    },
    "/readyz": {
      "get": {
        "operationId": "readyz_readyz_get",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response"
          }
        },
        "summary": "Readyz",
        "tags": [
          "system"
        ]
      }
    },
    "/v1/admin/keys": {
      "get": {
        "description": "Every credential of one tenant you administer \u2014 metadata only.\n\nThere is no raw key here and there cannot be: only the SHA-256 digest is\nstored (EH-SEC-04). `active` answers revocation and rotation expiry together,\nso an inventory can be read without re-deriving the admission rule.\n\n**Billing:** free.",
        "operationId": "list_keys_v1_admin_keys_get",
        "parameters": [
          {
            "in": "query",
            "name": "tenant_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "title": "Tenant Id",
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ApiKeyListResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "List Keys",
        "tags": [
          "admin"
        ],
        "x-accepted-key-scopes": [
          "admin"
        ]
      },
      "post": {
        "description": "Mint a credential. **The raw key is in this response and nowhere else.**\n\nIt is not stored \u2014 only its digest is \u2014 so it cannot be re-read later, by us\nor by you. Persist it now; a lost key is rotated, never recovered.\n\n`plan` is capped at the tenant's own plan: an admin key is not a self-service\nupgrade button. `scope` defaults to `resolve`; minting an `admin` key\ndelegates provisioning of that tenant's subtree and nothing beyond it.\nDeployment-wide `operator` keys are not accepted here; only the local\nmaintenance CLI may issue or manage one.\n\n**Billing:** free.",
        "operationId": "create_key_v1_admin_keys_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CreateKeyRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "201": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/IssuedKeyResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Create Key",
        "tags": [
          "admin"
        ],
        "x-accepted-key-scopes": [
          "admin"
        ]
      }
    },
    "/v1/admin/keys/{key_id}": {
      "delete": {
        "description": "Kill a credential immediately.\n\nReturns the credential's resulting state rather than an empty 204: a caller\nrevoking under pressure wants to see `active: false` come back, not infer it.\nRevoking every key of a tenant is how a customer is suspended \u2014 there is no\nsecond `active` flag on the tenant to disagree with this one.\n\n**Billing:** free.",
        "operationId": "revoke_key_v1_admin_keys__key_id__delete",
        "parameters": [
          {
            "in": "path",
            "name": "key_id",
            "required": true,
            "schema": {
              "maxLength": 100,
              "title": "Key Id",
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ApiKeyView"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Revoke Key",
        "tags": [
          "admin"
        ],
        "x-accepted-key-scopes": [
          "admin"
        ]
      }
    },
    "/v1/admin/keys/{key_id}/rotate": {
      "post": {
        "description": "Issue a replacement credential and grace-expire this one.\n\nBoth keys authenticate until `superseded.expires_at`, so the replacement can\nbe rolled through a deploy without a window in which neither works. Pass\n`grace_seconds: 0` for a leaked credential \u2014 a grace window is precisely what\nyou do not want when the old key is the problem.\n\nThe replacement inherits this key's tenant, plan, scope and name: a rotation\nreplaces a credential, it does not re-provision one.\n\n**Billing:** free.",
        "operationId": "rotate_key_v1_admin_keys__key_id__rotate_post",
        "parameters": [
          {
            "in": "path",
            "name": "key_id",
            "required": true,
            "schema": {
              "maxLength": 100,
              "title": "Key Id",
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/RotateKeyRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/RotatedKeyResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Rotate Key",
        "tags": [
          "admin"
        ],
        "x-accepted-key-scopes": [
          "admin"
        ]
      }
    },
    "/v1/admin/oauth/grants": {
      "get": {
        "description": "Which connectors currently hold an authorization for one of your tenants.\n\nThe inventory a customer needs before they can revoke anything \u2014 without it,\n\"revocation that actually revokes\" is only reachable by a connector revoking\nits own token, which is not a control the owner holds.\n\n**Billing:** free.",
        "operationId": "list_oauth_grants_v1_admin_oauth_grants_get",
        "parameters": [
          {
            "in": "query",
            "name": "tenant_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "title": "Tenant Id",
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/OAuthGrantListResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "List Oauth Grants",
        "tags": [
          "admin"
        ],
        "x-accepted-key-scopes": [
          "admin"
        ]
      }
    },
    "/v1/admin/oauth/grants/{grant_id}": {
      "delete": {
        "description": "Kill one connector's authorization and every token descended from it.\n\nImmediate: access tokens are verified against the database on every call, so\nthere is no signed-token window in which a revoked connector keeps working.\n\n**Billing:** free.",
        "operationId": "revoke_oauth_grant_v1_admin_oauth_grants__grant_id__delete",
        "parameters": [
          {
            "in": "path",
            "name": "grant_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "title": "Grant Id",
              "type": "string"
            }
          },
          {
            "in": "query",
            "name": "tenant_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "title": "Tenant Id",
              "type": "string"
            }
          }
        ],
        "responses": {
          "204": {
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Revoke Oauth Grant",
        "tags": [
          "admin"
        ],
        "x-accepted-key-scopes": [
          "admin"
        ]
      }
    },
    "/v1/admin/oauth/install-tickets": {
      "post": {
        "description": "Mint the one-time ticket a person pastes to finish a connector install.\n\n**The ticket is in this response and nowhere else** \u2014 only its digest is\nstored, exactly like an API key. It is single-use, expires in minutes, and\nbinds the grant it authorizes to the tenant named here.\n\nThis is what makes a connector install possible without anyone typing an API\nkey into a third party's dialog. It is also the honest boundary of the OAuth\nbuild: Resolvd has no end-user identity system, so a ticket is how a *tenant*\nproves itself at the consent step, and everyone who can obtain one authorizes\nas that tenant rather than as themselves.\n\n**Billing:** free.",
        "operationId": "create_install_ticket_v1_admin_oauth_install_tickets_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CreateInstallTicketRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "201": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/InstallTicketResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Create Install Ticket",
        "tags": [
          "admin"
        ],
        "x-accepted-key-scopes": [
          "admin"
        ]
      }
    },
    "/v1/admin/tenants": {
      "get": {
        "description": "Your own tenant, followed by every tenant you have minted.\n\nThe OEM's customer list. A tenant you did not mint is absent rather than\nforbidden, so this can never be walked to discover another reseller's book.\n\n**Billing:** free.",
        "operationId": "list_tenants_v1_admin_tenants_get",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/TenantListResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "List Tenants",
        "tags": [
          "admin"
        ],
        "x-accepted-key-scopes": [
          "admin"
        ]
      },
      "post": {
        "description": "Mint a sub-tenant beneath yours \u2014 one end customer of a reseller.\n\nRequires a plan carrying resale rights, which is what that plan line now\nbuys. The new tenant's id is derived as `<your tenant>-<slug>`: a\ncaller-chosen id would make a 409 an oracle over every customer id in the\ndeployment. Its plan is capped at your own, because a reseller cannot sell\nmore product than they bought.\n\nA tenant has no keys until you mint one, and therefore no way in \u2014 the same\nproperty a fresh deployment has.\n\n**Billing:** free.",
        "operationId": "create_tenant_v1_admin_tenants_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CreateTenantRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "201": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/TenantView"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Create Tenant",
        "tags": [
          "admin"
        ],
        "x-accepted-key-scopes": [
          "admin"
        ]
      }
    },
    "/v1/batch": {
      "post": {
        "description": "Resolve up to `max_batch_size` records under one idempotency key.\n\nEach outcome carries its own `decision_id`, `client_ref` and \u2014 on an\nabstention \u2014 `review_id`, in request order.\n\n**Pairs.** A batch also compares your rows against each other, and two of\nthose comparisons produce no outcome row because nothing landed anywhere.\n`blocked_pairs` are merges we proposed and our own guard refused, naming the\nfields of yours that disagreed \u2014 the prevented merges. `withheld_pairs` are\npairs we compared and deliberately did not merge: an abstention, not a\nverdict that they are different companies. Both are capped, and\n`pair_disclosure` reports what was found against what was returned so a\ntruncated list is never mistaken for a complete one.\n\n**Billing:** each record is metered independently under the same rules as\n`/v1/resolve`; `usage.credits_charged` is the batch total. `depth` is per\nrecord, so a bulk batch can carry a handful of rows worth researching.",
        "operationId": "batch_v1_batch_post",
        "parameters": [
          {
            "in": "header",
            "name": "Idempotency-Key",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 200,
                  "minLength": 1,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Idempotency-Key"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/BatchRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/BatchResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Batch",
        "tags": [
          "resolution"
        ],
        "x-accepted-key-scopes": [
          "resolve"
        ]
      }
    },
    "/v1/batch-jobs": {
      "post": {
        "description": "Queue resolution and enrichment; a stable Idempotency-Key recovers the same job.\n\n**Billing:** submission is free. Execution uses the synchronous batch's\ncharge-on-success policy, plan limits and evaluation grant. Replays do not\nexecute or charge again. A worker must be running against the same database.",
        "operationId": "submit_job_v1_batch_jobs_post",
        "parameters": [
          {
            "in": "header",
            "name": "Idempotency-Key",
            "required": true,
            "schema": {
              "maxLength": 200,
              "minLength": 1,
              "title": "Idempotency-Key",
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/BatchRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "202": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/BatchJobView"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Submit Job",
        "tags": [
          "batch jobs"
        ],
        "x-accepted-key-scopes": [
          "resolve"
        ]
      }
    },
    "/v1/batch-jobs/{job_id}": {
      "get": {
        "description": "Read an owned job's lifecycle state. **Billing:** free.",
        "operationId": "get_job_v1_batch_jobs__job_id__get",
        "parameters": [
          {
            "in": "path",
            "name": "job_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "title": "Job Id",
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/BatchJobView"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Get Job",
        "tags": [
          "batch jobs"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/batch-jobs/{job_id}/cancel": {
      "post": {
        "description": "Cancel queued work; repeated cancellation is safe, running work conflicts.\n\n**Billing:** free. Cancellation does not reverse already-started execution.",
        "operationId": "cancel_job_v1_batch_jobs__job_id__cancel_post",
        "parameters": [
          {
            "in": "path",
            "name": "job_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "title": "Job Id",
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/BatchJobView"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Cancel Job",
        "tags": [
          "batch jobs"
        ],
        "x-accepted-key-scopes": [
          "resolve"
        ]
      }
    },
    "/v1/batch-jobs/{job_id}/events": {
      "get": {
        "description": "Stream durable lifecycle events; resume using Last-Event-ID after reconnect.\n\n**Billing:** free. Credentials are rechecked while streaming. Connections\nlast at most 60 seconds; reconnect to continue observing a running job.",
        "operationId": "job_events_v1_batch_jobs__job_id__events_get",
        "parameters": [
          {
            "in": "path",
            "name": "job_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "title": "Job Id",
              "type": "string"
            }
          },
          {
            "in": "header",
            "name": "Last-Event-ID",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Last-Event-Id"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "text/event-stream": {}
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Job Events",
        "tags": [
          "batch jobs"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/batch-jobs/{job_id}/result": {
      "get": {
        "description": "Read completed enrichments; pending jobs return 202 and Retry-After.\n\n**Billing:** free, including repeated reads. This never reruns resolution.",
        "operationId": "get_result_v1_batch_jobs__job_id__result_get",
        "parameters": [
          {
            "in": "path",
            "name": "job_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "title": "Job Id",
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/BatchResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "202": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/BatchJobView"
                }
              }
            },
            "description": "Accepted",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Get Result",
        "tags": [
          "batch jobs"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/company-reference/batch": {
      "post": {
        "description": "Read up to 100 company domains without invoking the resolution pipeline.\n\n**Billing:** zero resolution credits and zero AI calls. Each distinct valid\nnormalized domain/country uses the normal tenant read allowance, alongside\none batch admission. Duplicate rows remain separate in the response. At most\nfour warehouse lookups run at once, with a 30-second execution budget;\nunfinished rows explicitly return unavailable/request_deadline.\n\nExact domain lookup preserves shared-domain candidates, truncation, licence\nand original snapshot provenance. It neither verifies legal identity nor\nfills every enrichment field. Unsupported countries or unusable domains are\nexplicit row results rather than a source lookup or a false empty match.",
        "operationId": "lookup_company_reference_batch_v1_company_reference_batch_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CompanyReferenceBatchRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/CompanyReferenceBatchResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Lookup Company Reference Batch",
        "tags": [
          "company reference"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/company-reference/search": {
      "post": {
        "description": "Find up to 50 vendor company records by exact website hostname.\n\nOptional US/GB geography narrows discovery, not legal verification. No fuzzy\nname search or automatic merging. Source unavailability is an explicit result,\ndistinct from a successful lookup returning no candidates. Sends only the\nrequested hostname/country to our restricted company warehouse reader.\n\n**Billing:** no resolution credits; normal authenticated read limits apply.",
        "operationId": "search_company_reference_v1_company_reference_search_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CompanyReferenceQuery"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/CompanyReferenceResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Search Company Reference",
        "tags": [
          "company reference"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/crosswalk": {
      "post": {
        "description": "Resolve one identifier or name to every identifier the company is known by, each with its own citation, licence tier and freshness \u2014 plus the identifier systems that were asked and came back empty, and one hop of ownership.\n\n**Billing:** identical to `/v1/resolve`, because it *is* a resolve: 1 credit for a deterministic or probabilistic decision, 5 when adjudication or research was required, 0 for a replay and 0 for `unresolved`. The projection is free; you are charged for the match behind it, once.",
        "operationId": "crosswalk_v1_crosswalk_post",
        "parameters": [
          {
            "in": "header",
            "name": "Idempotency-Key",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 200,
                  "minLength": 1,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Idempotency-Key"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CrosswalkRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/CrosswalkResolveResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Crosswalk",
        "tags": [
          "crosswalk"
        ],
        "x-accepted-key-scopes": [
          "resolve"
        ]
      }
    },
    "/v1/crosswalk/{entity_id}": {
      "get": {
        "description": "Read the identifier crosswalk and one-hop ownership graph for an entity you already own.\n\n**Billing:** free. It is a projection of facts you already paid to resolve, and charging to look at your own data in a second shape is a fee for our response format.",
        "operationId": "entity_crosswalk_v1_crosswalk__entity_id__get",
        "parameters": [
          {
            "in": "path",
            "name": "entity_id",
            "required": true,
            "schema": {
              "maxLength": 100,
              "title": "Entity Id",
              "type": "string"
            }
          },
          {
            "in": "query",
            "name": "max_hops",
            "required": false,
            "schema": {
              "default": 1,
              "maximum": 10,
              "minimum": 1,
              "title": "Max Hops",
              "type": "integer"
            }
          },
          {
            "in": "query",
            "name": "as_of",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "format": "date",
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "As Of"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/CrosswalkResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Entity Crosswalk",
        "tags": [
          "crosswalk"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/data-selections": {
      "post": {
        "description": "**Billing:** No resolution credits are charged. These operations use retained company evidence and tenant-local workflow records; they make no provider or model calls. Plan access and the operation's rate quota still apply.",
        "operationId": "capture_selection_v1_data_selections_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CaptureRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Capture Selection",
        "tags": [
          "company workflows"
        ],
        "x-accepted-key-scopes": [
          "resolve"
        ]
      }
    },
    "/v1/data-selections/{receipt_id}": {
      "delete": {
        "description": "**Billing:** No resolution credits are charged. These operations use retained company evidence and tenant-local workflow records; they make no provider or model calls. Plan access and the operation's rate quota still apply.",
        "operationId": "delete_selection_v1_data_selections__receipt_id__delete",
        "parameters": [
          {
            "in": "path",
            "name": "receipt_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "title": "Receipt Id",
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Delete Selection",
        "tags": [
          "company workflows"
        ],
        "x-accepted-key-scopes": [
          "resolve"
        ]
      },
      "get": {
        "description": "**Billing:** No resolution credits are charged. These operations use retained company evidence and tenant-local workflow records; they make no provider or model calls. Plan access and the operation's rate quota still apply.",
        "operationId": "get_selection_v1_data_selections__receipt_id__get",
        "parameters": [
          {
            "in": "path",
            "name": "receipt_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "title": "Receipt Id",
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Get Selection",
        "tags": [
          "company workflows"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/decisions": {
      "get": {
        "description": "List decision receipts, newest first, filtered by the policy behind them.\n\nThe remediation read. \"Show me every decision taken under the threshold we\nhave since raised, or under the pipeline version we have since replaced\" is\na question a compliance buyer asks by name, and until now it could only be\nanswered one `decision_id` at a time. Every row already stored its\nthresholds and its `pipeline_version`; this is the index over them.\n\n`acting_key_id` is the four-eyes read: every decision one credential\napplied. A reviewer verdict records the key it arrived on and the surface it\ncame through, so \"which merges did this integration's key approve, and which\ndid a named analyst approve\" is answerable \u2014 the question a compliance buyer\nasks when an agent turns out to hold a key. Cascade decisions name no\ncredential and are never returned by it.\n\n`threshold_upper` matches the auto-merge threshold the call was judged\nagainst, exactly \u2014 the point is to find the population decided under a\nspecific policy, not a band. `decided_since`/`decided_until` are half-open\n`[since, until)`, so two adjacent windows partition without double-counting.\n\nNewest first, unlike the review queue: remediation works backwards from the\nchange that prompted it, while a queue must be worked oldest first so its\ntail cannot starve.\n\n**Billing:** free, exactly as reading one receipt is.",
        "operationId": "list_decisions_v1_decisions_get",
        "parameters": [
          {
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "default": 50,
              "minimum": 1,
              "title": "Limit",
              "type": "integer"
            }
          },
          {
            "in": "query",
            "name": "offset",
            "required": false,
            "schema": {
              "default": 0,
              "minimum": 0,
              "title": "Offset",
              "type": "integer"
            }
          },
          {
            "in": "query",
            "name": "pipeline_version",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 64,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Pipeline Version"
            }
          },
          {
            "in": "query",
            "name": "threshold_upper",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maximum": 1.0,
                  "minimum": 0.0,
                  "type": "number"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Threshold Upper"
            }
          },
          {
            "in": "query",
            "name": "decided_since",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "format": "date-time",
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Decided Since"
            }
          },
          {
            "in": "query",
            "name": "decided_until",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "format": "date-time",
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Decided Until"
            }
          },
          {
            "in": "query",
            "name": "acting_key_id",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 64,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Acting Key Id"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/DecisionListResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "List Decisions",
        "tags": [
          "decisions"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve",
          "review"
        ]
      }
    },
    "/v1/decisions/{decision_id}": {
      "get": {
        "description": "Read the full, replayable record of one decision.\n\n`replay.reproduced` is the check that matters: the scorer is re-run over the\nfeatures stored at decision time and the result compared with the stored\nprobability. It is null for a deterministic identifier match, which never\nreached the scorer, and `replay.pipeline_version_matches` says whether the\nweights doing the reproducing are the ones that decided.\n\nA decision belonging to another tenant reads as not-found, never as\nforbidden \u2014 a 403 would confirm the id exists.\n\n**Billing:** free. Auditing a decision you already paid for is not a second\ndecision, and charging for the evidence trail would price honesty.",
        "operationId": "get_decision_v1_decisions__decision_id__get",
        "parameters": [
          {
            "in": "path",
            "name": "decision_id",
            "required": true,
            "schema": {
              "maxLength": 100,
              "title": "Decision Id",
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/DecisionResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Get Decision",
        "tags": [
          "decisions"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve",
          "review"
        ]
      }
    },
    "/v1/decisions/{decision_id}/feedback": {
      "post": {
        "description": "Record customer evidence about this binding; never change company identity.\n\n**Billing:** free; no resolution credits or provider calls. Wrong-match reports\nname the receipt's rejected target automatically.\nThe existing immutable label event is returned on an identical keyed retry.",
        "operationId": "feedback_v1_decisions__decision_id__feedback_post",
        "parameters": [
          {
            "in": "path",
            "name": "decision_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "title": "Decision Id",
              "type": "string"
            }
          },
          {
            "in": "header",
            "name": "Idempotency-Key",
            "required": true,
            "schema": {
              "maxLength": 200,
              "minLength": 1,
              "title": "Idempotency-Key",
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/FeedbackRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "201": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/CustomerFeedbackResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Feedback",
        "tags": [
          "outcomes"
        ],
        "x-accepted-key-scopes": [
          "resolve"
        ]
      }
    },
    "/v1/entities": {
      "get": {
        "description": "Enumerate the entities you own, oldest first.\n\nThe catalogue you can page through, sync from and \u2014 because erasure is per\nentity \u2014 the only way to erase at scale. `updated_since` is the incremental\nsync filter: entities touched since your last run. `q` matches a substring of\na name, domain, website, registration number or LEI; `country` matches the\ncountry or jurisdiction.\n\n`total` counts the filtered set, not the page, so a caller knows whether they\nhave reached the end of their data or the end of a page.\n\nFollow `next_cursor` with the same filters to avoid skipped rows when earlier\nentities are erased. Do not combine cursor with a nonzero offset. Cursors\nare positions, never credentials; every page rechecks tenant authorization.\nThis is a live catalogue, so matches and totals can change between pages.\n\nOrdered by creation, oldest first, with the id as tie-break: a stable order\nis what makes paging safe when new entities are being resolved underneath.\n\n**Billing:** free. Reading back what you already paid to resolve is not a\nsecond resolution.",
        "operationId": "list_entities_v1_entities_get",
        "parameters": [
          {
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "default": 50,
              "minimum": 1,
              "title": "Limit",
              "type": "integer"
            }
          },
          {
            "in": "query",
            "name": "offset",
            "required": false,
            "schema": {
              "default": 0,
              "minimum": 0,
              "title": "Offset",
              "type": "integer"
            }
          },
          {
            "in": "query",
            "name": "updated_since",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "format": "date-time",
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Updated Since"
            }
          },
          {
            "in": "query",
            "name": "country",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 64,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Country"
            }
          },
          {
            "in": "query",
            "name": "q",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 500,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Q"
            }
          },
          {
            "in": "query",
            "name": "cursor",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 2048,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Cursor"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/EntityListResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "List Entities",
        "tags": [
          "entities"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/entities/export": {
      "get": {
        "description": "Stream every entity you own as NDJSON \u2014 one golden record per line.\n\nThe portability path (GDPR art. 20): the full record, every field's\nprovenance and the `member_record_ids` crosswalk back to your own rows, in a\nformat that is machine-readable and streams at any size. The same filters as\nthe listing apply, so an incremental export is `?updated_since=`.\n\nStreamed rather than paged into a JSON array because an export has no\nbounded size and neither end should have to hold it. There is no `usage`\nblock for the same reason \u2014 the response begins before the work finishes.\n\n**Billing:** free, and rate-limited as a batch. Charging to leave is the\nbehaviour this product is positioned against.",
        "operationId": "export_entities_v1_entities_export_get",
        "parameters": [
          {
            "in": "query",
            "name": "updated_since",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "format": "date-time",
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Updated Since"
            }
          },
          {
            "in": "query",
            "name": "country",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 64,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Country"
            }
          },
          {
            "in": "query",
            "name": "q",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 500,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Q"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/x-ndjson": {}
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Export Entities",
        "tags": [
          "entities"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/entities/query": {
      "post": {
        "description": "**Billing:** No resolution credits are charged. These operations use retained company evidence and tenant-local workflow records; they make no provider or model calls. Plan access and the operation's rate quota still apply.",
        "operationId": "query_companies_v1_entities_query_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CompanySearch"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Query Companies",
        "tags": [
          "company workflows"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/entities/reconcile": {
      "post": {
        "description": "Map natural identifiers back to the entity ids they name in this store.\n\nThe repair path for `entity_id`, which is a uuid4 minted per store: re-import\nyour catalogue into a fresh tenant and every id changes, so every foreign key\nyou published against the old ones dangles. Nothing about the companies\nchanged and nothing can be re-derived from them, because the ids were never a\nfunction of their content.\n\nSupply the identifiers you already store beside your foreign key \u2014 `lei`,\n`registration_number` (+`jurisdiction`), or `domain` \u2014 with your own\n`client_ref` on each, and get back the id that names that company here today.\nMatching is EXACT on the same normalized forms the cascade matches on, so a\nzero-padded company number still reconciles.\n\nA name is deliberately not accepted, and an identifier held by two entities\nreturns `ambiguous` rather than a pick. Reconciliation that guessed would\nsilently repoint a foreign key at the wrong company \u2014 strictly worse than an\nhonest miss, which you can re-resolve.\n\n**Billing:** free, and never metered. This is not a resolution; it reads back\nids you already paid for, and repairing them is not a second sale.",
        "operationId": "reconcile_entities_v1_entities_reconcile_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ReconcileRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ReconcileResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Reconcile Entities",
        "tags": [
          "entities"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/entities/search": {
      "get": {
        "description": "Ask whether this tenant already knows a company, without resolving it.\n\nCandidate retrieval over the same blocking keys the cascade uses: no\nscoring, no adjudication and \u2014 the point \u2014 **no writes**. `POST /v1/resolve`\nwas the only way to ask this question, and it mints a record and often an\nentity, so nobody could evaluate against production data without changing\nit. An empty page means no known entity shares an identifier or a name key\nwith the input; it is not a claim that the company is unknown to the world.\n\nResults are RANKED by the same calibrated scorer the cascade uses, best\nfirst, so the first hit is the likeliest company rather than whichever\nentity id sorted lowest. Ranking is not deciding: no probability is\nreturned, because a score against a triage query is not a match claim and\npublishing one here would invite callers to threshold it themselves.\n\nSupply at least one of name, domain, registration_number or lei. Country\nnarrows a query but cannot retrieve on its own.\n\n**Billing:** free, and never metered. Triage is not resolution.",
        "operationId": "search_entities_v1_entities_search_get",
        "parameters": [
          {
            "in": "query",
            "name": "name",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 500,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Name"
            }
          },
          {
            "in": "query",
            "name": "domain",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 253,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Domain"
            }
          },
          {
            "in": "query",
            "name": "registration_number",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 64,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Registration Number"
            }
          },
          {
            "in": "query",
            "name": "lei",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 20,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Lei"
            }
          },
          {
            "in": "query",
            "name": "country",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 64,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Country"
            }
          },
          {
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "default": 10,
              "minimum": 1,
              "title": "Limit",
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/EntitySearchResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Search Entities",
        "tags": [
          "entities"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/entities/{entity_id}": {
      "delete": {
        "description": "Hard-delete one entity and its facts \u2014 the erasure path (EH-GOV-01).\n\n**Billing:** free. Erasure is an obligation, not a product.",
        "operationId": "delete_entity_v1_entities__entity_id__delete",
        "parameters": [
          {
            "in": "path",
            "name": "entity_id",
            "required": true,
            "schema": {
              "maxLength": 100,
              "title": "Entity Id",
              "type": "string"
            }
          }
        ],
        "responses": {
          "204": {
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Delete Entity",
        "tags": [
          "entities"
        ],
        "x-accepted-key-scopes": [
          "erase"
        ]
      },
      "get": {
        "description": "Read a resolved entity, with per-field provenance and freshness.\n\n`member_record_ids` lists every submission bound to this entity, which is\nwhat lets a caller join the golden record back to their own rows.\n\n**Billing:** free. Reading back an entity you already paid to resolve is\nnot a second resolution.",
        "operationId": "get_entity_v1_entities__entity_id__get",
        "parameters": [
          {
            "in": "path",
            "name": "entity_id",
            "required": true,
            "schema": {
              "maxLength": 100,
              "title": "Entity Id",
              "type": "string"
            }
          },
          {
            "in": "query",
            "name": "fields",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "items": {
                    "type": "string"
                  },
                  "maxItems": 64,
                  "type": "array"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Fields"
            }
          },
          {
            "in": "query",
            "name": "field_packs",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "items": {
                    "type": "string"
                  },
                  "maxItems": 8,
                  "type": "array"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Field Packs"
            }
          },
          {
            "in": "query",
            "name": "include_field_status",
            "required": false,
            "schema": {
              "default": false,
              "title": "Include Field Status",
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/EntityResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Get Entity",
        "tags": [
          "entities"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/entities/{entity_id}/detach": {
      "post": {
        "description": "Detach one wrongly merged member into a fresh entity.\n\nThe operation is deliberately narrower than an arbitrary split: exactly one\nstored member moves, only facts carrying that record's immutable attribution\nmove with it, and both sides plus blocking keys, replay binding, customer\ncrosswalk and audit receipt commit atomically. Legacy facts whose contributor\nis unknown are refused rather than guessed.\n\n`reason` is required because this is a governed correction, not an automated\nresolution. The reviewer principal and key id are both derived from the\nseparately issued REVIEW credential; a supplied `reviewer_id` must match.\n\n**Billing:** free. Correcting an over-merge is not a second resolution.",
        "operationId": "detach_entity_record_v1_entities__entity_id__detach_post",
        "parameters": [
          {
            "in": "path",
            "name": "entity_id",
            "required": true,
            "schema": {
              "maxLength": 100,
              "title": "Entity Id",
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/DetachRecordRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/DetachRecordResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Detach Entity Record",
        "tags": [
          "entities"
        ],
        "x-accepted-key-scopes": [
          "review"
        ]
      }
    },
    "/v1/entities/{entity_id}/events": {
      "get": {
        "description": "Read committed watch changes after a cursor; values stay in /intelligence.\n\nRepeat `categories` to select any of the requested change kinds. Filtering\napplies to a scanned page: `next_cursor` advances even for an empty filtered\nresult. `scanned_count` counts scanned events, not returned events. Watches\ncompare local observations, not a complete upstream event history.\n\n**Billing:** free.",
        "operationId": "entity_events_v1_entities__entity_id__events_get",
        "parameters": [
          {
            "in": "path",
            "name": "entity_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "title": "Entity Id",
              "type": "string"
            }
          },
          {
            "in": "query",
            "name": "after_id",
            "required": false,
            "schema": {
              "default": 0,
              "maximum": 2147483647,
              "minimum": 0,
              "title": "After Id",
              "type": "integer"
            }
          },
          {
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "default": 100,
              "maximum": 100,
              "minimum": 1,
              "title": "Limit",
              "type": "integer"
            }
          },
          {
            "in": "query",
            "name": "categories",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "items": {
                    "$ref": "#/components/schemas/EntityChangeCategory"
                  },
                  "maxItems": 9,
                  "type": "array"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Categories"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/EntityEventsResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Entity Events",
        "tags": [
          "intelligence"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/entities/{entity_id}/financial-comparison": {
      "post": {
        "description": "**Billing:** No resolution credits are charged. These operations use retained company evidence and tenant-local workflow records; they make no provider or model calls. Plan access and the operation's rate quota still apply.",
        "operationId": "financial_comparison_v1_entities__entity_id__financial_comparison_post",
        "parameters": [
          {
            "in": "path",
            "name": "entity_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "title": "Entity Id",
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/FinancialComparisonRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Financial Comparison",
        "tags": [
          "company workflows"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/entities/{entity_id}/financial-selection": {
      "post": {
        "description": "**Billing:** No resolution credits are charged. These operations use retained company evidence and tenant-local workflow records; they make no provider or model calls. Plan access and the operation's rate quota still apply.",
        "operationId": "financial_selection_v1_entities__entity_id__financial_selection_post",
        "parameters": [
          {
            "in": "path",
            "name": "entity_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "title": "Entity Id",
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/FinancialSelectionRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Financial Selection",
        "tags": [
          "company workflows"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/entities/{entity_id}/financial-statements": {
      "get": {
        "description": "**Billing:** No resolution credits are charged. These operations use retained company evidence and tenant-local workflow records; they make no provider or model calls. Plan access and the operation's rate quota still apply.",
        "operationId": "financial_history_v1_entities__entity_id__financial_statements_get",
        "parameters": [
          {
            "in": "path",
            "name": "entity_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "title": "Entity Id",
              "type": "string"
            }
          },
          {
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "default": 100,
              "maximum": 100,
              "minimum": 1,
              "title": "Limit",
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Financial History",
        "tags": [
          "company workflows"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/entities/{entity_id}/identifier-history": {
      "get": {
        "description": "**Billing:** No resolution credits are charged. These operations use retained company evidence and tenant-local workflow records; they make no provider or model calls. Plan access and the operation's rate quota still apply.",
        "operationId": "identifier_history_v1_entities__entity_id__identifier_history_get",
        "parameters": [
          {
            "in": "path",
            "name": "entity_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "title": "Entity Id",
              "type": "string"
            }
          },
          {
            "in": "query",
            "name": "as_of",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "format": "date",
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "As Of"
            }
          },
          {
            "in": "query",
            "name": "after_id",
            "required": false,
            "schema": {
              "default": 0,
              "maximum": 9223372036854775807,
              "minimum": 0,
              "title": "After Id",
              "type": "integer"
            }
          },
          {
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "default": 100,
              "maximum": 100,
              "minimum": 1,
              "title": "Limit",
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Identifier History",
        "tags": [
          "company workflows"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/entities/{entity_id}/identity": {
      "get": {
        "description": "Project portable official-registry references, dated names and cited address roles from a tenant-owned entity. Public IDs are stable per registry identifier across tenant imports and renames; they are not a single globally verified entity ID. The same entity may have several public IDs, and conflicts are explicit. A public ID grants no cross-tenant access. Parent and subsidiary references stay separate. Headquarters, registered and mailing addresses never imply operating activity. Source freshness is returned on each observation. Historical names and identifiers are included through `as_of`; future-effective observations are excluded. **Billing:** free; reads existing facts only, with no external lookups or mutations.",
        "operationId": "entity_identity_v1_entities__entity_id__identity_get",
        "parameters": [
          {
            "in": "path",
            "name": "entity_id",
            "required": true,
            "schema": {
              "maxLength": 100,
              "minLength": 1,
              "title": "Entity Id",
              "type": "string"
            }
          },
          {
            "in": "query",
            "name": "as_of",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "format": "date",
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "As Of"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/IdentityResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Entity Identity",
        "tags": [
          "identity"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/entities/{entity_id}/intelligence": {
      "get": {
        "description": "Read current intelligence and its field provenance for an owned entity.\n\nRe-evaluates local authorized observations and temporal facts. Does not\ncontact any network source, run an LLM, persist facts or imply live coverage.\nA removed local observation is omitted, not replaced with its old saved copy.\n\n**Billing:** free.",
        "operationId": "get_intelligence_v1_entities__entity_id__intelligence_get",
        "parameters": [
          {
            "in": "path",
            "name": "entity_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "title": "Entity Id",
              "type": "string"
            }
          },
          {
            "in": "query",
            "name": "fields",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "items": {
                    "type": "string"
                  },
                  "maxItems": 64,
                  "type": "array"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Fields"
            }
          },
          {
            "in": "query",
            "name": "field_packs",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "items": {
                    "type": "string"
                  },
                  "maxItems": 8,
                  "type": "array"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Field Packs"
            }
          },
          {
            "in": "query",
            "name": "include_field_status",
            "required": false,
            "schema": {
              "default": true,
              "title": "Include Field Status",
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/IntelligenceResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Get Intelligence",
        "tags": [
          "intelligence"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/entities/{entity_id}/market-cap-history": {
      "get": {
        "description": "Read up to 60 completed calendar month ends before the as_of month. An available point requires a cited, explicitly month-end, unadjusted valuation of the requested issuer or share class, with its actual close, publication and capture dates. Unknown publication dates stay null. Quotes more than seven calendar days before month-end are stale; conflicts have no selected value. No interpolation, currency conversion, share-class aggregation or reconstruction from adjusted prices and current shares is performed. Missing data is not zero. **Billing:** free local read; no external, registry or AI calls.",
        "operationId": "entity_market_cap_history_v1_entities__entity_id__market_cap_history_get",
        "parameters": [
          {
            "in": "path",
            "name": "entity_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "title": "Entity Id",
              "type": "string"
            }
          },
          {
            "in": "query",
            "name": "months",
            "required": false,
            "schema": {
              "default": 60,
              "maximum": 60,
              "minimum": 1,
              "title": "Months",
              "type": "integer"
            }
          },
          {
            "in": "query",
            "name": "as_of",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "format": "date",
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "As Of"
            }
          },
          {
            "in": "query",
            "name": "scope",
            "required": false,
            "schema": {
              "default": "issuer",
              "enum": [
                "issuer",
                "share_class"
              ],
              "title": "Scope",
              "type": "string"
            }
          },
          {
            "in": "query",
            "name": "currency",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "pattern": "^[A-Z]{3}$",
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Currency"
            }
          },
          {
            "in": "query",
            "name": "share_class",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 2000,
                  "minLength": 1,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Share Class"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/MarketCapHistoryResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Entity Market Cap History",
        "tags": [
          "market capitalization"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/entities/{entity_id}/ownership-plan": {
      "get": {
        "description": "Walk existing tenant ownership facts and return bounded, cited next steps. A missing registry identifier produces a suggested `/v1/resolve` request; ambiguous, truncated or name-only references require evidence review. No suggested request is executed. Accounting consolidation is distinct from beneficial ownership; unknown registry coverage never establishes no owners. **Billing:** this plan is free. Executing a suggested resolve is a separate operation under the normal resolution and provider budget rules.",
        "operationId": "entity_ownership_plan_v1_entities__entity_id__ownership_plan_get",
        "parameters": [
          {
            "in": "path",
            "name": "entity_id",
            "required": true,
            "schema": {
              "maxLength": 100,
              "minLength": 1,
              "title": "Entity Id",
              "type": "string"
            }
          },
          {
            "in": "query",
            "name": "max_hops",
            "required": false,
            "schema": {
              "default": 3,
              "maximum": 10,
              "minimum": 1,
              "title": "Max Hops",
              "type": "integer"
            }
          },
          {
            "in": "query",
            "name": "as_of",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "format": "date",
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "As Of"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/OwnershipPlanResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Entity Ownership Plan",
        "tags": [
          "identity"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/entities/{entity_id}/source-comparison": {
      "post": {
        "description": "**Billing:** No resolution credits are charged. These operations use retained company evidence and tenant-local workflow records; they make no provider or model calls. Plan access and the operation's rate quota still apply.",
        "operationId": "source_comparison_v1_entities__entity_id__source_comparison_post",
        "parameters": [
          {
            "in": "path",
            "name": "entity_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "title": "Entity Id",
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/SourceComparisonRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Source Comparison",
        "tags": [
          "company workflows"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/entities/{entity_id}/ultimate-owner": {
      "get": {
        "description": "Read sourced organizational ultimate-owner assertions, bounded observed corporate-control paths and accounting-consolidation parent reports separately. Reports retain their effective dates and citations. A graph endpoint is never promoted to a verified global ultimate owner; unknown global coverage and conflicts stay explicit. Natural-person ownership is outside this company-only summary. **Billing:** free local reads, no provider calls, AI, resolution or writes.",
        "operationId": "entity_ultimate_owner_v1_entities__entity_id__ultimate_owner_get",
        "parameters": [
          {
            "in": "path",
            "name": "entity_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "title": "Entity Id",
              "type": "string"
            }
          },
          {
            "in": "query",
            "name": "max_hops",
            "required": false,
            "schema": {
              "default": 3,
              "maximum": 10,
              "minimum": 1,
              "title": "Max Hops",
              "type": "integer"
            }
          },
          {
            "in": "query",
            "name": "as_of",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "format": "date",
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "As Of"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/UltimateOwnerResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Entity Ultimate Owner",
        "tags": [
          "identity"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/entities/{entity_id}/watch": {
      "delete": {
        "description": "Disable a watch; safe to repeat. Already queued notifications remain deliverable.\n\n**Billing:** free.",
        "operationId": "delete_watch_v1_entities__entity_id__watch_delete",
        "parameters": [
          {
            "in": "path",
            "name": "entity_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "title": "Entity Id",
              "type": "string"
            }
          }
        ],
        "responses": {
          "204": {
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Delete Watch",
        "tags": [
          "intelligence"
        ],
        "x-accepted-key-scopes": [
          "resolve"
        ]
      },
      "get": {
        "description": "Read watch status, or null when disabled. **Billing:** free.",
        "operationId": "get_watch_v1_entities__entity_id__watch_get",
        "parameters": [
          {
            "in": "path",
            "name": "entity_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "title": "Entity Id",
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "anyOf": [
                    {
                      "$ref": "#/components/schemas/WatchView"
                    },
                    {
                      "type": "null"
                    }
                  ],
                  "title": "Response Get Watch V1 Entities  Entity Id  Watch Get"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Get Watch",
        "tags": [
          "intelligence"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      },
      "put": {
        "description": "Enable an idempotent watch of stored/local intelligence for this entity.\n\nThe worker compares observations at the requested interval (default daily,\nminimum five minutes). It never performs paid research or network enrichment.\nRegister entity.intelligence_changed on /v1/webhooks to receive changes.\nWatches coalesce changes between checks; they are not an upstream event log.\nRetries preserve the baseline. At most 1000 active watches per tenant.\nErasing this entity or a contributing record cancels its watch, clears its\nchange history and removes queued entity notifications. Re-enable explicitly\nto watch any surviving entity; a request already in flight may still arrive.\n\n**Billing:** free.",
        "operationId": "put_watch_v1_entities__entity_id__watch_put",
        "parameters": [
          {
            "in": "path",
            "name": "entity_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "title": "Entity Id",
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/WatchRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/WatchView"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Put Watch",
        "tags": [
          "intelligence"
        ],
        "x-accepted-key-scopes": [
          "resolve"
        ]
      }
    },
    "/v1/entities/{entity_id}/yahoo-observations": {
      "post": {
        "description": "Fetch return-only Yahoo values for this tenant's exact bound issuer.\n\nExplicit external access, with the batch rate-limit bucket and a maximum\n30-second caller deadline (or the shorter configured request deadline).\nNo resolution, AI, application credits, saved facts, result captures or\nartifacts. Includes market cap, enterprise value and seven raw financial\nstatement metrics with provider frequency and column dates. Unknown reporting\nboundaries, scope, currency, units and EBITDA definition remain explicit. This\nresponse is not retained for replay and does not establish storage or resale\nrights. A repeated POST performs a new bounded observation.\n\n**Billing:** free; consumes no application credits.",
        "operationId": "fetch_yahoo_observations_v1_entities__entity_id__yahoo_observations_post",
        "parameters": [
          {
            "in": "path",
            "name": "entity_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "title": "Entity Id",
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/YahooObservationsResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Fetch Yahoo Observations",
        "tags": [
          "supplier observations"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/evaluation": {
      "get": {
        "description": "Read lifetime balances, activation, expiry and configured capabilities for free.\n\nThis does not start validity or call providers. Balances are snapshots and\nreservations may change concurrently. A null evaluation means this tenant\nhas no grant. The recurring Free integration plan remains separate.\n\n**Billing:** free. Reading balances never consumes credits or attempts.",
        "operationId": "evaluation_v1_evaluation_get",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/EvaluationResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Evaluation",
        "tags": [
          "evaluation"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/evaluation/activate": {
      "post": {
        "description": "Exchange a trusted verifier's signed proof for an evaluation and scoped key.\n\nGated off until launch prerequisites and the verification integration are\nconfigured. This endpoint does not accept self-asserted verification or a\ntenant ID. Only the first completed activation returns the key; retries\nconverge on the same tenant/grant/key metadata without exposing it again.\n\n**Billing:** free. Verification and key issuance do not start grant validity.",
        "operationId": "activate_evaluation_v1_evaluation_activate_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/EvaluationActivationRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/EvaluationActivationResponse"
                }
              }
            },
            "description": "Successful Response"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          }
        },
        "summary": "Activate Evaluation",
        "tags": [
          "evaluation"
        ]
      }
    },
    "/v1/investigations": {
      "get": {
        "description": "List saved cases. **Billing:** free; no new agent turn is started.",
        "operationId": "list_investigations_v1_investigations_get",
        "parameters": [
          {
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "default": 50,
              "maximum": 100,
              "minimum": 1,
              "title": "Limit",
              "type": "integer"
            }
          },
          {
            "in": "query",
            "name": "offset",
            "required": false,
            "schema": {
              "default": 0,
              "minimum": 0,
              "title": "Offset",
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/InvestigationList"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "List Investigations",
        "tags": [
          "investigations"
        ],
        "x-accepted-key-scopes": [
          "resolve"
        ]
      },
      "post": {
        "description": "Start a tenant-owned unresolved-case investigation.\n\n**Billing:** agent usage is billed to the deployment's OpenAI project.\nEntityBind resolution tools consume the caller's existing credits; case\ncreation itself has no separate EntityBind credit charge.",
        "operationId": "create_v1_investigations_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CreateInvestigation"
              }
            }
          },
          "required": true
        },
        "responses": {
          "201": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/InvestigationView"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Create",
        "tags": [
          "investigations"
        ],
        "x-accepted-key-scopes": [
          "resolve"
        ]
      }
    },
    "/v1/investigations/capabilities": {
      "get": {
        "description": "Read deployment availability. **Billing:** free; no agent work is started.",
        "operationId": "capabilities_v1_investigations_capabilities_get",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Capabilities",
        "tags": [
          "investigations"
        ],
        "x-accepted-key-scopes": [
          "resolve"
        ]
      }
    },
    "/v1/investigations/{case_id}": {
      "delete": {
        "description": "Delete the remote session before removing its local ownership record.\n\n**Billing:** deletion is free and does not reverse charges already incurred.",
        "operationId": "delete_investigation_v1_investigations__case_id__delete",
        "parameters": [
          {
            "in": "path",
            "name": "case_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "title": "Case Id",
              "type": "string"
            }
          }
        ],
        "responses": {
          "204": {
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Delete Investigation",
        "tags": [
          "investigations"
        ],
        "x-accepted-key-scopes": [
          "resolve"
        ]
      },
      "get": {
        "description": "Recover saved research and verified receipts.\n\n**Billing:** free; this read starts no new agent turn or resolution call.",
        "operationId": "get_v1_investigations__case_id__get",
        "parameters": [
          {
            "in": "path",
            "name": "case_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "title": "Case Id",
              "type": "string"
            }
          },
          {
            "in": "query",
            "name": "after",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 200,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "After"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/InvestigationView"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Get",
        "tags": [
          "investigations"
        ],
        "x-accepted-key-scopes": [
          "resolve"
        ]
      }
    },
    "/v1/investigations/{case_id}/cancel": {
      "post": {
        "description": "Request that the provider stop the active turn.\n\n**Billing:** cancellation is free and does not undo charges or resolution\ncalls already completed.",
        "operationId": "cancel_v1_investigations__case_id__cancel_post",
        "parameters": [
          {
            "in": "path",
            "name": "case_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "title": "Case Id",
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/InvestigationView"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Cancel",
        "tags": [
          "investigations"
        ],
        "x-accepted-key-scopes": [
          "resolve"
        ]
      }
    },
    "/v1/investigations/{case_id}/messages": {
      "post": {
        "description": "Continue or steer a case with a bounded, idempotent message.\n\n**Billing:** new agent usage is billed to the deployment's OpenAI project;\nEntityBind resolution tools consume the caller's existing credits.",
        "operationId": "send_v1_investigations__case_id__messages_post",
        "parameters": [
          {
            "in": "path",
            "name": "case_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "title": "Case Id",
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/SendMessage"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/InvestigationView"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Send",
        "tags": [
          "investigations"
        ],
        "x-accepted-key-scopes": [
          "resolve"
        ]
      }
    },
    "/v1/labels": {
      "get": {
        "description": "List labels newest first, sliced for evaluation or active learning.\n\n**Billing:** free. Reading a tenant's own feedback corpus is a governance\noperation, not a resolution or external-data lookup.",
        "operationId": "list_labels_v1_labels_get",
        "parameters": [
          {
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "default": 50,
              "minimum": 1,
              "title": "Limit",
              "type": "integer"
            }
          },
          {
            "in": "query",
            "name": "offset",
            "required": false,
            "schema": {
              "default": 0,
              "minimum": 0,
              "title": "Offset",
              "type": "integer"
            }
          },
          {
            "in": "query",
            "name": "label",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "$ref": "#/components/schemas/ResolutionLabelValue"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Label"
            }
          },
          {
            "in": "query",
            "name": "source",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "$ref": "#/components/schemas/ResolutionLabelSource"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Source"
            }
          },
          {
            "in": "query",
            "name": "evidence_tier",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "$ref": "#/components/schemas/ComparisonEvidenceTier"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Evidence Tier"
            }
          },
          {
            "in": "query",
            "name": "record_id",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 64,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Record Id"
            }
          },
          {
            "in": "query",
            "name": "entity_id",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 64,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Entity Id"
            }
          },
          {
            "in": "query",
            "name": "model_id",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 255,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Model Id"
            }
          },
          {
            "in": "query",
            "name": "prompt_version",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 255,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Prompt Version"
            }
          },
          {
            "in": "query",
            "name": "pipeline_version",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 64,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Pipeline Version"
            }
          },
          {
            "in": "query",
            "name": "labelled_since",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "format": "date-time",
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Labelled Since"
            }
          },
          {
            "in": "query",
            "name": "labelled_until",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "format": "date-time",
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Labelled Until"
            }
          },
          {
            "in": "query",
            "name": "latest_only",
            "required": false,
            "schema": {
              "default": true,
              "title": "Latest Only",
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ResolutionLabelListResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "List Labels",
        "tags": [
          "labels"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve",
          "review"
        ]
      },
      "post": {
        "description": "Append one independently attributable customer/import label.\n\nReusing ``source_event_id`` with the same content is idempotent; reusing it\nwith different content is a 409. Corrections name ``supersedes_label_id``\nand append a revision\u2014the original row is never overwritten.\n\n**Billing:** free. Supplying correction data improves the resolver and does\nnot perform a resolution or consume external evidence.",
        "operationId": "submit_label_v1_labels_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ResolutionLabelSubmitRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "201": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ResolutionLabelResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Submit Label",
        "tags": [
          "labels"
        ],
        "x-accepted-key-scopes": [
          "resolve"
        ]
      }
    },
    "/v1/labels/export": {
      "get": {
        "description": "Export a reproducible JSONL label slice, oldest first.\n\nModel, prompt, pipeline, source and evidence-tier filters make the export a\ndirectly usable calibration population rather than a bag that must be\njoined back to decision logs. ``latest_only=false`` includes superseded\nrevisions for audit/reproduction; the default emits current truth only.\n\nA tenant's RESOLVE ingestion key or separately issued REVIEW key may read\nthis corpus. ADMIN keys are provisioning-only and cannot read customer\nrecords; ADMIN here is the lower-frequency *rate-limit class*, not an\nexpansion of that credential boundary.\n\n**Billing:** free. Exporting ground truth improves evaluation and model\ncalibration; it does not perform a resolution or call an external source.",
        "operationId": "export_labels_v1_labels_export_get",
        "parameters": [
          {
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "default": 10000,
              "maximum": 10000,
              "minimum": 1,
              "title": "Limit",
              "type": "integer"
            }
          },
          {
            "in": "query",
            "name": "offset",
            "required": false,
            "schema": {
              "default": 0,
              "minimum": 0,
              "title": "Offset",
              "type": "integer"
            }
          },
          {
            "in": "query",
            "name": "label",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "$ref": "#/components/schemas/ResolutionLabelValue"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Label"
            }
          },
          {
            "in": "query",
            "name": "source",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "$ref": "#/components/schemas/ResolutionLabelSource"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Source"
            }
          },
          {
            "in": "query",
            "name": "evidence_tier",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "$ref": "#/components/schemas/ComparisonEvidenceTier"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Evidence Tier"
            }
          },
          {
            "in": "query",
            "name": "record_id",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 64,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Record Id"
            }
          },
          {
            "in": "query",
            "name": "entity_id",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 64,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Entity Id"
            }
          },
          {
            "in": "query",
            "name": "model_id",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 255,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Model Id"
            }
          },
          {
            "in": "query",
            "name": "prompt_version",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 255,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Prompt Version"
            }
          },
          {
            "in": "query",
            "name": "pipeline_version",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 64,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Pipeline Version"
            }
          },
          {
            "in": "query",
            "name": "labelled_since",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "format": "date-time",
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Labelled Since"
            }
          },
          {
            "in": "query",
            "name": "labelled_until",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "format": "date-time",
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Labelled Until"
            }
          },
          {
            "in": "query",
            "name": "latest_only",
            "required": false,
            "schema": {
              "default": true,
              "title": "Latest Only",
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/x-ndjson": {}
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Export Labels",
        "tags": [
          "labels"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve",
          "review"
        ]
      }
    },
    "/v1/match": {
      "post": {
        "description": "Compare two records without writing anything.\n\nStateless by design: nothing is stored, so this endpoint mints no\n`record_id`, no `entity_id` and **no decision receipt** \u2014 there is no\n`decision_id` to fetch afterwards. Use `/v1/resolve` when the decision has\nto be auditable later.\n\nAn `unresolved` answer carries `depth_capped` and `escalation_unavailable`,\nwhich say which kind of \"cannot tell\" this is: your cap, our adjudicator\nbeing unavailable, or genuine ambiguity in the evidence. Only the first two\nare worth retrying.\n\n**Billing:** 1 credit for a `match`/`no_match` call, 5 if adjudication was\nneeded, 0 for `unresolved`. `depth` caps the pair the same way it caps a\nresolve.",
        "operationId": "match_v1_match_post",
        "parameters": [
          {
            "in": "header",
            "name": "Idempotency-Key",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 200,
                  "minLength": 1,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Idempotency-Key"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/MatchRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/MatchResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Match",
        "tags": [
          "resolution"
        ],
        "x-accepted-key-scopes": [
          "resolve"
        ]
      }
    },
    "/v1/outcomes": {
      "get": {
        "description": "Retained durable batch cohorts; acceptance and human feedback are not accuracy.\n\n**Billing:** free; no resolution credits or provider calls. UTC calendar dates\nare inclusive; omitted dates select the last 30 days.\nThe payload states retention, sampling, latency and credit-scope limitations.",
        "operationId": "outcomes_v1_outcomes_get",
        "parameters": [
          {
            "in": "query",
            "name": "since",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "format": "date",
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Since"
            }
          },
          {
            "in": "query",
            "name": "until",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "format": "date",
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Until"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/CustomerOutcomeResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Outcomes",
        "tags": [
          "outcomes"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/portfolios": {
      "get": {
        "description": "**Billing:** No resolution credits are charged. These operations use retained company evidence and tenant-local workflow records; they make no provider or model calls. Plan access and the operation's rate quota still apply.",
        "operationId": "list_portfolios_v1_portfolios_get",
        "parameters": [
          {
            "in": "query",
            "name": "cursor",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 2048,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Cursor"
            }
          },
          {
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "default": 50,
              "maximum": 100,
              "minimum": 1,
              "title": "Limit",
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "List Portfolios",
        "tags": [
          "company workflows"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      },
      "post": {
        "description": "**Billing:** No resolution credits are charged. These operations use retained company evidence and tenant-local workflow records; they make no provider or model calls. Plan access and the operation's rate quota still apply.",
        "operationId": "create_portfolio_v1_portfolios_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/PortfolioRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Create Portfolio",
        "tags": [
          "company workflows"
        ],
        "x-accepted-key-scopes": [
          "resolve"
        ]
      }
    },
    "/v1/portfolios/{portfolio_id}": {
      "delete": {
        "description": "**Billing:** No resolution credits are charged. These operations use retained company evidence and tenant-local workflow records; they make no provider or model calls. Plan access and the operation's rate quota still apply.",
        "operationId": "delete_portfolio_v1_portfolios__portfolio_id__delete",
        "parameters": [
          {
            "in": "path",
            "name": "portfolio_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "title": "Portfolio Id",
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Delete Portfolio",
        "tags": [
          "company workflows"
        ],
        "x-accepted-key-scopes": [
          "resolve"
        ]
      },
      "get": {
        "description": "**Billing:** No resolution credits are charged. These operations use retained company evidence and tenant-local workflow records; they make no provider or model calls. Plan access and the operation's rate quota still apply.",
        "operationId": "get_portfolio_v1_portfolios__portfolio_id__get",
        "parameters": [
          {
            "in": "path",
            "name": "portfolio_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "title": "Portfolio Id",
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Get Portfolio",
        "tags": [
          "company workflows"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      },
      "patch": {
        "description": "**Billing:** No resolution credits are charged. These operations use retained company evidence and tenant-local workflow records; they make no provider or model calls. Plan access and the operation's rate quota still apply.",
        "operationId": "rename_portfolio_v1_portfolios__portfolio_id__patch",
        "parameters": [
          {
            "in": "path",
            "name": "portfolio_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "title": "Portfolio Id",
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/PortfolioRename"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Rename Portfolio",
        "tags": [
          "company workflows"
        ],
        "x-accepted-key-scopes": [
          "resolve"
        ]
      }
    },
    "/v1/portfolios/{portfolio_id}/events": {
      "get": {
        "description": "**Billing:** No resolution credits are charged. These operations use retained company evidence and tenant-local workflow records; they make no provider or model calls. Plan access and the operation's rate quota still apply.",
        "operationId": "portfolio_events_v1_portfolios__portfolio_id__events_get",
        "parameters": [
          {
            "in": "path",
            "name": "portfolio_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "title": "Portfolio Id",
              "type": "string"
            }
          },
          {
            "in": "query",
            "name": "after_id",
            "required": false,
            "schema": {
              "default": 0,
              "maximum": 9223372036854775807,
              "minimum": 0,
              "title": "After Id",
              "type": "integer"
            }
          },
          {
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "default": 100,
              "maximum": 100,
              "minimum": 1,
              "title": "Limit",
              "type": "integer"
            }
          },
          {
            "in": "query",
            "name": "categories",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "items": {
                    "type": "string"
                  },
                  "maxItems": 16,
                  "type": "array"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Categories"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Portfolio Events",
        "tags": [
          "company workflows"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/portfolios/{portfolio_id}/export": {
      "get": {
        "description": "**Billing:** No resolution credits are charged. These operations use retained company evidence and tenant-local workflow records; they make no provider or model calls. Plan access and the operation's rate quota still apply.",
        "operationId": "portfolio_export_v1_portfolios__portfolio_id__export_get",
        "parameters": [
          {
            "in": "path",
            "name": "portfolio_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "title": "Portfolio Id",
              "type": "string"
            }
          },
          {
            "in": "query",
            "name": "cursor",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 2048,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Cursor"
            }
          },
          {
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "default": 100,
              "maximum": 100,
              "minimum": 1,
              "title": "Limit",
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Portfolio Export",
        "tags": [
          "company workflows"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/portfolios/{portfolio_id}/members": {
      "get": {
        "description": "**Billing:** No resolution credits are charged. These operations use retained company evidence and tenant-local workflow records; they make no provider or model calls. Plan access and the operation's rate quota still apply.",
        "operationId": "portfolio_members_v1_portfolios__portfolio_id__members_get",
        "parameters": [
          {
            "in": "path",
            "name": "portfolio_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "title": "Portfolio Id",
              "type": "string"
            }
          },
          {
            "in": "query",
            "name": "cursor",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 2048,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Cursor"
            }
          },
          {
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "default": 100,
              "maximum": 100,
              "minimum": 1,
              "title": "Limit",
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Portfolio Members",
        "tags": [
          "company workflows"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/portfolios/{portfolio_id}/members/{entity_id}": {
      "delete": {
        "description": "**Billing:** No resolution credits are charged. These operations use retained company evidence and tenant-local workflow records; they make no provider or model calls. Plan access and the operation's rate quota still apply.",
        "operationId": "remove_member_v1_portfolios__portfolio_id__members__entity_id__delete",
        "parameters": [
          {
            "in": "path",
            "name": "portfolio_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "title": "Portfolio Id",
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "entity_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "title": "Entity Id",
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Remove Member",
        "tags": [
          "company workflows"
        ],
        "x-accepted-key-scopes": [
          "resolve"
        ]
      },
      "put": {
        "description": "**Billing:** No resolution credits are charged. These operations use retained company evidence and tenant-local workflow records; they make no provider or model calls. Plan access and the operation's rate quota still apply.",
        "operationId": "put_member_v1_portfolios__portfolio_id__members__entity_id__put",
        "parameters": [
          {
            "in": "path",
            "name": "portfolio_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "title": "Portfolio Id",
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "entity_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "title": "Entity Id",
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/MemberRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Put Member",
        "tags": [
          "company workflows"
        ],
        "x-accepted-key-scopes": [
          "resolve"
        ]
      }
    },
    "/v1/portfolios/{portfolio_id}/watches": {
      "post": {
        "description": "**Billing:** No resolution credits are charged. These operations use retained company evidence and tenant-local workflow records; they make no provider or model calls. Plan access and the operation's rate quota still apply.",
        "operationId": "portfolio_watches_v1_portfolios__portfolio_id__watches_post",
        "parameters": [
          {
            "in": "path",
            "name": "portfolio_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "title": "Portfolio Id",
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/WatchPageRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Portfolio Watches",
        "tags": [
          "company workflows"
        ],
        "x-accepted-key-scopes": [
          "resolve"
        ]
      }
    },
    "/v1/records/by-ref/{client_ref}": {
      "get": {
        "description": "Find what happened to a row of YOUR data, by your own key for it.\n\n`client_ref` is the identifier you send on a resolve and get echoed back.\nUntil now it was echoed and never stored, so the join from a row in your CRM\nto the decision receipt behind it lived in whatever file you kept beside the\nimport \u2014 and two customers named reconstructing a merge eighteen months\nlater as the thing they were buying. This is that join, on our side.\n\nEach result carries the `record_id` we minted, the `decision_id` to redeem\nat `GET /v1/decisions/{id}`, the `entity_id` the row landed on and, when the\nsubmission abstained, the `review_id` of the queue item a human settled.\n\nAn unknown key returns an empty list rather than a 404: absence of a key is\nnot the same as a bad request, and a 404 here would confirm which keys exist\nfor whoever guessed one.\n\n**Billing:** free. Finding your own data is not a product.",
        "operationId": "records_by_client_ref_v1_records_by_ref__client_ref__get",
        "parameters": [
          {
            "in": "path",
            "name": "client_ref",
            "required": true,
            "schema": {
              "maxLength": 200,
              "title": "Client Ref",
              "type": "string"
            }
          },
          {
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "default": 50,
              "minimum": 1,
              "title": "Limit",
              "type": "integer"
            }
          },
          {
            "in": "query",
            "name": "offset",
            "required": false,
            "schema": {
              "default": 0,
              "minimum": 0,
              "title": "Offset",
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ClientRefResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Records By Client Ref",
        "tags": [
          "records"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/records/unbound": {
      "get": {
        "description": "Enumerate the records you submitted that no entity claims, oldest first.\n\nEverything the cascade did not bind: abstentions awaiting review, and\nsubmissions that replayed onto an entity whose member list they never\njoined. They hold your data verbatim and no entity id points at them, so\nwithout this listing the only way to erase one was to already know its\nrecord id.\n\n`total` counts the whole unbound set, not the page, so a caller working\nthrough an erasure request knows when they have finished.\n\n**Billing:** free. Enumerating what we hold about you is not a product.",
        "operationId": "list_unbound_records_v1_records_unbound_get",
        "parameters": [
          {
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "default": 50,
              "minimum": 1,
              "title": "Limit",
              "type": "integer"
            }
          },
          {
            "in": "query",
            "name": "offset",
            "required": false,
            "schema": {
              "default": 0,
              "minimum": 0,
              "title": "Offset",
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/UnboundRecordListResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "List Unbound Records",
        "tags": [
          "records"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/records/{record_id}": {
      "delete": {
        "description": "Erase one submitted record and the review queue's copies of it (EH-GOV-01).\n\nRemoves the record and its resolution labels, deletes any OPEN review item\nembedding it, and REDACTS any settled one \u2014 a verdict and who reached it are\nevidence that must survive, so the payload goes and the judgement stays,\nmarked `redacted_at`. The label deletion is unconditional and tenant scoped:\nit also reaches valid external/import ids for which no local record row was\nstored. The customer-key crosswalk for the record goes too: it holds an\nidentifier the caller chose for their own row, which is exactly the kind of\nthing an erasure request is about, and a pointer is not evidence of a\njudgement.\n\nThis does not erase an entity the record contributed to. A golden record\noutlives its members, and `DELETE /v1/entities/{id}` is the call that erases\nthe company; this one erases the submission.\n\n**Billing:** free. Erasure is an obligation, not a product.",
        "operationId": "delete_record_v1_records__record_id__delete",
        "parameters": [
          {
            "in": "path",
            "name": "record_id",
            "required": true,
            "schema": {
              "maxLength": 100,
              "title": "Record Id",
              "type": "string"
            }
          }
        ],
        "responses": {
          "204": {
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Delete Record",
        "tags": [
          "records"
        ],
        "x-accepted-key-scopes": [
          "erase"
        ]
      }
    },
    "/v1/reference/decisions": {
      "get": {
        "description": "The four outcomes, including what an abstention means.\n\n**Billing:** free, and deliberately so. Charging for the lookup that tells you how to call the API correctly taxes getting it right.",
        "operationId": "decisions_v1_reference_decisions_get",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ReferenceListResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Decisions",
        "tags": [
          "reference"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/reference/depths": {
      "get": {
        "description": "How far down the cascade each `depth` lets a call descend.\n\n**Billing:** free, and deliberately so. Charging for the lookup that tells you how to call the API correctly taxes getting it right.",
        "operationId": "depths_v1_reference_depths_get",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ReferenceListResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Depths",
        "tags": [
          "reference"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/reference/enrichment-fields": {
      "get": {
        "description": "Every enrichable field, its suppliers, configured availability and caller resale rights.\n\n**Billing:** free, and deliberately so. Charging for the lookup that tells you how to call the API correctly taxes getting it right.",
        "operationId": "enrichment_fields_v1_reference_enrichment_fields_get",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/EnrichmentFieldsResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Enrichment Fields",
        "tags": [
          "reference"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/reference/error-codes": {
      "get": {
        "description": "The complete error vocabulary, with the status each code arrives as.\n\n**Billing:** free, and deliberately so. Charging for the lookup that tells you how to call the API correctly taxes getting it right.",
        "operationId": "error_codes_v1_reference_error_codes_get",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorCodesResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Error Codes",
        "tags": [
          "reference"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/reference/identifiers": {
      "get": {
        "description": "The identifier schemes `/v1/crosswalk` maps between, and who supplies each.\n\n**Billing:** free, and deliberately so. Charging for the lookup that tells you how to call the API correctly taxes getting it right.",
        "operationId": "identifier_schemes_v1_reference_identifiers_get",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/IdentifierSchemesResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Identifier Schemes",
        "tags": [
          "reference"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/reference/jurisdictions": {
      "get": {
        "description": "Jurisdiction codes, and which of them get registry-backed candidates.\n\n**Billing:** free, and deliberately so. Charging for the lookup that tells you how to call the API correctly taxes getting it right.",
        "operationId": "jurisdictions_v1_reference_jurisdictions_get",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/JurisdictionsResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Jurisdictions",
        "tags": [
          "reference"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/reference/licences": {
      "get": {
        "description": "What each licence tier permits us to store and you to redistribute (ADR-0004). These describe the data, not your plan: whether you may exercise a redistribution right is the separate `resale_rights` term on `/v1/reference/limits`.\n\n**Billing:** free, and deliberately so. Charging for the lookup that tells you how to call the API correctly taxes getting it right.",
        "operationId": "licences_v1_reference_licences_get",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ReferenceListResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Licences",
        "tags": [
          "reference"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/reference/limits": {
      "get": {
        "description": "Every ceiling this deployment enforces, as it applies to your key.\n\n**Billing:** free, and deliberately so. Charging for the lookup that tells you how to call the API correctly taxes getting it right.",
        "operationId": "limits_v1_reference_limits_get",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/LimitsResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Limits",
        "tags": [
          "reference"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/reference/pricing": {
      "get": {
        "description": "The credit rule and the plan list, served from the constants that bill.\n\n**Billing:** free, and deliberately so. Charging for the lookup that tells you how to call the API correctly taxes getting it right.",
        "operationId": "pricing_v1_reference_pricing_get",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PricingResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Pricing",
        "tags": [
          "reference"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/reference/registries": {
      "get": {
        "description": "The evidence sources this deployment has actually wired in.\n\n**Billing:** free, and deliberately so. Charging for the lookup that tells you how to call the API correctly taxes getting it right.",
        "operationId": "registries_v1_reference_registries_get",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/RegistriesResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Registries",
        "tags": [
          "reference"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/reference/search-fields": {
      "get": {
        "description": "**Billing:** No resolution credits are charged. These operations use retained company evidence and tenant-local workflow records; they make no provider or model calls. Plan access and the operation's rate quota still apply.",
        "operationId": "search_fields_v1_reference_search_fields_get",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Search Fields",
        "tags": [
          "company workflows"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/reference/sources": {
      "get": {
        "description": "Machine-readable connector capabilities, readiness and locally observed health.\n\n**Billing:** free, and deliberately so. Charging for the lookup that tells you how to call the API correctly taxes getting it right.",
        "operationId": "source_capabilities_v1_reference_sources_get",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/SourceCapabilitiesResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Source Capabilities",
        "tags": [
          "reference"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/reference/stages": {
      "get": {
        "description": "The cascade stages a decision can be reached at.\n\n**Billing:** free, and deliberately so. Charging for the lookup that tells you how to call the API correctly taxes getting it right.",
        "operationId": "stages_v1_reference_stages_get",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ReferenceListResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Stages",
        "tags": [
          "reference"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/relationships/explain": {
      "post": {
        "description": "**Billing:** No resolution credits are charged. These operations use retained company evidence and tenant-local workflow records; they make no provider or model calls. Plan access and the operation's rate quota still apply.",
        "operationId": "relationship_paths_v1_relationships_explain_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/RelationshipRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Relationship Paths",
        "tags": [
          "company workflows"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/resolve": {
      "post": {
        "description": "Resolve one record.\n\nReturns `decision_id` \u2014 the receipt, readable back at\n`GET /v1/decisions/{decision_id}` \u2014 and, on an abstention, `review_id` plus\nthe ranked `candidates` the cascade could not choose between. `client_ref`\ncomes back verbatim so the answer can be joined to the row it came from.\n\nAn actionable `clarification` names typed answer fields and visible candidate\nclues. Resubmit your own corrected record with the same `client_ref` and\n`clarification_of={record_id, decision_id}` from the unresolved response.\nCandidate options are unverified alternatives. The new attempt runs normal\nverification, plan limits and billing; it never binds a chosen candidate directly.\n\n**Billing:** 1 credit for a deterministic or probabilistic decision, 5 for\none that required LLM adjudication or agentic research, 0 for a cache replay\nand 0 for `unresolved`. Cap the spend with `depth`.\nAn explicit quality profile can request fresh field research on a cached\nidentity; that new attempt uses the five-credit research rate.\n\n**Egress:** `depth=probabilistic` makes no external call of any kind, and\n`enrich=false` turns the registries off at any depth \u2014 deduplication against\nyour own store only, for callers whose contract forbids the lookup.",
        "operationId": "resolve_v1_resolve_post",
        "parameters": [
          {
            "in": "header",
            "name": "Idempotency-Key",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 200,
                  "minLength": 1,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Idempotency-Key"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ResolveRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ResolveResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Resolve",
        "tags": [
          "resolution"
        ],
        "x-accepted-key-scopes": [
          "resolve"
        ]
      }
    },
    "/v1/review-queue": {
      "get": {
        "description": "List queued abstentions, oldest first by default.\n\n`stage` separates \"the model could not tell\" from \"the caller capped the\ndepth\" \u2014 a reviewer works those differently. `evidence_tier` targets the\nsame identifier/corroborated/uncorroborated populations used by confidence\ncalibration, derived from the stored comparison features. `record_id` is\nthe migration join: a bulk import holds the record id of every abstained\nrow, and this is how that row reaches the queue item it produced.\n`min_confidence` drops items the cascade scored below the given probability;\nan item that never reached the scorer carries no probability and is dropped\nby any minimum at all.\n\n`sort=confidence_desc` is how a backlog gets worked by value rather than by\narrival: the items nearest the auto-merge band are the cheapest to confirm.\nOldest-first stays the default, because a queue worked any other way starves\nits tail and the tail is where the flywheel's labels are.\n\n`total` is the size of the FILTERED set \u2014 what `offset` walks against,\n`min_confidence` included \u2014 and `open_backlog` is the standing count of\nunworked items whatever slice is being read.\n\n**Billing:** free. Working your own abstention queue is what makes the\nsystem better; charging for it would be charging for our own tail.",
        "operationId": "list_review_queue_v1_review_queue_get",
        "parameters": [
          {
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "default": 50,
              "minimum": 1,
              "title": "Limit",
              "type": "integer"
            }
          },
          {
            "in": "query",
            "name": "offset",
            "required": false,
            "schema": {
              "default": 0,
              "minimum": 0,
              "title": "Offset",
              "type": "integer"
            }
          },
          {
            "in": "query",
            "name": "status",
            "required": false,
            "schema": {
              "$ref": "#/components/schemas/ReviewStatus",
              "default": "open"
            }
          },
          {
            "in": "query",
            "name": "stage",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "$ref": "#/components/schemas/DecisionStage"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Stage"
            }
          },
          {
            "in": "query",
            "name": "evidence_tier",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "$ref": "#/components/schemas/ComparisonEvidenceTier"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Evidence Tier"
            }
          },
          {
            "in": "query",
            "name": "record_id",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maxLength": 100,
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Record Id"
            }
          },
          {
            "in": "query",
            "name": "min_confidence",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "maximum": 1.0,
                  "minimum": 0.0,
                  "type": "number"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Min Confidence"
            }
          },
          {
            "in": "query",
            "name": "sort",
            "required": false,
            "schema": {
              "$ref": "#/components/schemas/ReviewSort",
              "default": "oldest_first"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ReviewQueueResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "List Review Queue",
        "tags": [
          "review"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve",
          "review"
        ]
      }
    },
    "/v1/review-queue/decisions": {
      "post": {
        "description": "Settle many abstentions in one call.\n\nOne HTTP round trip per item is not a queue anyone can work: an extrapolated\nbacklog runs to tens of thousands of items, and the review tier is the\nflywheel \u2014 a flywheel nobody can turn is a queue that only grows. A reviewer\nsweeps a filtered page (`sort=confidence_desc`, `min_confidence=\u2026`) and\nsettles it here.\n\n**Not transactional, on purpose.** Each verdict is applied by exactly the\npath a single one takes \u2014 same merge guard, same already-resolved gate, same\nreviewer requirement \u2014 and a failure is reported per item while the rest\nproceed. Rolling eighty verdicts back because a colleague settled the third\none first would discard labels a human already produced. `settled` and\n`failed` are the counts; every item carries either its resulting state or an\n`error.code` from the same vocabulary the single-item route raises.\n\nHTTP 200 even when every item failed: the request was processed, and the\nper-item results are the answer. Check the counts, not the status line.\n\n**Billing:** free, exactly as one verdict is.",
        "operationId": "submit_review_decisions_v1_review_queue_decisions_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/BulkReviewDecisionRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/BulkReviewDecisionResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Submit Review Decisions",
        "tags": [
          "review"
        ],
        "x-accepted-key-scopes": [
          "review"
        ]
      }
    },
    "/v1/review-queue/{review_id}": {
      "get": {
        "description": "Poll one abstention: what it was about, and whether it has been settled.\n\nA `/v1/resolve` that answers `unresolved` returns the `review_id` of the\nitem it queued. This is where that id is redeemed, so a caller can track\ntheir own abstention to a verdict instead of discovering it by re-resolving.\n\n**Billing:** free.",
        "operationId": "get_review_item_v1_review_queue__review_id__get",
        "parameters": [
          {
            "in": "path",
            "name": "review_id",
            "required": true,
            "schema": {
              "maxLength": 100,
              "title": "Review Id",
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ReviewItemView"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Get Review Item",
        "tags": [
          "review"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve",
          "review"
        ]
      }
    },
    "/v1/review-queue/{review_id}/decision": {
      "post": {
        "description": "Settle one abstention with a reviewer verdict.\n\n`applied` reports whether the verdict changed stored state: a candidate the\ncascade never stored has no entity to merge into, and saying so is the\ndifference between \"acted on\" and \"recorded\". When it is false,\n`blocked_reason` says which of those happened and `verdict_decision_id`\npoints at the audit row that recorded it.\n\nThe accountable reviewer is the authenticated REVIEW credential's immutable\nname. `reviewer_id`, when supplied for transition compatibility, must equal\nthat name; it can no longer manufacture an unauthenticated identity.\n\n**Billing:** free. The verdict is a label we want.",
        "operationId": "submit_review_decision_v1_review_queue__review_id__decision_post",
        "parameters": [
          {
            "in": "path",
            "name": "review_id",
            "required": true,
            "schema": {
              "maxLength": 100,
              "title": "Review Id",
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ReviewDecisionRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ReviewItemView"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Submit Review Decision",
        "tags": [
          "review"
        ],
        "x-accepted-key-scopes": [
          "review"
        ]
      }
    },
    "/v1/run-room/runs/{run_id}": {
      "get": {
        "description": "Read your run's stages and retained evidence metadata; no new research.\n\n**Billing:** free. This read does not submit work or invoke a provider.",
        "operationId": "get_run_room_v1_run_room_runs__run_id__get",
        "parameters": [
          {
            "in": "path",
            "name": "run_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "pattern": "^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$",
              "title": "Run Id",
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/RunRoomResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Get Run Room",
        "tags": [
          "run room"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/run-room/runs/{run_id}/artifacts/{artifact_id}/{kind}": {
      "get": {
        "description": "Download private literal evidence; no public bucket or signed URL.\n\n**Billing:** free. This read does not submit work or invoke a provider.",
        "operationId": "get_run_room_artifact_v1_run_room_runs__run_id__artifacts__artifact_id___kind__get",
        "parameters": [
          {
            "in": "path",
            "name": "run_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "pattern": "^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$",
              "title": "Run Id",
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "artifact_id",
            "required": true,
            "schema": {
              "maxLength": 64,
              "minLength": 1,
              "pattern": "^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$",
              "title": "Artifact Id",
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "kind",
            "required": true,
            "schema": {
              "enum": [
                "raw",
                "extracted",
                "markdown"
              ],
              "title": "Kind",
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Get Run Room Artifact",
        "tags": [
          "run room"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/screening": {
      "post": {
        "description": "Retrieve potential sanctions, PEP and adverse-media matches with explicit coverage.\n\n**Billing:** free; uses installed snapshots and never calls a paid provider.\nNo query or result is retained. Missing/stale coverage cannot produce a clear\nresult. Similarity scores are not calibrated probabilities or legal decisions.",
        "operationId": "screen_v1_screening_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ScreeningRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ScreeningResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Screen",
        "tags": [
          "screening"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/screening/coverage": {
      "get": {
        "description": "Inspect visible snapshot versions, freshness and source coverage. **Billing:** free.",
        "operationId": "coverage_v1_screening_coverage_get",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "items": {
                    "$ref": "#/components/schemas/ScreeningCoverage"
                  },
                  "title": "Response Coverage V1 Screening Coverage Get",
                  "type": "array"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Coverage",
        "tags": [
          "screening"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/usage": {
      "get": {
        "description": "Your automation rate, abstention rate, stage mix and credit spend, with intervals.\n\nEvery rate carries its 95% Wilson interval and the sample behind it: an\nautomation rate of 1.0 over nine calls and one over nine thousand are the\nsame number and not the same claim.\n\n`since` and `until` are dates read as UTC and applied half-open \u2014 `until`\ncovers the whole of that day \u2014 so two adjacent periods sum without\ndouble-counting. Omitted, the window is the billing period the quota is\nsummed over, so this report and the `usage` block beside it describe the\nsame span of time.\n\n**What this cannot tell you.** It cannot measure precision, and neither can\nany other view of your usage: review items are created only when the pipeline\nabstains, so reviewer verdicts label the *unresolved* band and the\nautomatically merged population carries no labels at all. `not_measured`\nnames each undecidable metric with the reason. What the same verdicts DO\nmeasure is lost automation \u2014 `abstentions.human_decidable_rate`, the share of\nthe abstentions a reviewer worked that a person could decide. Precision is\nmeasured against a labelled gold set (docs/ACCURACY.md), not against this.\n\n**Billing:** free. Charging a customer to see what they spent would be\nremarkable.",
        "operationId": "usage_v1_usage_get",
        "parameters": [
          {
            "in": "query",
            "name": "since",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "format": "date",
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Since"
            }
          },
          {
            "in": "query",
            "name": "until",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "format": "date",
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Until"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/UsageResponse"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Usage",
        "tags": [
          "usage"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    },
    "/v1/webhooks": {
      "get": {
        "description": "List the tenant's webhook registrations; signing secrets are omitted.\n\n**Billing:** free.",
        "operationId": "list_webhooks_v1_webhooks_get",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "items": {
                    "$ref": "#/components/schemas/WebhookView"
                  },
                  "title": "Response List Webhooks V1 Webhooks Get",
                  "type": "array"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "List Webhooks",
        "tags": [
          "webhooks"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      },
      "post": {
        "description": "Register a job or watched-entity subscription. Retries use the same key.\n\nDeliveries authenticate exact bytes with Standard Webhooks HMAC-SHA256.\nConsumers verify timestamp (five-minute tolerance), signature and event ID;\nacknowledge 2xx, deduplicate retries, then read results with their API key.\nReceivers get job ID/state or watched entity ID/changed attribute names,\nnever company values or credentials. Enable an entity watch separately;\nsigning up to entity events does not start research or create watches.\nFive attempts use bounded backoff; final failures remain inspectable.\n\n**Billing:** free. Registering or delivering a notification does not resolve\ncompanies or consume evaluation credits.",
        "operationId": "create_webhook_v1_webhooks_post",
        "parameters": [
          {
            "in": "header",
            "name": "Idempotency-Key",
            "required": true,
            "schema": {
              "maxLength": 200,
              "minLength": 1,
              "title": "Idempotency-Key",
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/WebhookCreate"
              }
            }
          },
          "required": true
        },
        "responses": {
          "201": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/WebhookCreated"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "413": {
            "$ref": "#/components/responses/PayloadTooLargeError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Create Webhook",
        "tags": [
          "webhooks"
        ],
        "x-accepted-key-scopes": [
          "resolve"
        ]
      }
    },
    "/v1/webhooks/{webhook_id}": {
      "delete": {
        "description": "Disable delivery and remove the stored URL; safe to repeat.\n\nCancels pending deliveries. A request already in flight cannot be recalled.\n\n**Billing:** free.",
        "operationId": "disable_webhook_v1_webhooks__webhook_id__delete",
        "parameters": [
          {
            "in": "path",
            "name": "webhook_id",
            "required": true,
            "schema": {
              "title": "Webhook Id",
              "type": "string"
            }
          }
        ],
        "responses": {
          "204": {
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Disable Webhook",
        "tags": [
          "webhooks"
        ],
        "x-accepted-key-scopes": [
          "resolve"
        ]
      }
    },
    "/v1/webhooks/{webhook_id}/deliveries": {
      "get": {
        "description": "Latest 100 delivery receipts, including retries and final failures.\n\n**Billing:** free.",
        "operationId": "webhook_deliveries_v1_webhooks__webhook_id__deliveries_get",
        "parameters": [
          {
            "in": "path",
            "name": "webhook_id",
            "required": true,
            "schema": {
              "title": "Webhook Id",
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "items": {
                    "$ref": "#/components/schemas/WebhookDeliveryView"
                  },
                  "title": "Response Webhook Deliveries V1 Webhooks  Webhook Id  Deliveries Get",
                  "type": "array"
                }
              }
            },
            "description": "Successful Response",
            "headers": {
              "RateLimit-Limit": {
                "description": "Capacity of this caller's token bucket.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Remaining": {
                "description": "Tokens remaining after this request.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "RateLimit-Reset": {
                "description": "Seconds until the bucket is full again.",
                "schema": {
                  "minimum": 0,
                  "type": "integer"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/UnauthorizedError"
          },
          "403": {
            "$ref": "#/components/responses/ForbiddenError"
          },
          "422": {
            "$ref": "#/components/responses/ValidationError"
          },
          "429": {
            "$ref": "#/components/responses/RateLimitError"
          },
          "default": {
            "$ref": "#/components/responses/ApiError"
          }
        },
        "security": [
          {
            "BearerAuth": []
          }
        ],
        "summary": "Webhook Deliveries",
        "tags": [
          "webhooks"
        ],
        "x-accepted-key-scopes": [
          "read",
          "resolve"
        ]
      }
    }
  },
  "x-resolvd-revision": {
    "offer_status": "planned",
    "pipeline_version": "2026.09.0",
    "route_schema_sha256": "59418f1d2119407b93d1c811f331efd68a9946afcd388027ff60b785c12d4356",
    "runtime_source_sha256": "0d79fffaa1c62b30e684cca56916629f30041593c5b6987b9d239e0a04af9412"
  }
}