model

type Acceptance struct {
	DependencyAuthorization []AuthorizationDecision `json:",omitempty"`
	State                   string
	VersionID               string
	Valid                   Interval
	PolicyID                string
	AttestationIDs          []string
	LedgerRevision          int64
}

type AcceptancePolicy struct {
	Scope, ID                        string
	Mode                             string
	AcceptingServices, SourceClasses []string
	Required                         []AttestationRequirement
}

type ActiveProjection struct {
	Generation string
	Epoch      int64
}

type Approval struct {
	Command
	Scope, RecordID, VersionID string
	ExpectedRevision           int64
}

type ApprovedExtractor struct {
	Profile  ExtractionProfile
	Provider ExtractionProvider
}

type ArchiveBatch struct {
	Manifest  ArchiveManifest
	Signature AuditSignature
}

type ArchiveCoverageReceipt struct {
	Tenant, Scope, Stream, HeadDigest, KeyID string
	ThroughRevision                          int64
	VerifiedAt                               time.Time
}

type ArchiveCoverageVerifier interface {
	VerifyAuditCoverage(context.Context, string, string, int64) (ArchiveCoverageReceipt, error)
}

type ArchiveManifest struct {
	Authorization                    []AuthorizationDecision
	Schema, Encoding, Tenant, Stream string
	FromRevision, ThroughRevision    int64
	EventCount                       int
	Payload                          ObjectRef
	Previous                         *ObjectRef
}

type ArchivePayload struct {
	Scopes  []string
	Event   Event
	Entries []AuditEntry
	Gaps    []AuditGap
}

type ArchiveSource interface {
	ArchivePayload(context.Context, Delivery) (ArchivePayload, error)
}

type ArchiveStore interface {
	Put(context.Context, string, string, []byte) (ObjectRef, error)
	Load(context.Context, string, string) (ObjectRef, []byte, error)
	Read(context.Context, string, ObjectRef) ([]byte, error)
}

type ArtifactReference struct{ EvidenceID, Digest string }

type Attestation struct {
	PayloadDisposed                                                 bool                   `json:",omitempty"`
	DisposedPayloadDigest                                           string                 `json:",omitempty"`
	RecordedAt                                                      *time.Time             `json:",omitempty"`
	ReviewAuthorization                                             *AuthorizationDecision `json:",omitempty"`
	Recorder                                                        *Caller                `json:",omitempty"`
	Delegation                                                      *AttestationDelegation `json:",omitempty"`
	EvidenceAuthorization                                           *AuthorizationDecision `json:",omitempty"`
	Confirmation                                                    *ClientConfirmation    `json:",omitempty"`
	ID, Scope, RecordID, VersionID, ContentDigest, Kind, EvidenceID string
	Attestor                                                        Caller
	ExpiresAt                                                       *time.Time
}

type AttestationDelegation struct {
	Receipt       AttestationIdentityReceipt
	Authorization []AuthorizationDecision
}

type AttestationDisposalRequest struct {
	Command
	Kind, Scope, RecordID, VersionID, AttestationID, PolicyID, Jurisdiction, Purpose, Reason string
}

type AttestationDisposalTx interface {
	DisposeAttestation(context.Context, AttestationDisposalRequest) (int64, error)
}

type AttestationIdentityOptions struct {
	Verifier                      AttestationIdentityVerifier
	Authority                     string
	Timeout, MaxAuthenticationAge time.Duration
}

type AttestationIdentityReceipt struct {
	Authority, BindingID, RequestDigest    string
	Attestor                               Caller
	AuthenticatedAt, VerifiedAt, ExpiresAt time.Time
}

type AttestationIdentityRequest struct {
	Recorder Caller
	Request  DelegatedAttestationRequest
}

type AttestationIdentityVerifier interface {
	VerifyAttestationIdentity(context.Context, AttestationIdentityRequest) (AttestationIdentityReceipt, error)
}

type AttestationRequest struct {
	Command
	Attestation Attestation
}

type AttestationRequirement struct {
	RequireExpiry bool  `json:",omitempty"`
	MaxAgeSeconds int64 `json:",omitempty"`
	Kind          string
	Principals    []string
}

type AuditBundle struct {
	Manifest  AuditManifest
	Entries   []AuditEntry
	Signature AuditSignature
}

type AuditEntry struct {
	Kind, ID string
	Payload  json.RawMessage
}

type AuditExportJob struct {
	ID              string
	Caller          Caller
	Request         AuditExportRequest
	CreatedRevision int64
	State           string
	Fence           int64
	LeaseUntil      *time.Time
}

type AuditExportQuery struct{ ID, Scope, Purpose string }

type AuditExportRequest struct {
	Command
	Scope           string
	IncludeEvidence bool
}

type AuditExportResult struct {
	ID, State                          string
	CreatedRevision, CompletedRevision int64
	Artifact                           ObjectRef
	Bundle                             *AuditBundle
}

type AuditExportRunner interface {
	RunAuditExport(context.Context, Caller, AuditExportQuery) (AuditExportResult, error)
}

type AuditGap struct{ Kind, ID, Reason string }

type AuditManifest struct {
	SchemaVersion, Encoding, Tenant, Scope, ExportID string
	ThroughRevision                                  int64
	EntryCount                                       int
	Entries                                          []AuditManifestEntry
	Gaps                                             []AuditGap
	Authorization                                    []AuthorizationDecision
	ArchiveCoverage                                  *ArchiveCoverageReceipt `json:",omitempty"`
}

type AuditManifestEntry struct{ Kind, ID, Digest string }

type AuditOptions struct {
	Signer          AuditSigner
	ArchiveCoverage ArchiveCoverageVerifier
}

type AuditSignature struct {
	Algorithm, KeyID string
	Bytes            []byte
}

type AuditSigner interface {
	Sign(context.Context, []byte) (AuditSignature, error)
}

type AuditTx interface {
	TemporalTx
	CalculationRun(context.Context, string, string) (CalculationRecord, error)
	Calculation(context.Context, string) (CalculationRecord, error)
	StageCalculation(context.Context, CalculationRecord, []FactSnapshot) error
	StageAuditJob(context.Context, AuditExportJob) error
	AuditJob(context.Context, string) (AuditExportJob, error)
	ClaimAuditJob(context.Context, string, time.Duration) (AuditExportJob, error)
	StageAuditBundle(context.Context, AuditExportJob, AuditBundle) error
	AuditExport(context.Context, string) (AuditExportResult, error)
	AuditEntries(context.Context, string) ([]AuditEntry, []AuditGap, error)
}

type AuthorizationDecision struct {
	Allowed                             bool
	ModelID, ContextDigest, Consistency string
	CheckedAt                           time.Time
	Request                             AuthorizationRequest
}

type AuthorizationRequest struct {
	Caller                                    Caller
	Scope, Permission, Purpose, CorrelationID string
}

type Authorizer interface {
	Check(context.Context, AuthorizationRequest) (AuthorizationDecision, error)
}

type CalculationDisposalRequest struct {
	Command
	CalculationID, Reason string
	Bindings              []CalculationRetentionBinding
}

