openapi

type BadRequest = Error

type BadRequestJSONResponse Error

type BranchHead struct {
	// Head The content-addressed head claim id.
	Head string `json:"head"`
}

type BranchName = string

type CancelVerification200JSONResponse VerificationReport

type CancelVerification401JSONResponse struct{ UnauthorizedJSONResponse }

type CancelVerification403JSONResponse struct{ ForbiddenJSONResponse }

type CancelVerification404JSONResponse struct{ NotFoundJSONResponse }

type CancelVerificationRequestObject struct {
	ReportId string `json:"reportId"`
}

type CancelVerificationResponseObject interface {
	VisitCancelVerificationResponse(w http.ResponseWriter) error
}

type ClaimId = string

type Comparison struct {
	Eq   interface{}    `json:"eq,omitempty"`
	Ge   interface{}    `json:"ge,omitempty"`
	Glob *string        `json:"glob,omitempty"`
	Gt   interface{}    `json:"gt,omitempty"`
	In   *[]interface{} `json:"in,omitempty"`
	Le   interface{}    `json:"le,omitempty"`
	Lt   interface{}    `json:"lt,omitempty"`
	Ne   interface{}    `json:"ne,omitempty"`
}

type Conflict = Error

type ConflictJSONResponse Error

type Contribute201JSONResponse ContributionResult

type Contribute400JSONResponse struct{ BadRequestJSONResponse }

type Contribute401JSONResponse struct{ UnauthorizedJSONResponse }

type Contribute403JSONResponse struct{ ForbiddenJSONResponse }

type Contribute404JSONResponse struct{ NotFoundJSONResponse }

type Contribute409JSONResponse struct{ ConflictJSONResponse }

type ContributeRequestObject struct {
	Body io.Reader
}

type ContributeResponseObject interface {
	VisitContributeResponse(w http.ResponseWriter) error
}

type ContributionResult struct {
	// Head The new branch-table head id after the merge.
	Head string `json:"head"`

	// Ids Content-addressed ids of the contributed claims, in order.
	Ids []string `json:"ids"`
}

type DeleteVerification204Response struct {
}

type DeleteVerification401JSONResponse struct{ UnauthorizedJSONResponse }

type DeleteVerification403JSONResponse struct{ ForbiddenJSONResponse }

type DeleteVerification404JSONResponse struct{ NotFoundJSONResponse }

type DeleteVerificationRequestObject struct {
	ReportId string `json:"reportId"`
}

type DeleteVerificationResponseObject interface {
	VisitDeleteVerificationResponse(w http.ResponseWriter) error
}

type Error struct {
	// Code Machine-readable failure category, stable across releases — one of
	// unauthenticated, forbidden, not_found, conflict, busy, invalid,
	// unimplemented, internal. Clients branch on this, not on the message.
	Code string `json:"code"`

	// Error Human-readable message. Carries no subject id, even on 403.
	Error string `json:"error"`
}

type Execution struct {
	// Layer Pin execution to a named storage layer — any layer the stack composes —
	// instead of letting the planner choose which layer answers. The engine then
	// follows from that layer's capability (its native walk, or a Cypher/GQL
	// engine if it has one).
	Layer *string `json:"layer,omitempty"`

	// Report Execution-report verbosity: info (high-level stages), debug (routing and
	// lowering), or trace (per-claim detail). Absent, no report is produced; set,
	// the sequence's **final item** is a QueryReport.
	Report *ExecutionReport `json:"report,omitempty"`
}

type ExecutionReport string

type Forbidden = Error

type ForbiddenJSONResponse Error

type GetBranchClaim200ApplicationcborResponse struct {
	Body          io.Reader
	Headers       GetBranchClaim200ResponseHeaders
	ContentLength int64
}

type GetBranchClaim200ResponseHeaders struct {
	ETag *string
}

type GetBranchClaim401JSONResponse struct{ UnauthorizedJSONResponse }

type GetBranchClaim403JSONResponse struct{ ForbiddenJSONResponse }