type CalculationQuery struct{ ID, Purpose string }

type CalculationReceipt struct {
	Command
	Scope, SnapshotID, ApplicationID, ExternalRunID                                      string
	MethodID, MethodVersion, ExecutableDigest, ConfigurationDigest, NormalizationVersion string
	ReferenceSnapshotIDs                                                                 []string
	Input, Output                                                                        ArtifactReference
	StartedAt, CompletedAt                                                               time.Time
	Outcome                                                                              string
}

type CalculationRecord struct {
	PayloadDisposed                    bool `json:",omitempty"`
	Authorization                      []AuthorizationDecision
	ID, Tenant, Digest, SnapshotDigest string
	Caller                             Caller
	Receipt                            CalculationReceipt
	LedgerRevision                     int64
}

type CalculationRetentionBinding struct{ Scope, PolicyID, Jurisdiction string }

type Caller struct {
	Tenant, Principal, Initiator string
	Service                      bool
}

type ChangesQuery struct {
	Scope, Purpose string
	AfterRevision  int64
	Limit          int
}

type ChangesResult struct {
	Events                        []Event
	ThroughRevision, NextRevision int64
}

type ChangesTx interface {
	Tx
	Changes(context.Context, string, int64, int64, int) ([]Event, error)
}

type ClientConfirmation struct {
	Presentation, Response   ArtifactReference
	PresentationVersion      string
	PresentedAt, RespondedAt time.Time
}

type Command struct{ Key, Purpose, CorrelationID string }

type CommitResult struct {
	RecordKind                     string `json:",omitempty"`
	ContentDigest                  string
	ID, RecordID, VersionID        string
	StreamRevision, LedgerRevision int64
}

type ConsumerKey struct{ Tenant, Consumer string }

type ConsumerStatus struct {
	Key                   ConsumerKey
	AcknowledgedRevision  int64
	State                 string
	Fence                 int64
	Attempts, MaxAttempts int
	LeaseUntil            *time.Time
	AvailableAt           time.Time
	LastFailureCode       string
}

type ContextArchiveOptions struct {
	Stream              string
	MaxPendingRevisions int64
	Progress            OutboxProgressReader
}

type ContextArchiveReceipt struct {
	Stream                                                    string
	MaxPendingRevisions, LedgerRevision, AcknowledgedRevision int64
	CheckedAt                                                 time.Time
}

type ContextDisposalRequest struct {
	Command
	ContextID, Reason string
	Bindings          []ContextRetentionBinding
}

type ContextDisposalTx interface {
	DisposeContext(context.Context, ContextDisposalRequest) error
}

type ContextManifest struct {
	PayloadDisposed                                      bool                   `json:",omitempty"`
	Archive                                              *ContextArchiveReceipt `json:",omitempty"`
	ID, Tenant, Scope                                    string
	Caller                                               Caller
	Request                                              ContextRequest
	CanonicalVersion, RedactionVersion, QueryReference   string
	Retrieval                                            RetrievalIdentity
	Items                                                []RecallItem
	Memories                                             []MemoryRecallItem `json:",omitempty"`
	Order                                                []VersionReference `json:",omitempty"`
	Rendered                                             []byte
	RenderedDigest, Digest                               string
	SelectionRevision, IndexedRevision, CreationRevision int64
	Incomplete                                           bool
	Authorization                                        []AuthorizationDecision
}

type ContextQuery struct{ ID, Purpose string }

type ContextRequest struct {
	Command
	Scope           string
	Query           RecallRequest
	IncludeMemories bool `json:",omitempty"`
}

type ContextRetentionBinding struct{ Scope, PolicyID, Jurisdiction string }

type ContextTx interface {
	AuditTx
	ContextManifest(context.Context, string) (ContextManifest, error)
	StageContext(context.Context, ContextManifest) error
	Decision(context.Context, string) (DecisionRecord, error)
	DecisionRun(context.Context, string, string) (DecisionRecord, error)
	StageDecision(context.Context, DecisionRecord, map[VersionReference]string) error
}

type ConversationDisposalRequest struct {
	Command
	Scope, ConversationID, PolicyID, Jurisdiction, Purpose, Reason string
}

type ConversationDisposalTx interface {
	DisposeConversation(context.Context, ConversationDisposalRequest) error
}

type ConversationMessage struct {
	ID, Revision, Speaker, SpeakerRole, SourceClass string
	SourceTime                                      time.Time
	MediaType, Classification, RetentionPolicy      string
	Object                                          ObjectRef
}

type ConversationQuery struct{ ID, Scope, Purpose string }

type ConversationRecord struct {
	ID, Tenant, Digest string
	Caller             Caller
	Request            ConversationRequest
	EvidenceIDs        []string
	Authorization      []AuthorizationDecision
	LedgerRevision     int64
	PayloadDisposed    bool `json:",omitempty"`
}

type ConversationRequest struct {
	Command
	Scope, SourceSystem, ConversationID, Revision, Timezone string
	Messages                                                []ConversationMessage
}

type ConversationTx interface {
	Tx
	Conversation(context.Context, string) (ConversationRecord, error)
	StageConversation(context.Context, ConversationRecord) error
}

type DecisionDisposalRequest struct {
	Command
	DecisionID, Reason string
	Bindings           []DecisionRetentionBinding
}

type DecisionQuery struct{ ID, Purpose string }

type DecisionReceipt struct {
	Command
	Scope, ApplicationID, ExternalDecisionID                   string
	ContextID, SnapshotID, CalculationID                       string
	SelectedItems, UsedItems                                   []VersionReference
	MethodKind, MethodID, MethodVersion, TransformationVersion string
	Input, Output                                              ArtifactReference
	ModelRequest, ModelResponse, ActionReceipt                 *ArtifactReference
	DecidedAt                                                  time.Time
	Outcome                                                    string
}

type DecisionRecord struct {
	PayloadDisposed                                     bool `json:",omitempty"`
	ID, Tenant, Digest, SourceDigest, CalculationDigest string
	Caller                                              Caller
	Receipt                                             DecisionReceipt
	Scopes                                              []string
	LedgerRevision                                      int64
	Authorization                                       []AuthorizationDecision
}

type DecisionRetentionBinding struct{ Scope, PolicyID, Jurisdiction string }

type DelegatedAttestationRequest struct {
	AttestationRequest
	GrantID string
}

type Delivery struct {
	Key        ConsumerKey
	Event      Event
	Fence      int64
	Attempt    int
	LeaseUntil time.Time
}

type DisposalBatchRequest struct {
	Command
	Scope, Reason string
	Evidence      []EvidenceDisposalRequest     `json:",omitempty"`
	Conversations []ConversationDisposalRequest `json:",omitempty"`
	Attestations  []AttestationDisposalRequest  `json:",omitempty"`
	Decisions     []DecisionDisposalRequest     `json:",omitempty"`
	Calculations  []CalculationDisposalRequest  `json:",omitempty"`
	Snapshots     []SnapshotDisposalRequest     `json:",omitempty"`
	Contexts      []ContextDisposalRequest      `json:",omitempty"`
	Versions      []VersionDisposalRequest
	Extractions   []ExtractionDisposalRequest
}

type DisposalBatchResult struct {
	VersionRevisions     []int64
	AttestationRevisions []int64
}

type DisposalBatchTx interface {
	DisposeBatch(context.Context, DisposalBatchRequest) (DisposalBatchResult, error)
}

type Embedder interface {
	Embed(context.Context, string) ([]float32, error)
}

type EngineOptions struct {
	ProjectionCleanup       ProjectionCleanupOptions
	ContextArchive          *ContextArchiveOptions
	Telemetry               TelemetryOptions
	Operations              OperationsOptions
	RedactionPolicyVersions []string
	AttestationIdentity     AttestationIdentityOptions
	Extraction              ExtractionOptions
	Audit                   AuditOptions
	Retrieval               RetrievalOptions
	Reads                   ReadOptions
}

type Event struct {
	RefreshSweep                         *MemoryRefreshSweep `json:",omitempty"`
	RecordKind                           string              `json:",omitempty"`
	DefinitionPredicate                  string              `json:",omitempty"`
	EntityID, Reason                     string
	Affected                             *Interval
	ReplacedVersionIDs                   []string
	ID, Type, Scope, RecordID, VersionID string
	StreamRevision, LedgerRevision       int64
	Caller                               Caller
	Command                              Command
	Authorization                        AuthorizationDecision
	RecordedAt                           time.Time
}

type Evidence struct {
	Derivation                                                                                                              *EvidenceDerivation `json:",omitempty"`
	ID, Scope, SourceSystem, SourceObject, SourceRevision, Speaker, SourceClass, MediaType, Classification, RetentionPolicy string
	SourceTime                                                                                                              time.Time
	Object                                                                                                                  ObjectRef
}

type EvidenceContent struct {
	Metadata Evidence
	Bytes    []byte
}

type EvidenceCopyRange struct {
	OriginalStart, OriginalEnd, DerivedStart int
}

type EvidenceDerivation struct {
	ParentEvidenceID, TransformationVersion, PolicyVersion string
	Ranges                                                 []EvidenceCopyRange
}

type EvidenceDisposalRequest struct {
	// DerivativeEvidenceIDs explicitly selects the complete direct derivative set.
	// Empty preserves single-object disposal; custom adapters must implement EvidenceLineageDisposalTx.
	DerivativeEvidenceIDs []string `json:",omitempty"`
	// DeferObjectDeletion is service-owned and excluded from command identity.
	// External stores are deleted by a retryable outbox worker after the ledger tombstone commits.
	DeferObjectDeletion bool `json:"-"`
	Command
	Scope, EvidenceID, PolicyID, Jurisdiction, Reason string
}

type EvidenceLineageDisposalTx interface {
	DisposeEvidenceLineage(context.Context, EvidenceDisposalRequest) error
}

type EvidenceQuery struct{ ID, Scope, Purpose string }

type EvidenceRequest struct {
	Command
	Evidence Evidence
}

type EvidenceStore interface {
	Read(context.Context, string, ObjectRef) ([]byte, error)
}

type EvidenceVersionDeleter interface {
	DeleteEvidenceVersion(context.Context, string, ObjectRef) error
}

type ExtractedProposal struct {
	RecordKind          string `json:",omitempty"`
	Candidate           int
	RecordID, VersionID string
}

type ExtractionAdmission struct {
	JobStatus
	Reservation ExtractionReservation
}

type ExtractionAttempt struct {
	PayloadDisposed                                                    bool                   `json:",omitempty"`
	Reservation                                                        *ExtractionReservation `json:",omitempty"`
	ContentScopes                                                      []string               `json:",omitempty"`
	RefreshScopes                                                      []string               `json:",omitempty"`
	ID, Tenant, Scope, JobID, OwnerNonce, ProfileDigest, RequestDigest string
	Caller                                                             Caller
	Fence, LedgerRevision                                              int64
	LeaseUntil                                                         time.Time
	Number                                                             int
	StartedAt                                                          time.Time
	RequestBytes                                                       []byte
	Authorization                                                      []AuthorizationDecision
}

type ExtractionCandidate struct {
	Subject, Predicate, Discriminator, SchemaVersion string
	Value                                            Value
	Valid                                            Interval
	Sources                                          []SourceSpan
	Uncertainty, Rationale                           string
	Confidence                                       float64
}

type ExtractionChunk struct {
	InputRanges []ExtractionInputRange
	SourceBytes int
}

type ExtractionChunkPlan struct {
	RedactedEvidenceIDs                                        []string `json:",omitempty"`
	Version, Tenant, Scope, ConversationID, ConversationDigest string
	ProfileID, ProfileDigest                                   string
	MaxSourceBytes                                             int
	Chunks                                                     []ExtractionChunk
	ExcludedRanges                                             []ExtractionInputRange
}

type ExtractionChunkQuery struct {
	RedactedEvidenceIDs                       []string
	Scope, ConversationID, ProfileID, Purpose string
	InputRanges                               []ExtractionInputRange
	MaxSourceBytes                            int
}

type ExtractionCostBudget struct {
	Unit                   string
	DailyLimit, PerAttempt int64
}

type ExtractionDisposalRequest struct {
	Command
	JobID, Reason string
	Bindings      []ExtractionRetentionBinding
}

type ExtractionDisposalTx interface {
	DisposeExtraction(context.Context, ExtractionDisposalRequest) error
}

type ExtractionInput struct {
	PayloadRedactionVersion string                   `json:",omitempty"`
	PayloadOmittedPaths     []string                 `json:",omitempty"`
	PayloadRanges           []ExtractionPayloadRange `json:",omitempty"`

	InputSelectionVersion                                                          string                 `json:",omitempty"`
	ExcludedRanges                                                                 []ExtractionInputRange `json:",omitempty"`
	Schema, Tenant, JobID, AttemptID, ConversationID, ConversationDigest, Timezone string
	Profile                                                                        ExtractionProfile
	Subjects                                                                       []string
	Predicates                                                                     []PredicateVersion
	Messages                                                                       []ExtractionInputMessage
	OmittedRanges                                                                  []string
	RedactionVersion                                                               string
	Refresh                                                                        *MemoryRefreshInput      `json:",omitempty"`
	MemoryTargets                                                                  []MemoryExtractionTarget `json:",omitempty"`
	MemoryTypes                                                                    []MemoryType             `json:",omitempty"`
	DependencyVersions                                                             []Version                `json:",omitempty"`
}

type ExtractionInputMessage struct {
	DerivativeEvidenceID, DerivativeDigest        string `json:",omitempty"`
	DerivativeStart                               int    `json:",omitempty"`
	SourceStart                                   int    `json:",omitempty"`
	EvidenceID, Speaker, SpeakerRole, SourceClass string
	SourceTime                                    time.Time
	Content                                       string
}

type ExtractionInputRange struct {
	EvidenceID string
	Start, End int
}

type ExtractionIssue struct {
	Candidate int
	Code      string
}