type GetBranchClaim404JSONResponse struct{ NotFoundJSONResponse }

type GetBranchClaimContent200ApplicationoctetStreamResponse struct {
	Body          io.Reader
	Headers       GetBranchClaimContent200ResponseHeaders
	ContentLength int64
}

type GetBranchClaimContent200ResponseHeaders struct {
	ETag *string
}

type GetBranchClaimContent401JSONResponse struct{ UnauthorizedJSONResponse }

type GetBranchClaimContent403JSONResponse struct{ ForbiddenJSONResponse }

type GetBranchClaimContent404JSONResponse struct{ NotFoundJSONResponse }

type GetBranchClaimContentRequestObject struct {
	Branch BranchName `json:"branch"`
	Id     ClaimId    `json:"id"`
}

type GetBranchClaimContentResponseObject interface {
	VisitGetBranchClaimContentResponse(w http.ResponseWriter) error
}

type GetBranchClaimRequestObject struct {
	Branch BranchName `json:"branch"`
	Id     ClaimId    `json:"id"`
}

type GetBranchClaimResponseObject interface {
	VisitGetBranchClaimResponse(w http.ResponseWriter) error
}

type GetBranchHead200JSONResponse struct {
	Body    BranchHead
	Headers GetBranchHead200ResponseHeaders
}

type GetBranchHead200ResponseHeaders struct {
	ETag *string
}

type GetBranchHead401JSONResponse struct{ UnauthorizedJSONResponse }

type GetBranchHead403JSONResponse struct{ ForbiddenJSONResponse }

type GetBranchHead404JSONResponse struct{ NotFoundJSONResponse }

type GetBranchHeadRequestObject struct {
	Branch BranchName `json:"branch"`
}

type GetBranchHeadResponseObject interface {
	VisitGetBranchHeadResponse(w http.ResponseWriter) error
}

type GetUniverseClaim200ApplicationcborResponse struct {
	Body          io.Reader
	Headers       GetUniverseClaim200ResponseHeaders
	ContentLength int64
}

type GetUniverseClaim200ResponseHeaders struct {
	ETag *string
}

type GetUniverseClaim401JSONResponse struct{ UnauthorizedJSONResponse }

type GetUniverseClaim403JSONResponse struct{ ForbiddenJSONResponse }

type GetUniverseClaim404JSONResponse struct{ NotFoundJSONResponse }

type GetUniverseClaimContent200ApplicationoctetStreamResponse struct {
	Body          io.Reader
	Headers       GetUniverseClaimContent200ResponseHeaders
	ContentLength int64
}

type GetUniverseClaimContent200ResponseHeaders struct {
	ETag *string
}

type GetUniverseClaimContent401JSONResponse struct{ UnauthorizedJSONResponse }

type GetUniverseClaimContent403JSONResponse struct{ ForbiddenJSONResponse }

type GetUniverseClaimContent404JSONResponse struct{ NotFoundJSONResponse }

type GetUniverseClaimContentRequestObject struct {
	Id ClaimId `json:"id"`
}

type GetUniverseClaimContentResponseObject interface {
	VisitGetUniverseClaimContentResponse(w http.ResponseWriter) error
}

type GetUniverseClaimRequestObject struct {
	Id ClaimId `json:"id"`
}

type GetUniverseClaimResponseObject interface {
	VisitGetUniverseClaimResponse(w http.ResponseWriter) error
}

type GetVerification200JSONResponse struct {
	Body    VerificationReport
	Headers GetVerification200ResponseHeaders
}

type GetVerification200ResponseHeaders struct {
	RetryAfter *int
}

type GetVerification401JSONResponse struct{ UnauthorizedJSONResponse }

type GetVerification403JSONResponse struct{ ForbiddenJSONResponse }

type GetVerification404JSONResponse struct{ NotFoundJSONResponse }

type GetVerificationRequestObject struct {
	ReportId string `json:"reportId"`
}

type GetVerificationResponseObject interface {
	VisitGetVerificationResponse(w http.ResponseWriter) error
}

type Health struct {
	// Signer The contributor identity this stack signs merges with.
	//
	// Example: did:key:z6Mk...
	Signer *string `json:"signer,omitempty"`

	// Status Example: ok
	Status string `json:"status"`
}

type Health200JSONResponse Health

type HealthRequestObject struct {
}

type HealthResponseObject interface {
	VisitHealthResponse(w http.ResponseWriter) error
}

type InvalidParamFormatError struct {
	ParamName string
	Err       error
}

type Limit struct {
	// Results Maximum number of claims returned; `0` = unbounded.
	Results *int `json:"results,omitempty"`

	// Time Execution budget as a duration (e.g. `"5s"`); the query is cancelled when
	// exceeded. Absent or `"0"` = no budget.
	Time *string `json:"time,omitempty"`
}

type ListStorageLayers200JSONResponse StorageLayerList

type ListStorageLayers401JSONResponse struct{ UnauthorizedJSONResponse }

type ListStorageLayers403JSONResponse struct{ ForbiddenJSONResponse }

type ListStorageLayersRequestObject struct {
}

type ListStorageLayersResponseObject interface {
	VisitListStorageLayersResponse(w http.ResponseWriter) error
}

type ListVerifications200JSONResponse VerificationReportList

type ListVerifications401JSONResponse struct{ UnauthorizedJSONResponse }

type ListVerifications403JSONResponse struct{ ForbiddenJSONResponse }

type ListVerificationsRequestObject struct {
}

type ListVerificationsResponseObject interface {
	VisitListVerificationsResponse(w http.ResponseWriter) error
}

type MiddlewareFunc func(http.Handler) http.Handler

type NotFound = Error

type NotFoundJSONResponse Error

type OrderKey struct {
	// Compare How the values compare; absent = lexical.
	Compare *OrderKeyCompare `json:"compare,omitempty"`

	// Dir Sort direction; absent = asc.
	Dir *OrderKeyDir `json:"dir,omitempty"`

	// Field The field sorted on — any field a claim carries, or the derived `height`.
	Field string `json:"field"`
}

type OrderKeyCompare string

type OrderKeyDir string

type Output struct {
	// Content Inline content per claim. Absent, no content is inlined and a claim carries
	// only its `content_hash`.
	Content *OutputContent `json:"content,omitempty"`

	// Detail How each element is carried: id (identities only), graph (nodes joined by
	// the edges between them), or claims (each node with **all** its outgoing
	// edges — the default, and richer than graph).
	Detail *OutputDetail `json:"detail,omitempty"`

	// Encoding How each claim is serialised — json (text; content base64-encoded) or cbor
	// (binary). The same information either way, and orthogonal to the other
	// output fields; the response media type frames the sequence to match
	// (`application/json-seq` / `application/cbor-seq`).
	Encoding *OutputEncoding `json:"encoding,omitempty"`

	// Form Which field values each claim carries: original (as written — a
	// diff-overlaid claim's delta, and the id-defining form) or materialized
	// (with any `contribution/diff` chain resolved). A property of the values,
	// so orthogonal to `detail` and `encoding`.
	Form *OutputForm `json:"form,omitempty"`

	// Shape single (each item is one reached endpoint — the default) or path (each item
	// is the route to it, start-first).
	Shape *OutputShape `json:"shape,omitempty"`
}

type OutputContent struct {
	// Max Cap in bytes on the content inlined per claim.
	Max int `json:"max"`

	// Overflow What happens to content past the cap: cutoff (truncate), omit (drop it),
	// or reference (a `content_hash` stub in its place — the bytes are then
	// fetched from the claim's content route).
	Overflow *OutputContentOverflow `json:"overflow,omitempty"`
}

type OutputContentOverflow string

type OutputDetail string

type OutputEncoding string

type OutputForm string

type OutputShape string