type ExtractionJob struct {
	PayloadDisposed           bool `json:",omitempty"`
	ID, Tenant, ProfileDigest string
	Caller                    Caller
	Request                   ExtractionRequest
	Profile                   ExtractionProfile
	Predicates                []PredicateVersion
	RefreshScopes             []string `json:",omitempty"`
	Authorization             []AuthorizationDecision
	CreatedRevision           int64
	MemoryTypes               []MemoryType `json:",omitempty"`
	DependencyVersions        []Version    `json:",omitempty"`
	ContentScopes             []string     `json:",omitempty"`
}

type ExtractionOptions struct {
	// ScheduleOnly allows profile validation and durable job creation without a
	// provider. Profiles must omit Provider; RunExtraction is disabled in this host.
	// A separate execution host must configure the same profile digest and budgets.
	ScheduleOnly           bool
	CostUnit               string
	DailyCostBudgetUnits   int64
	Profiles               []ApprovedExtractor
	MaxConcurrentPerTenant int
	DailyTokenBudget       int64
}

type ExtractionOutput struct {
	Candidates []ExtractionCandidate `json:"candidates"`
}

type ExtractionPayloadRange struct {
	Path       string
	Start, End int
}

type ExtractionPayloadRedaction struct {
	PolicyVersion               string
	DependencyPayloads          bool
	OriginalMemoryPayload       bool
	RefreshEvidence             bool
	DependencyPayloadRanges     bool `json:",omitempty"`
	OriginalMemoryPayloadRanges bool `json:",omitempty"`
	RefreshEvidenceRanges       bool `json:",omitempty"`
}

type ExtractionProfile struct {
	PayloadRedaction *ExtractionPayloadRedaction `json:",omitempty"`

	RedactionPolicyVersion                                                                       string `json:",omitempty"`
	InputSelectionVersion                                                                        string `json:",omitempty"`
	CostUnit                                                                                     string `json:",omitempty"`
	MaxCostUnitsPerAttempt                                                                       int64  `json:",omitempty"`
	ID, ProviderID, RequestedModel, PromptVersion, PromptDigest, ParserVersion, ApplicationBuild string
	Prompt                                                                                       []byte
	Parameters                                                                                   json.RawMessage
	Timeout                                                                                      time.Duration
	MaxInputBytes, MaxOutputBytes, MaxCandidates, MaxAttempts                                    int
	MaxTokensPerAttempt                                                                          int64
	RetryDelay                                                                                   time.Duration
}

type ExtractionProvider interface {
	Extract(context.Context, []byte) (ExtractionResponse, error)
}

type ExtractionRelation struct {
	Candidate                 int
	RecordID, VersionID, Kind string
}

type ExtractionRequest struct {
	RedactedEvidenceIDs   []string                 `json:",omitempty"`
	ExpectedProfileDigest string                   `json:",omitempty"`
	InputRanges           []ExtractionInputRange   `json:",omitempty"`
	PayloadRanges         []ExtractionPayloadRange `json:",omitempty"`
	Command
	Scope, ConversationID, ProfileID string
	Subjects                         []string
	Predicates                       []PredicateBinding
	Refresh                          *VersionReference        `json:",omitempty"`
	RefreshTrigger                   *MemoryRefreshTrigger    `json:",omitempty"`
	MemoryTargets                    []MemoryExtractionTarget `json:",omitempty"`
}

type ExtractionReservation struct {
	Day                       string
	Tokens, DailyTokenLimit   int64
	ConcurrentLimit           int
	CostUnit                  string `json:",omitempty"`
	CostUnits, DailyCostLimit int64  `json:",omitempty"`
}

type ExtractionResponse struct {
	ModelIdentity             string
	Body                      []byte
	InputTokens, OutputTokens int64
}

type ExtractionResult struct {
	PayloadDisposed                                                                        bool     `json:",omitempty"`
	ContentScopes                                                                          []string `json:",omitempty"`
	RefreshScopes                                                                          []string `json:",omitempty"`
	AttemptID, JobID, Tenant, Scope, Outcome, ModelIdentity, RequestDigest, ResponseDigest string
	ResponseBytes                                                                          []byte
	ResponseComplete                                                                       bool
	InputTokens, OutputTokens                                                              int64
	Issues                                                                                 []ExtractionIssue
	Relations                                                                              []ExtractionRelation
	Proposals                                                                              []ExtractedProposal
	Authorization                                                                          []AuthorizationDecision
	CompletedAt                                                                            time.Time
	LedgerRevision                                                                         int64
}

type ExtractionRetentionBinding struct {
	Scope, JobPolicyID, RequestPolicyID, ResponsePolicyID, Jurisdiction string
}

type ExtractionRun struct {
	Attempt ExtractionAttempt
	Result  *ExtractionResult
}

type ExtractionRunQuery struct{ ID, Scope, Purpose string }

type ExtractionRunRequest struct {
	Command
	ID, Scope string
}

type ExtractionRunTx interface {
	ExtractionTx
	TemporalTx
	BeginExtraction(context.Context, string, string, int, int64, int64, time.Duration, ExtractionCostBudget) (ExtractionAdmission, error)
	FailExpiredExtraction(context.Context, string, int64) error
	RejectExtractionInput(context.Context, string) error
	StageExtractionAttempt(context.Context, ExtractionAttempt) error
	ExtractionAttempt(context.Context, string) (ExtractionAttempt, error)
	ExtractionResult(context.Context, string) (ExtractionResult, error)
	FinishExtraction(context.Context, string, string, int64, string, string, time.Duration) error
	StageExtractionResult(context.Context, ExtractionResult) error
}

type ExtractionRunner interface {
	GetJob(context.Context, Caller, JobQuery) (JobStatus, error)
	RunExtraction(context.Context, Caller, ExtractionRunRequest) (JobStatus, error)
}

type ExtractionTx interface {
	Tx
	StageExtractionJob(context.Context, ExtractionJob) error
	ExtractionJob(context.Context, string) (ExtractionJob, error)
	ExtractionJobStatus(context.Context, string) (JobStatus, error)
	RetryExtractionJob(context.Context, string, int64) error
}

type FactKey struct{ Scope, Subject, Predicate, Discriminator string }

type FactProposal struct {
	Command
	Key              FactKey
	SchemaVersion    string
	Value            Value
	Valid            Interval
	Sources          []SourceSpan
	ExpectedRevision int64
}

type FactQuery struct {
	KnownAt           *time.Time
	Purpose           string
	Key               FactKey
	ValidAt           time.Time
	KnowledgeRevision int64
}

type FactResult struct {
	State                          string
	RecordID, VersionID            string
	Value                          *Value
	LedgerRevision, StreamRevision int64
}

type FactSnapshot struct {
	PayloadDisposed                     bool `json:",omitempty"`
	ID                                  string
	Tenant                              string
	Caller                              Caller
	Purpose                             string
	ValidAt, EvaluatedAt                time.Time
	SelectionRevision, CreationRevision int64
	Items                               []SnapshotItem
	CanonicalVersion, Digest            string
	Authorization                       []AuthorizationDecision
}