type PathStep struct {
	// Dir provenance (outgoing, toward references — the default), uses (incoming,
	// the claims that cite this one), or connections (either).
	Dir *PathStepDir `json:"dir,omitempty"`

	// Edges Edge-class globs over `class/sub`; a leading `-` on an entry excludes that class.
	Edges *[]string `json:"edges,omitempty"`

	// Max Most hops; `0` means unbounded for this step (a step of at most zero hops
	// would move nothing). A `min` above a bounded `max` is rejected.
	Max *int `json:"max,omitempty"`

	// Min Fewest hops; absent means 1, so a step moves at least one hop. `0` also
	// yields the step's own starting set, carrying the frontier through
	// alongside what lies beyond it.
	Min *int `json:"min,omitempty"`

	// Nodes Node-class globs the step may yield; a leading `-` excludes a class.
	Nodes *[]string `json:"nodes,omitempty"`
}

type PathStepDir string

type Query struct {
	// Execution Where the query runs and how it reports on itself (paper 02 §Filtered Reads).
	// Queries are declarative; the planner lowers each to the most capable engine the
	// storage stack offers, so these controls affect execution and diagnostics only,
	// never the result set.
	Execution *Execution `json:"execution,omitempty"`

	// Limit Bounds the read; each field's `0` means unbounded.
	Limit *Limit `json:"limit,omitempty"`

	// Order Sort keys in priority order; absent or empty leaves the natural
	// `(created_at, id)` order.
	Order *[]OrderKey `json:"order,omitempty"`

	// Output Shapes each result along orthogonal axes and fixes the per-claim
	// serialization. `detail: claims` + `form: original` + `encoding: cbor`
	// reproduces the canonical bytes a claim's id is computed over — the only
	// combination directly verifiable against that id.
	Output *Output `json:"output,omitempty"`

	// Select A generator in four orthogonal parts: `branch` is the **scope**, `head` the
	// **closure** read, `claim` where the walk **starts**, and `path` the
	// **traversal**. Scope and start are independent because a walk runs both ways:
	// a `uses` step reaches the claims that *cite* the current one, which lie above
	// it, so it is the closure — not the start — that decides a reverse step's
	// answer.
	Select Select `json:"select"`

	// Where A boolean tree. Each node is exactly one of the `and`/`or`/`not` combinators
	// over sub-trees, or a **leaf** naming a `field` and its `test`. Within a
	// `where`, `or` is boolean; across generators it unions whole result sets. A leaf
	// may name any field a claim carries, including the derived `height` (the level a
	// claim sits at above its sources, compared numerically).
	Where *Where `json:"where,omitempty"`
}

type Query200ApplicationcborSeqResponse struct {
	Body          io.Reader
	ContentLength int64
}

type Query200ApplicationjsonSeqResponse struct {
	Body          io.Reader
	ContentLength int64
}

type Query400JSONResponse struct{ BadRequestJSONResponse }

type Query401JSONResponse struct{ UnauthorizedJSONResponse }

type Query403JSONResponse struct{ ForbiddenJSONResponse }

type Query404JSONResponse struct{ NotFoundJSONResponse }

type QueryJSONRequestBody = Query

type QueryRequestObject struct {
	Body *QueryJSONRequestBody
}

type QueryResponseObject interface {
	VisitQueryResponse(w http.ResponseWriter) error
}

type RequiredHeaderError struct {
	ParamName string
	Err       error
}

type RequiredParamError struct {
	ParamName string
}

type Select struct {
	// Branch The mandatory scope: a branch name (confines the query to that branch),
	// `$archive` (the whole Ranke-Archive), or `$universe` (no confinement —
	// privileged). An empty value is not allowed.
	Branch string `json:"branch"`

	// Claim Where the walk starts, which must lie inside the closure; absent, the walk
	// starts at the closure's head. It moves where reading begins, never what is
	// visible.
	Claim *string `json:"claim,omitempty"`

	// Head The closure read: the query sees the closure of this claim and nothing
	// else. **Required** under `$universe`, which confines nothing and so offers
	// no head to fall back on; optional under every other scope, where the
	// scope's own head serves. Given explicitly it must resolve to a claim
	// within the scope's closure, so it narrows the read and can never widen it
	// past the grant.
	Head *string `json:"head,omitempty"`

	// Path The traversal: steps applied in order. A step-less `path` returns the full
	// outward closure of the start claim.
	Path *[]PathStep `json:"path,omitempty"`
}