type FactSnapshotRequest struct {
	Command
	Selectors         []FactKey
	ValidAt           time.Time
	KnowledgeRevision int64
}

type FactsPage struct {
	Items          []SnapshotItem
	LedgerRevision int64
	EvaluatedAt    time.Time
	NextPageToken  string
}

type FactsQuery struct {
	Scope, Subject, Predicate, Purpose string
	ValidAt                            time.Time
	KnowledgeRevision                  int64
	KnownAt                            *time.Time
	Limit                              int
	PageToken                          string
}

type GenerationKey struct{ Tenant, Generation string }

type HistoryPage struct {
	Events                         []Event
	LedgerRevision, StreamRevision int64
	NextPageToken                  string
}

type HistoryPageQuery struct {
	HistoryQuery
	Limit     int
	PageToken string
}

type HistoryPageTx interface {
	Tx
	HistoryPage(context.Context, string, int64, int64, int) ([]Event, error)
}

type HistoryQuery struct{ Scope, RecordID, Purpose string }

type HistoryResult struct {
	LedgerRevision int64
	Events         []Event
}

type IdentityQuery struct {
	Scope, ID, Purpose string
	Revision           int64
}

type IdentityTx interface {
	Tx
	StageScope(context.Context, ScopeVersion, int64) error
	StageSubject(context.Context, SubjectVersion, int64) error
	ScopeIdentity(context.Context, string, int64) (ScopeVersion, error)
	SubjectIdentity(context.Context, string, string, int64) (SubjectVersion, error)
	LookupSubject(context.Context, string, string, string) (SubjectVersion, error)
}

type Interval struct {
	From *time.Time
	To   *time.Time
}

type JobQuery struct{ ID, Scope, Purpose string }

type JobRetryRequest struct {
	Command
	ID, Scope     string
	ExpectedFence int64
}

type JobStatus struct {
	ID, Scope, Kind, State, AttemptID, LastFailureCode, Purpose string
	Attempts, MaxAttempts                                       int
	Fence, CreatedRevision                                      int64
	AvailableAt                                                 time.Time
	LeaseUntil                                                  *time.Time
}

type Ledger interface {
	Transact(context.Context, string, func(Tx) error) error
}

type LegalHoldRequest struct {
	Command
	ID, Scope, Reason string
}

type LifecycleChange struct {
	Approval
	Valid  Interval
	Reason string
}

type MemoriesPage struct {
	Items          []MemoryListItem
	LedgerRevision int64
	EvaluatedAt    time.Time
	NextPageToken  string
}

type MemoriesQuery struct {
	Scope, Subtype, Purpose string
	ValidAt                 time.Time
	KnowledgeRevision       int64
	KnownAt                 *time.Time
	Limit                   int
	PageToken               string
}

type MemoryDependency struct {
	Scope, RecordID, VersionID, ContentDigest string
	// Label preserves the application's distinction between assertions and uncertainty.
	Label string
}

type MemoryExtractionCandidate struct {
	ID, Subtype, SchemaVersion, Body string
	Valid                            Interval
	Sources                          []SourceSpan
	Uncertainty, Rationale           string
	Confidence                       float64
}

type MemoryExtractionOutput struct {
	Candidates []MemoryExtractionCandidate `json:"candidates"`
}

type MemoryExtractionTarget struct {
	ID, Subtype, SchemaVersion string
	Dependencies               []MemoryDependency
}

type MemoryExtractionTx interface {
	MemoryLifecycleTx
	MemoryVersions(context.Context, string, int64) ([]MemoryVersion, error)
}

type MemoryHistoryPageTx interface {
	Tx
	MemoryHistoryPage(context.Context, string, int64, int64, int) ([]Event, error)
}

type MemoryKey struct{ Scope, ID string }

type MemoryLifecycleTx interface {
	MemoryTx
	TemporalTx
	MemoryTimeline(context.Context, string, int64) ([]Acceptance, error)
	StageMemoryTimeline(context.Context, string, []Acceptance) error
	MemoryRejected(context.Context, string, string, int64) (bool, error)
	MemoryHasAcceptance(context.Context, string, string) (bool, error)
	StageMemoryRejection(context.Context, string, string) error
	MemoryStreamRevisionAt(context.Context, string, int64) (int64, error)
	MemoryAttestations(context.Context, string, int64) ([]Attestation, error)
	StageMemoryAttestation(context.Context, Attestation) error
}

type MemoryListItem struct {
	Key    MemoryKey
	Memory MemoryResult
}

type MemoryProjection struct {
	Key                          MemoryKey
	Subtype, SchemaVersion, Body string
	Dependencies                 []MemoryDependency
}

type MemoryProposal struct {
	Command
	Key                          MemoryKey
	Subtype, SchemaVersion, Body string
	Valid                        Interval
	Sources                      []SourceSpan
	Dependencies                 []MemoryDependency
	ExpectedRevision             int64
}

type MemoryQuery struct {
	Key               MemoryKey
	Purpose           string
	ValidAt           time.Time
	KnowledgeRevision int64
	KnownAt           *time.Time
}

type MemoryRecallItem struct {
	Key    MemoryKey
	Memory MemoryResult
	Score  float64
}

type MemoryRecallResult struct {
	Items                           []MemoryRecallItem
	Generation                      string
	LedgerRevision, IndexedRevision int64
	Incomplete                      bool
}

type MemoryRefreshBinding struct{ Scope, ProfileID string }

type MemoryRefreshDependency struct {
	Scope, RecordID string
	Timeline        []Acceptance
	Versions        []Version
}

type MemoryRefreshInput struct {
	Schema                         string
	Original                       MemoryVersion
	Definition                     MemoryType
	LedgerRevision, StreamRevision int64
	Dependencies                   []MemoryRefreshDependency
	Evidence                       []ExtractionInputMessage
}

type MemoryRefreshOutput struct {
	Body          string
	Dependencies  []MemoryDependency
	DeclineReason string
}

type MemoryRefreshRequest struct {
	Trigger       *MemoryRefreshTrigger    `json:",omitempty"`
	PayloadRanges []ExtractionPayloadRange `json:",omitempty"`
	Command
	Scope, RecordID, VersionID, ProfileID string
}

type MemoryRefreshScan struct {
	Scope, Purpose string
	Trigger        MemoryRefreshTrigger
	AfterVersionID string
	Limit          int
}

type MemoryRefreshScanResult struct{ Versions []VersionReference }

type MemoryRefreshScanTx interface {
	Tx
	MemoryRefreshEvent(context.Context, MemoryRefreshTrigger) (Event, error)
	MemoryRefreshDependents(context.Context, string, string, int64, string, int) ([]VersionReference, error)
}

type MemoryRefreshScheduler interface {
	ScanMemoryRefresh(context.Context, Caller, MemoryRefreshScan) (MemoryRefreshScanResult, error)
	StartMemoryRefresh(context.Context, Caller, MemoryRefreshRequest) (JobStatus, error)
}