type ServeMux interface {
	HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request))
	http.Handler
}

type ServerInterface interface {
	// GetUniverseClaim Fetch a claim by id from the Universe (privileged)
	// (GET /$universe/claim/{id})
	GetUniverseClaim(w http.ResponseWriter, r *http.Request, id ClaimId)
	// GetUniverseClaimContent Fetch the content of a claim by id from the Universe (privileged)
	// (GET /$universe/claim/{id}/content)
	GetUniverseClaimContent(w http.ResponseWriter, r *http.Request, id ClaimId)
	// Contribute Contribute signed claims (atomic)
	// (POST /contribute)
	Contribute(w http.ResponseWriter, r *http.Request)
	// Health Liveness and signer identity
	// (GET /health)
	Health(w http.ResponseWriter, r *http.Request)
	// Query Read the graph with a declarative query
	// (POST /query)
	Query(w http.ResponseWriter, r *http.Request)
	// ListStorageLayers List storage layers
	// (GET /system/layers)
	ListStorageLayers(w http.ResponseWriter, r *http.Request)
	// ListVerifications List verification runs
	// (GET /system/verification)
	ListVerifications(w http.ResponseWriter, r *http.Request)
	// StartVerification Start a verification run
	// (POST /system/verification)
	StartVerification(w http.ResponseWriter, r *http.Request)
	// DeleteVerification Delete a verification run
	// (DELETE /system/verification/{reportId})
	DeleteVerification(w http.ResponseWriter, r *http.Request, reportId string)
	// GetVerification Show a verification run
	// (GET /system/verification/{reportId})
	GetVerification(w http.ResponseWriter, r *http.Request, reportId string)
	// CancelVerification Cancel a running verification run
	// (POST /system/verification/{reportId}/cancel)
	CancelVerification(w http.ResponseWriter, r *http.Request, reportId string)
	// GetBranchClaim Fetch a claim within a branch's closure
	// (GET /{branch}/claim/{id})
	GetBranchClaim(w http.ResponseWriter, r *http.Request, branch BranchName, id ClaimId)
	// GetBranchClaimContent Fetch the content of a claim within a branch's closure
	// (GET /{branch}/claim/{id}/content)
	GetBranchClaimContent(w http.ResponseWriter, r *http.Request, branch BranchName, id ClaimId)
	// GetBranchHead Current head id of a branch
	// (GET /{branch}/head)
	GetBranchHead(w http.ResponseWriter, r *http.Request, branch BranchName)
}

type ServerInterfaceWrapper struct {
	Handler            ServerInterface
	HandlerMiddlewares []MiddlewareFunc
	ErrorHandlerFunc   func(w http.ResponseWriter, r *http.Request, err error)
}

type StartVerification202JSONResponse struct {
	Body    VerificationReport
	Headers StartVerification202ResponseHeaders
}

type StartVerification202ResponseHeaders struct {
	Location   *string
	RetryAfter *int
}

type StartVerification400JSONResponse struct{ BadRequestJSONResponse }

type StartVerification401JSONResponse struct{ UnauthorizedJSONResponse }

type StartVerification403JSONResponse struct{ ForbiddenJSONResponse }

type StartVerification429JSONResponse struct {
	Body    Error
	Headers StartVerification429ResponseHeaders
}

type StartVerification429ResponseHeaders struct {
	RetryAfter *int
}

type StartVerificationJSONRequestBody = VerificationConfig

type StartVerificationRequestObject struct {
	Body *StartVerificationJSONRequestBody
}

type StartVerificationResponseObject interface {
	VisitStartVerificationResponse(w http.ResponseWriter) error
}

type StdHTTPServerOptions struct {
	BaseURL          string
	BaseRouter       ServeMux
	Middlewares      []MiddlewareFunc
	ErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
}

type StorageLayer struct {
	Name string `json:"name"`

	// Type Adapter type (e.g. memory, filesystem, s3, postgres, neo4j).
	Type string `json:"type"`
}

type StorageLayerList struct {
	// Layers Read-through tiers, top (cache) to bottom (authoritative).
	Layers []StorageLayer `json:"layers"`
}

type StrictHTTPServerOptions struct {
	RequestErrorHandlerFunc  func(w http.ResponseWriter, r *http.Request, err error)
	ResponseErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
}

type StrictHandlerFunc func(ctx context.Context, w http.ResponseWriter, r *http.Request, request any) (any, error)

type StrictMiddlewareFunc func(f StrictHandlerFunc, operationID string) StrictHandlerFunc

type StrictServerInterface interface {
	// GetUniverseClaim Fetch a claim by id from the Universe (privileged)
	// (GET /$universe/claim/{id})
	GetUniverseClaim(ctx context.Context, request GetUniverseClaimRequestObject) (GetUniverseClaimResponseObject, error)
	// GetUniverseClaimContent Fetch the content of a claim by id from the Universe (privileged)
	// (GET /$universe/claim/{id}/content)
	GetUniverseClaimContent(ctx context.Context, request GetUniverseClaimContentRequestObject) (GetUniverseClaimContentResponseObject, error)
	// Contribute Contribute signed claims (atomic)
	// (POST /contribute)
	Contribute(ctx context.Context, request ContributeRequestObject) (ContributeResponseObject, error)
	// Health Liveness and signer identity
	// (GET /health)
	Health(ctx context.Context, request HealthRequestObject) (HealthResponseObject, error)
	// Query Read the graph with a declarative query
	// (POST /query)
	Query(ctx context.Context, request QueryRequestObject) (QueryResponseObject, error)
	// ListStorageLayers List storage layers
	// (GET /system/layers)
	ListStorageLayers(ctx context.Context, request ListStorageLayersRequestObject) (ListStorageLayersResponseObject, error)
	// ListVerifications List verification runs
	// (GET /system/verification)
	ListVerifications(ctx context.Context, request ListVerificationsRequestObject) (ListVerificationsResponseObject, error)
	// StartVerification Start a verification run
	// (POST /system/verification)
	StartVerification(ctx context.Context, request StartVerificationRequestObject) (StartVerificationResponseObject, error)
	// DeleteVerification Delete a verification run
	// (DELETE /system/verification/{reportId})
	DeleteVerification(ctx context.Context, request DeleteVerificationRequestObject) (DeleteVerificationResponseObject, error)
	// GetVerification Show a verification run
	// (GET /system/verification/{reportId})
	GetVerification(ctx context.Context, request GetVerificationRequestObject) (GetVerificationResponseObject, error)
	// CancelVerification Cancel a running verification run
	// (POST /system/verification/{reportId}/cancel)
	CancelVerification(ctx context.Context, request CancelVerificationRequestObject) (CancelVerificationResponseObject, error)
	// GetBranchClaim Fetch a claim within a branch's closure
	// (GET /{branch}/claim/{id})
	GetBranchClaim(ctx context.Context, request GetBranchClaimRequestObject) (GetBranchClaimResponseObject, error)
	// GetBranchClaimContent Fetch the content of a claim within a branch's closure
	// (GET /{branch}/claim/{id}/content)
	GetBranchClaimContent(ctx context.Context, request GetBranchClaimContentRequestObject) (GetBranchClaimContentResponseObject, error)
	// GetBranchHead Current head id of a branch
	// (GET /{branch}/head)
	GetBranchHead(ctx context.Context, request GetBranchHeadRequestObject) (GetBranchHeadResponseObject, error)
}

type TooManyValuesForParamError struct {
	ParamName string
	Count     int
}

type Unauthorized = Error

type UnauthorizedJSONResponse Error