type MemoryRefreshSweep struct {
	Stream, ProfileID, ProfileDigest string
	ScheduledFor                     time.Time
	Interval                         time.Duration
}

type MemoryRefreshSweepRequest struct {
	Command
	Scope, Stream, ProfileID string
	ScheduledFor             time.Time
	Interval                 time.Duration
}

type MemoryRefreshSweepStarter interface {
	StartMemoryRefreshSweep(context.Context, Caller, MemoryRefreshSweepRequest) (CommitResult, error)
}

type MemoryRefreshTrigger struct {
	EventID        string
	LedgerRevision int64
}

type MemoryResult struct {
	State, RecordID, VersionID, Body string
	StreamRevision, LedgerRevision   int64
	Dependencies                     []MemoryDependency
}

type MemoryTx interface {
	Tx
	MemoryType(context.Context, string, string, string) (MemoryType, error)
	ActiveMemoryType(context.Context, string, string) (string, error)
	StageMemoryType(context.Context, MemoryType) error
	LockMemory(context.Context, MemoryKey) (Record, error)
	StageMemoryVersion(context.Context, MemoryVersion) error
	MemoryVersion(context.Context, string, string) (MemoryVersion, error)
}

type MemoryType struct {
	Scope, Subtype, Version, PolicyID, Classification string
	Migration                                         *PredicateMigration `json:",omitempty"`
}

type MemoryTypeRequest struct {
	Command
	Definition MemoryType
}

type MemoryVersion struct {
	PayloadDisposed                bool `json:",omitempty"`
	Authorization                  []AuthorizationDecision
	ID, RecordID, Digest, PolicyID string
	Proposal                       MemoryProposal
	Proposer                       Caller
	LedgerRevision                 int64
}

type MemoryVersionQuery struct{ Scope, RecordID, VersionID, Purpose string }

type ObjectRef struct {
	Locator, Version, Digest string
	Size                     int64
}

type OperationsOptions struct {
	Scope    string
	Store    RebuildStore
	Index    RebuildIndex
	Progress Outbox
}

type OrphanEvidenceDisposalRequest struct {
	Command
	Scope, PolicyID, Jurisdiction, Reason string
	Object                                ObjectRef
}

type OrphanEvidenceDisposalTx interface {
	DisposeOrphanEvidence(context.Context, OrphanEvidenceDisposalRequest) error
}

type OrphanEvidenceEngine interface {
	ScanOrphanEvidence(context.Context, Caller, OrphanEvidenceQuery) ([]ObjectRef, error)
	DisposeOrphanEvidence(context.Context, Caller, OrphanEvidenceDisposalRequest) (CommitResult, error)
}

type OrphanEvidenceQuery struct {
	Scope, PolicyID, Jurisdiction, Purpose string
	AfterLocator, AfterVersion             string
	Limit                                  int
}

type OrphanEvidenceScannerTx interface {
	ScanOrphanEvidence(context.Context, OrphanEvidenceQuery) ([]ObjectRef, error)
}

type Outbox interface {
	RegisterConsumer(context.Context, ConsumerKey, int) error
	ClaimDelivery(context.Context, ConsumerKey, time.Duration) (Delivery, error)
	RenewDelivery(context.Context, Delivery, time.Duration) error
	AcknowledgeDelivery(context.Context, Delivery) error
	FailDelivery(context.Context, Delivery, time.Duration) error
	ConsumerStatus(context.Context, ConsumerKey) (ConsumerStatus, error)
	RetryConsumer(context.Context, ConsumerKey, int64) error
}

type OutboxProgress struct {
	LedgerRevision, AcknowledgedRevision int64
	OldestRecordedAt                     *time.Time
	State                                string
}

type OutboxProgressReader interface {
	ReadOutboxProgress(context.Context, ConsumerKey) (OutboxProgress, error)
}

type PagedRebuildIndex interface {
	VerifyProjectionPages(context.Context, GenerationKey, int64, ProjectionPageLoader) (ProjectionCheck, error)
}

type PagedRebuildStore interface {
	ProjectionDocumentPage(context.Context, GenerationKey, int64, int64, ProjectionCursor, int) (ProjectionPage, error)
}

type PendingEvidenceUpload struct{ ID, Scope, PolicyID string }

type PolicyRequest struct {
	Command
	Policy AcceptancePolicy
}

type PredicateBinding struct{ Predicate, SchemaVersion string }

type PredicateMigration struct {
	FromVersion, Mode, Reason string
}

type PredicateRequest struct {
	Command
	Definition PredicateVersion
}

type PredicateVersion struct {
	Scope, Predicate, Version, PolicyID string
	Kind                                ValueKind
	Classification                      string
	Migration                           *PredicateMigration `json:",omitempty"`
	Constraints                         *ValueConstraints   `json:",omitempty"`
	Cardinality                         string              `json:",omitempty"`
	TemporalPrecision                   string              `json:",omitempty"`
}

type ProjectionCheck struct {
	Version string `json:",omitempty"`
	Count   int
	Digest  string
}

type ProjectionCleanupCursor struct{ Kind, VersionID, Generation string }

type ProjectionCleanupEngine interface {
	CleanupProjection(context.Context, Caller, ProjectionCleanupRequest) (CommitResult, error)
}

type ProjectionCleanupGate interface {
	ProjectionDisposalSealer
	SetProjectionGate(context.Context, GenerationKey, int64, bool) error
}

type ProjectionCleanupKey struct{ Tenant, Kind, VersionID string }

type ProjectionCleanupOptions struct{ Destination ProjectionDisposer }

type ProjectionCleanupPlan struct {
	Target        ProjectionDisposal
	TerminalFence int64
}

type ProjectionCleanupQuery struct {
	Tenant string
	After  ProjectionCleanupCursor
	Limit  int
}

type ProjectionCleanupReader interface {
	ProjectionCleanupStatus(context.Context, ProjectionCleanupKey) (ProjectionCleanupStatus, error)
}

type ProjectionCleanupRequest struct {
	Command
	Kind, Scope, RecordID, VersionID, DisposalEventID, Generation, Reason string
	Bindings                                                              []VersionRetentionBinding
}

type ProjectionCleanupScanner interface {
	ScanProjectionCleanup(context.Context, ProjectionCleanupQuery) ([]ProjectionCleanupRequest, error)
}

type ProjectionCleanupStatus struct {
	Key            ProjectionCleanupKey
	InventoryEpoch int64
	CreatedAt      time.Time
	Targets        []ProjectionCleanupTarget
	Complete       bool
}

type ProjectionCleanupTarget struct {
	Generation, AcknowledgementID string
	CompletedAt                   *time.Time
}

type ProjectionCleanupTx interface {
	PrepareProjectionCleanup(context.Context, ProjectionCleanupRequest) (ProjectionCleanupPlan, error)
}

type ProjectionCursor struct{ Kind, VersionID string }

type ProjectionDestinationInventory struct {
	Destinations     []GenerationKey
	MissingConsumers []string
	Epoch            int64
}

type ProjectionDestinationRegistry interface {
	RegisterProjectionDestination(context.Context, GenerationKey) error
	ProjectionDestinationInventory(context.Context, string) (ProjectionDestinationInventory, error)
}

type ProjectionDisposal struct{ Tenant, Generation, Kind, VersionID string }

type ProjectionDisposalSealer interface {
	SealProjectionForDisposal(context.Context, GenerationKey, int64) error
}

type ProjectionDisposer interface {
	DisposeProjection(context.Context, ProjectionDisposal) error
}

type ProjectionDocument struct {
	Memory                                                                           *MemoryProjection `json:",omitempty"`
	Tenant, Generation, RecordID, VersionID, VersionDigest, PolicyID, Classification string
	Key                                                                              FactKey
	Value                                                                            Value
	Valid                                                                            Interval
	SourceClasses                                                                    []string
}

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

type ProjectionPage struct {
	Documents []ProjectionDocument
	// Next is the last scanned acceptance, including disposed versions. A page
	// may contain no documents and still advance. Nil means the scan is complete.
	Next *ProjectionCursor
}

type ProjectionPageLoader func(context.Context, ProjectionCursor) (ProjectionPage, error)

type ProjectionReceipt struct {
	Generation      string
	IndexedRevision int64
}

type ProjectionRegistry interface {
	ActiveProjection(context.Context, string) (ActiveProjection, error)
}

type ProjectionSource interface {
	ProjectionDocument(context.Context, Delivery, string) (*ProjectionDocument, error)
}

type ProjectionStatus struct {
	Active         ActiveProjection
	Rebuild        RebuildStatus
	Consumer       ConsumerStatus
	LedgerRevision int64
	Incomplete     bool
}

type ProjectionStatusQuery struct{ Generation, Purpose string }

type ProjectionWaitRequest struct {
	Scopes              []string
	Generation, Purpose string
	Revision            int64
}

type ReadOptions struct {
	PaginationKey []byte
	TokenLifetime time.Duration
}

type ReadTx interface {
	TemporalTx
	RevisionAt(context.Context, time.Time) (int64, error)
	FactRecords(context.Context, FactsQuery, int64, string, int) ([]Record, error)
	// MemoryRecords returns memory records in the scope, ordered by record ID,
	// whose key is carried as Record.Key.Scope and Record.Key.Discriminator.
	MemoryRecords(context.Context, MemoriesQuery, int64, string, int) ([]Record, error)
}

type RebuildActor struct {
	Principal, Purpose string
	// Present for application-authorized operations; legacy trusted worker callers
	// retain their host-supplied principal and purpose contract.
	Caller        *Caller                `json:",omitempty"`
	Authorization *AuthorizationDecision `json:",omitempty"`
}

type RebuildIndex interface {
	RetrievalIndex
	SetProjectionGate(context.Context, GenerationKey, int64, bool) error
	VerifyProjection(context.Context, GenerationKey, int64, []ProjectionDocument) (ProjectionCheck, error)
}

type RebuildRequest struct {
	Generation, Action, Purpose string
	MaxAttempts                 int
	ExpectedFence               int64
}

type RebuildStatus struct {
	VerificationVersion               string `json:",omitempty"`
	Key                               GenerationKey
	State                             string
	Fence, ThroughRevision, BaseEpoch int64
	PreviousGeneration                string
	Count                             int
	Digest                            string
}

type RebuildStore interface {
	ProjectionRegistry
	StartRebuild(context.Context, GenerationKey, RebuildActor, int) (RebuildStatus, error)
	RebuildStatus(context.Context, GenerationKey) (RebuildStatus, error)
	FreezeRebuild(context.Context, GenerationKey, RebuildActor) (RebuildStatus, error)
	VerifyRebuild(context.Context, GenerationKey, RebuildActor, int64, ProjectionCheck) (RebuildStatus, error)
	ResumeRebuild(context.Context, GenerationKey, RebuildActor, int64) (RebuildStatus, error)
	FinishResume(context.Context, GenerationKey, RebuildActor, int64) (RebuildStatus, error)
	ActivateRebuild(context.Context, GenerationKey, RebuildActor, int64) (RebuildStatus, error)
	FinishActivation(context.Context, GenerationKey, RebuildActor, int64) (RebuildStatus, error)
	AbandonRebuild(context.Context, GenerationKey, RebuildActor, int64) (RebuildStatus, error)
	ProjectionDocuments(context.Context, GenerationKey, int64) ([]ProjectionDocument, error)
}

type RecallItem struct {
	Key   FactKey
	Fact  FactResult
	Score float64
}

type RecallRequest struct {
	Scopes                             []string
	Query, Purpose                     string
	RequireGeneration                  string `json:",omitempty"`
	ValidAt                            time.Time
	KnowledgeRevision, RequireRevision int64
	Limit                              int
}

type RecallResult struct {
	Items                           []RecallItem
	Generation                      string
	LedgerRevision, IndexedRevision int64
	Incomplete                      bool
}

type Record struct {
	Kind     string `json:",omitempty"`
	ID       string
	Key      FactKey
	Revision int64
}

type RedactedEvidenceRequest struct {
	Command
	ID, Scope, ParentEvidenceID, PolicyVersion string
	Object                                     ObjectRef
	Ranges                                     []EvidenceCopyRange
}

type ReleaseLegalHoldRequest struct {
	Command
	ID, Scope, Reason string
}

type RetentionDomain interface {
	RetentionDomain(context.Context) (string, error)
}

type RetentionEvent struct {
	DecisionDisposal        *DecisionDisposalRequest     `json:",omitempty"`
	CalculationDisposal     *CalculationDisposalRequest  `json:",omitempty"`
	BatchID                 string                       `json:",omitempty"`
	DisposalBatch           *DisposalBatchRequest        `json:",omitempty"`
	ProjectionCleanup       *ProjectionCleanupRequest    `json:",omitempty"`
	VersionDisposal         *VersionDisposalRequest      `json:",omitempty"`
	AttestationDisposal     *AttestationDisposalRequest  `json:",omitempty"`
	ConversationDisposal    *ConversationDisposalRequest `json:",omitempty"`
	ExtractionDisposal      *ExtractionDisposalRequest   `json:",omitempty"`
	ContextDisposal         *ContextDisposalRequest      `json:",omitempty"`
	SnapshotDisposal        *SnapshotDisposalRequest     `json:",omitempty"`
	AdditionalAuthorization []AuthorizationDecision      `json:",omitempty"`

	ID, Tenant, Scope, Kind, TargetID string
	Caller                            Caller
	Command                           Command
	Policy                            *RetentionPolicy
	Hold                              *LegalHoldRequest
	Release                           *ReleaseLegalHoldRequest
	Disposal                          *EvidenceDisposalRequest
	OrphanDisposal                    *OrphanEvidenceDisposalRequest `json:",omitempty"`
	LedgerRevision                    int64
	Limitations                       []string
}

type RetentionPolicy struct {
	ID, Scope, RecordClass, Purpose, Jurisdiction string
	MinimumAgeSeconds                             int64
}

type RetentionPolicyRequest struct {
	Command
	Policy RetentionPolicy
}