type UnescapedCookieParamError struct {
	ParamName string
	Err       error
}

type UnmarshalingParamError struct {
	ParamName string
	Err       error
}

type VerificationConfig struct {
	// Closure Root of the closure to verify — a branch name or a claim id.
	Closure string `json:"closure"`

	// ContentThreshold For full-content, the max content size in bytes to re-read and re-hash
	// per claim; larger content is skipped this run. Omit to verify all content.
	ContentThreshold *int `json:"contentThreshold,omitempty"`

	// Depth completeness (a `has` sweep), record-correctness (recanonicalise and
	// recheck the id-chain and signatures), or full-content (also re-hash blobs).
	Depth *VerificationConfigDepth `json:"depth,omitempty"`

	// Layer Storage layer (by name) to read directly. Omit to read the composed
	// read-through view — which may mask the loss of an object on a deeper
	// layer, so name a layer to verify it without blind spots.
	Layer *string `json:"layer,omitempty"`
}

type VerificationConfigDepth string

type VerificationFailure struct {
	Detail *string `json:"detail,omitempty"`

	// Id The claim or object id that failed.
	Id string `json:"id"`

	// Layer The layer where the failure was observed.
	Layer string `json:"layer"`

	// Mode corrupt-bytes — stored bytes don't match their hash (storage rot/loss;
	// self-heals via read-through if a deeper layer is intact).
	// invalid-content — the claim itself doesn't validate (e.g. bad signature);
	// unrepairable.
	Mode VerificationFailureMode `json:"mode"`
}

type VerificationFailureMode string

type VerificationReport struct {
	// BytesRead Content bytes re-read so far; advances while `status` is `running`.
	BytesRead *int `json:"bytesRead,omitempty"`

	// ClaimsChecked Claims checked so far; advances while `status` is `running`.
	ClaimsChecked *int       `json:"claimsChecked,omitempty"`
	CompletedAt   *time.Time `json:"completedAt,omitempty"`

	// Config Parameters for a verification run — the same shape whether declared in the
	// stack config (scheduled) or posted ad-hoc. Depths are those of
	// core-verification.
	Config VerificationConfig `json:"config"`

	// Failures The failures found, accumulating while `status` is `running`. Empty (with
	// `ok: true`) for an intact closure; a healthy archive verifies with none.
	Failures *[]VerificationFailure `json:"failures,omitempty"`

	// Head The head id the run verified — the closure it pinned at start. When
	// `config.closure` names a branch, this is the branch's head at start time;
	// the report stays fixed to it even as the branch head moves on.
	Head string `json:"head"`
	Id   string `json:"id"`

	// Ok True when no failures were found in this run.
	Ok        bool      `json:"ok"`
	StartedAt time.Time `json:"startedAt"`

	// Status running (in progress), complete (finished on its own), stopped (cancelled
	// by an operator via the cancel action — partial findings kept), or error
	// (the run itself failed).
	Status VerificationReportStatus `json:"status"`
}

type VerificationReportList struct {
	Reports []VerificationReport `json:"reports"`
}

type VerificationReportStatus string

type Where struct {
	// contains filtered or unexported fields
}

type Where0 struct {
	And []Where `json:"and"`
}

type Where1 struct {
	Or []Where `json:"or"`
}

type Where2 struct {
	// Not A boolean tree. Each node is exactly one of the `and`/`or`/`not` combinators
	// over sub-trees, or a **leaf** naming a `field` and its `test`. Within a
	// `where`, `or` is boolean; across generators it unions whole result sets. A leaf
	// may name any field a claim carries, including the derived `height` (the level a
	// claim sits at above its sources, compared numerically).
	Not Where `json:"not"`
}

type Where3 struct {
	// Field The field tested — any field a claim carries, or the derived `height`.
	Field string `json:"field"`

	// Test A test on one field. Exactly one operator is expected. `in` takes a set;
	// `glob` a shell-style wildcard; the rest a scalar.
	Test Comparison `json:"test"`
}