type RetentionStatus struct {
	EvidenceID, PolicyID string
	RegisteredAt         time.Time
	Disposed             bool
	ActiveHolds          []string
	Blockers             []string
}

type RetentionStatusQuery struct{ Scope, EvidenceID, Purpose string }

type RetentionTx interface {
	Tx
	RetentionPolicy(context.Context, string, string) (RetentionPolicy, error)
	StageRetention(context.Context, RetentionEvent) error
	RetentionStatus(context.Context, string, string) (RetentionStatus, error)
	DisposeEvidence(context.Context, EvidenceDisposalRequest) error
}

type RetrievalDescriber interface {
	DescribeRetrieval(context.Context, string, string) (RetrievalIdentity, error)
}

type RetrievalIdentity struct {
	Generation, EmbeddingID, SearchVersion, RerankerID string
	Dimensions                                         int
}

type RetrievalIndex interface {
	Put(context.Context, ProjectionDocument) error
	Candidates(context.Context, string, string, string, string, int) ([]SearchCandidate, error)
}

type RetrievalOptions struct {
	Registry   ProjectionRegistry
	Index      RetrievalIndex
	Progress   Outbox
	Generation string
}

type RevisionConflict struct {
	RecordID                          string
	ExpectedRevision, CurrentRevision int64
}

type ScopeDefinition struct{ ID, Label string }

type ScopeRequest struct {
	Command
	Definition       ScopeDefinition
	ExpectedRevision int64
	Reason           string
}

type ScopeVersion struct {
	Definition               ScopeDefinition
	Revision, LedgerRevision int64
	Caller                   Caller
	Reason                   string
}

type SearchCandidate struct {
	Kind                string `json:",omitempty"`
	RecordID, VersionID string
	Score               float64
}

type SnapshotDisposalRequest struct {
	Command
	SnapshotID, Reason string
	Bindings           []SnapshotRetentionBinding
}

type SnapshotDisposalTx interface {
	DisposeSnapshot(context.Context, SnapshotDisposalRequest) error
}

type SnapshotItem struct {
	Selector                    FactKey
	Resolution                  FactResult
	SchemaVersion, PolicyID     string
	Valid                       Interval
	SourceClasses               []string
	EvidenceIDs, AttestationIDs []string
}

type SnapshotQuery struct {
	ID      string
	Purpose string
}

type SnapshotRetentionBinding struct{ Scope, PolicyID, Jurisdiction string }

type SourceSpan struct {
	EvidenceID string
	Start, End int
	Quote      string
}

type SubjectDefinition struct {
	Scope, ID, Kind, Label string
	// Lookup contains qualified, exact external identifiers, not search terms.
	Lookup map[string]string
}

type SubjectLookupQuery struct{ Scope, Namespace, Value, Purpose string }

type SubjectRequest struct {
	Command
	Definition       SubjectDefinition
	ExpectedRevision int64
	Reason           string
}

type SubjectVersion struct {
	Definition               SubjectDefinition
	Revision, LedgerRevision int64
	Caller                   Caller
	Reason                   string
}

type Supersession struct {
	Approval
	ReplacedVersionIDs []string
	Valid              Interval
	Reason             string
	Automated          bool
}

type TelemetryOptions struct {
	TracerProvider trace.TracerProvider
	MeterProvider  metric.MeterProvider
	Logger         *slog.Logger
}

type TemporalTx interface {
	Tx
	StageTimeline(context.Context, string, []Acceptance) error
	StageRejection(context.Context, string, string) error
	Rejected(context.Context, string, string, int64) (bool, error)
	HasAcceptance(context.Context, string, string) (bool, error)
	Versions(context.Context, string, int64) ([]Version, error)
	HistoricalAttestations(context.Context, string, int64) ([]Attestation, error)
	RevisionTime(context.Context, int64) (time.Time, error)
	StreamRevisionAt(context.Context, string, int64) (int64, error)
	StageSnapshot(context.Context, FactSnapshot) error
	Snapshot(context.Context, string) (FactSnapshot, error)
	History(context.Context, string) ([]Event, error)
}

type Tx interface {
	// RequireScope and RequireSubject reject unregistered write identities.
	RequireScope(context.Context, string) error
	RequireSubject(context.Context, string, string) error
	Receipt(context.Context, Caller, string, string, string) (*CommitResult, error)
	SaveReceipt(context.Context, Caller, string, string, string, CommitResult) error
	Policy(context.Context, string, string) (AcceptancePolicy, error)
	InsertPolicy(context.Context, AcceptancePolicy) error
	Predicate(context.Context, string, string, string) (PredicateVersion, error)
	InsertPredicate(context.Context, PredicateVersion) error
	ActivePredicate(context.Context, string, string) (string, error)
	Evidence(context.Context, string) (Evidence, error)
	InsertEvidence(context.Context, Evidence) (string, error)
	// LockRecord must require a registered subject before locking or creating a record.
	LockRecord(context.Context, FactKey) (Record, error)
	Record(context.Context, string) (Record, error)
	SetRevision(context.Context, string, int64) error
	Version(context.Context, string, string) (Version, error)
	InsertVersion(context.Context, Version) error
	Attestations(context.Context, string) ([]Attestation, error)
	InsertAttestation(context.Context, Attestation) error
	WithdrawAttestation(context.Context, string, string, Caller) (CommitResult, error)
	Acceptances(context.Context, string, int64) ([]Acceptance, error)
	InsertAcceptance(context.Context, string, Acceptance) error
	Append(context.Context, Event) (Event, error)
	Revision(context.Context) (int64, error)
}

type Value struct {
	Kind    ValueKind
	Text    *string
	Boolean *bool
	Integer *int64
	Decimal *string
	Unit    string
	Date    *string
	Instant *time.Time
	Entity  *string
}

type ValueConstraints struct {
	AllowUnknown               *bool    `json:",omitempty"`
	AllowedValues              []Value  `json:",omitempty"`
	MinTextRunes, MaxTextRunes *int     `json:",omitempty"`
	MinInteger, MaxInteger     *int64   `json:",omitempty"`
	MinDecimal, MaxDecimal     *string  `json:",omitempty"`
	DecimalPlaces              *int     `json:",omitempty"`
	Units                      []string `json:",omitempty"`
}

type ValueKind string

type Version struct {
	PayloadDisposed      bool   `json:",omitempty"`
	ExtractionAttemptID  string `json:",omitempty"`
	ID, RecordID, Digest string
	Proposal             FactProposal
	Proposer             Caller
	PolicyID             string
}

type VersionDisposalRequest struct {
	Command
	Kind, Scope, RecordID, VersionID, Reason string
	Bindings                                 []VersionRetentionBinding
}

type VersionDisposalTx interface {
	DisposeVersion(context.Context, VersionDisposalRequest) (int64, error)
}

type VersionReference struct{ RecordID, VersionID string }

type VersionRetentionBinding struct{ Scope, PolicyID, Jurisdiction string }

type Withdrawal struct {
	Command
	Scope, AttestationID string
}