ontology

type ACLPolicy interface {
	Check(principal string, required Permission) error
}

type ActionEffects struct {
	FactsAsserted  []FactEffect     `json:"factsAsserted,omitempty"`
	FactsRetracted []FactRetraction `json:"factsRetracted,omitempty"`
	PropertiesSet  []PropertyEffect `json:"propertiesSet,omitempty"`
}

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

type ActionLogEntry struct {
	ID          uuid.UUID         `json:"id"`
	ActionName  string            `json:"actionName"`
	Principal   string            `json:"principal"`
	Params      map[string]string `json:"params"`
	Status      ActionStatus      `json:"status"`
	Effects     *ActionEffects    `json:"effects,omitempty"`
	Error       string            `json:"error,omitempty"`
	StartedAt   time.Time         `json:"startedAt"`
	CompletedAt *time.Time        `json:"completedAt,omitempty"`
}

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

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

type ActionResult struct {
	LogID   uuid.UUID      `json:"logID"`
	Status  ActionStatus   `json:"status"`
	Effects *ActionEffects `json:"effects,omitempty"`
	Error   string         `json:"error,omitempty"`
}

type ActionStatus string

type ActionSummary struct {
	Name         string            `json:"name"`
	Description  string            `json:"description"`
	RequiredPerm Permission        `json:"requiredPerm"`
	ParamSchema  map[string]string `json:"paramSchema"`
}

type ActionType struct {
	Name        string
	Description string
	// RequiredPerm is the permission the executor checks before running.
	// INVARIANT: must be >= max permission of any OntologyService method
	// called by Execute or Compensate. Violating this causes "executor
	// passed but service rejected" partial failures.
	RequiredPerm Permission
	// ParamSchema maps parameter names to descriptions (used for tool generation).
	ParamSchema map[string]string
	// Precondition validates whether the action can be executed.
	// Returns nil if preconditions are met.
	Precondition func(ctx context.Context, svc OntologyService, params map[string]string) error
	// Execute performs the action and returns its effects.
	Execute func(ctx context.Context, svc OntologyService, params map[string]string) (*ActionEffects, error)
	// Compensate reverses the effects on Execute failure. May be nil.
	Compensate func(ctx context.Context, svc OntologyService, effects *ActionEffects) error
}

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

type AllowAllPolicy struct{}

type AssertionInput struct {
	Triple     graph.Triple
	Source     string    // origin category (key in SourcePrecedence)
	Confidence float64   // 0.0–1.0
	ValidFrom  time.Time // zero = now
}

type AssertionResult struct {
	Stored     bool
	ConflictID *uuid.UUID // non-nil when a conflict was created
	Message    string
}

type CandidateTriple struct {
	Subject    string `json:"subject"`
	Object     string `json:"object"`
	Source     string `json:"source"`
	Confidence string `json:"confidence"`
	RecordedAt string `json:"recorded_at"`
}

type Cardinality string

type Conflict struct {
	ID         uuid.UUID
	Subject    string
	Predicate  string
	Candidates []CandidateTriple
	Status     ConflictStatus
	ResolvedAt *time.Time
	Resolution string
	CreatedAt  time.Time
}

type ConflictStatus string

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

type Constraint struct {
	Kind  ConstraintKind `json:"kind"`
	Value string         `json:"value"`
}

type ConstraintKind string

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

type EntityResolver interface {
	// Resolve returns the canonical ID for a raw ID. If no alias exists, returns rawID unchanged.
	Resolve(ctx context.Context, rawID string) (string, error)

	// RegisterAlias creates a mapping from rawID to canonicalID.
	RegisterAlias(ctx context.Context, rawID, canonicalID, source string) error

	// DeclareSameAs declares that nodeA and nodeB refer to the same entity.
	// The canonical is chosen by source precedence; ties go to the first-created alias.
	DeclareSameAs(ctx context.Context, nodeA, nodeB, source string) error

	// Merge moves all relationships from duplicate to canonical and retracts the originals.
	// Order: snapshot → replicate → retract → alias (last, to avoid mid-merge canonicalization).
	Merge(ctx context.Context, canonical, duplicate string) (*MergeResult, error)

	// Split removes the alias for splitOut from canonical. Relationship restoration is manual.
	Split(ctx context.Context, canonical, splitOut string) error

	// Aliases returns all raw IDs that map to canonicalID.
	Aliases(ctx context.Context, canonicalID string) ([]string, error)
}

type EntityResult struct {
	EntityID   string            `json:"entityId"`
	EntityType string            `json:"entityType"`
	Properties map[string]string `json:"properties"`
	Outgoing   []ResultTriple    `json:"outgoing,omitempty"` // subject=entityID
	Incoming   []ResultTriple    `json:"incoming,omitempty"` // object=entityID
}

type FactEffect struct {
	Subject   string `json:"subject"`
	Predicate string `json:"predicate"`
	Object    string `json:"object"`
}

type FactRetraction struct {
	Subject   string `json:"subject"`
	Predicate string `json:"predicate"`
	Object    string `json:"object"`
	Reason    string `json:"reason"`
}

type FilterOp string

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

type GovernancePolicy struct {
	MaxNewPerDay          int // combined daily limit for type + predicate proposals
	QuarantinePeriodHrs   int
	ShadowModeDurationHrs int
	MinUsageForPromotion  int
	SchemaExplosionBudget int // per month, type + predicate combined
}

type ImportMode string

type ImportOptions struct {
	Mode      ImportMode `json:"mode"`
	SourceDID string     `json:"sourceDID,omitempty"` // DID of the exporting peer
}

type ImportResult struct {
	TypesAdded       int      `json:"typesAdded"`
	TypesSkipped     int      `json:"typesSkipped"`
	TypesConflicting []string `json:"typesConflicting,omitempty"`
	PredsAdded       int      `json:"predsAdded"`
	PredsSkipped     int      `json:"predsSkipped"`
	PredsConflicting []string `json:"predsConflicting,omitempty"`
}

type MergeResult struct {
	TriplesUpdated int
	AliasesCreated int
}

type ObjectType struct {
	ID          uuid.UUID     `json:"id"`
	Name        string        `json:"name"`
	Description string        `json:"description"`
	Properties  []PropertyDef `json:"properties"`
	Extends     string        `json:"extends,omitempty"`
	Status      SchemaStatus  `json:"status"`
	Version     int           `json:"version"`
	CreatedAt   time.Time     `json:"createdAt"`
	UpdatedAt   time.Time     `json:"updatedAt"`
}

type OntologyService interface {
	// Schema queries
	GetType(ctx context.Context, name string) (*ObjectType, error)
	ListTypes(ctx context.Context) ([]ObjectType, error)
	GetPredicate(ctx context.Context, name string) (*PredicateDefinition, error)
	ListPredicates(ctx context.Context) ([]PredicateDefinition, error)

	// Schema mutations
	RegisterType(ctx context.Context, t ObjectType) error
	RegisterPredicate(ctx context.Context, p PredicateDefinition) error
	DeprecateType(ctx context.Context, name string) error
	DeprecatePredicate(ctx context.Context, name string) error

	// Validation
	ValidateTriple(ctx context.Context, t graph.Triple) error

	// Schema version — increments on register/deprecate
	SchemaVersion(ctx context.Context) (int, error)

	// Triple storage facade — Resolve → store.AddTriple.
	// When EntityResolver is available, canonicalizes subject and object
	// before storing. Predicate validation is NOT performed here — use
	// AssertFact for validated storage with temporal metadata and conflict detection.
	StoreTriple(ctx context.Context, t graph.Triple) error

	// PredicateValidator returns a context-free closure for hot-path
	// predicate validation. Uses a cached map, refreshed on schema changes.
	PredicateValidator() func(name string) bool

	// Truth Maintenance — Change 1-3
	AssertFact(ctx context.Context, input AssertionInput) (*AssertionResult, error)
	RetractFact(ctx context.Context, subject, predicate, object, reason string) error
	ConflictSet(ctx context.Context, subject, predicate string) ([]Conflict, error)
	ResolveConflict(ctx context.Context, conflictID uuid.UUID, winnerObject, reason string) error
	FactsAt(ctx context.Context, subject string, validAt time.Time) ([]graph.Triple, error)
	OpenConflicts(ctx context.Context) ([]Conflict, error)

	// Entity Resolution — Change 1-4
	Resolve(ctx context.Context, rawID string) (string, error)
	DeclareSameAs(ctx context.Context, nodeA, nodeB, source string) error
	MergeEntities(ctx context.Context, canonical, duplicate string) (*MergeResult, error)
	SplitEntity(ctx context.Context, canonical, splitOut string) error
	Aliases(ctx context.Context, canonicalID string) ([]string, error)
	// QueryTriples resolves subject via alias before querying graph store.
	QueryTriples(ctx context.Context, subject string) ([]graph.Triple, error)

	// Property Store — Change 1.5-1
	SetEntityProperty(ctx context.Context, entityID, entityType, property, value string) error
	GetEntityProperties(ctx context.Context, entityID string) (map[string]string, error)
	QueryEntities(ctx context.Context, q PropertyQuery) ([]EntityResult, error)
	GetEntity(ctx context.Context, entityID string) (*EntityResult, error)
	DeleteEntityProperties(ctx context.Context, entityID string) error

	// Action Types — Change 2-2
	ExecuteAction(ctx context.Context, actionName string, params map[string]string) (*ActionResult, error)
	ListActions(ctx context.Context) ([]ActionSummary, error)
	GetActionLog(ctx context.Context, logID uuid.UUID) (*ActionLogEntry, error)
	ListActionLogs(ctx context.Context, actionName string, limit int) ([]ActionLogEntry, error)

	// Governance — Change 2-3
	PromoteType(ctx context.Context, typeName string, targetStatus SchemaStatus, reason string) error
	PromotePredicate(ctx context.Context, predName string, targetStatus SchemaStatus, reason string) error
	SchemaHealth(ctx context.Context) (*SchemaHealthReport, error)
	TypeUsage(ctx context.Context, typeName string) (*TypeUsageInfo, error)

	// Schema Exchange — Change 3-1
	ExportSchema(ctx context.Context) (*SchemaBundle, error)
	ImportSchema(ctx context.Context, bundle *SchemaBundle, opts ImportOptions) (*ImportResult, error)

	// P2P Fact Exchange — Change 3-4
	AssertP2PFact(ctx context.Context, input P2PFactInput) (*AssertionResult, error)
	VerifyP2PFact(ctx context.Context, subject, predicate, object string) error
}

type P2PFactInput struct {
	Triple     graph.Triple
	PeerDID    string  // DID of the asserting peer
	PeerTrust  float64 // 0.0-1.0 peer reputation score
	Confidence float64 // peer's claimed confidence
}

type Permission int

type PredicateDefinition struct {
	ID          uuid.UUID    `json:"id"`
	Name        string       `json:"name"`
	Description string       `json:"description"`
	SourceTypes []string     `json:"sourceTypes"`
	TargetTypes []string     `json:"targetTypes"`
	Cardinality Cardinality  `json:"cardinality"`
	Inverse     string       `json:"inverse,omitempty"`
	Status      SchemaStatus `json:"status"`
	Version     int          `json:"version"`
	CreatedAt   time.Time    `json:"createdAt"`
	UpdatedAt   time.Time    `json:"updatedAt"`
}

type PropertyDef struct {
	Name        string       `json:"name"`
	Type        PropertyType `json:"type"`
	Required    bool         `json:"required"`
	Indexed     bool         `json:"indexed"`
	Constraints []Constraint `json:"constraints,omitempty"`
}

type PropertyEffect struct {
	EntityID string `json:"entityID"`
	Property string `json:"property"`
	OldValue string `json:"oldValue,omitempty"`
	NewValue string `json:"newValue"`
}

type PropertyFilter struct {
	Property string   `json:"property"`
	Op       FilterOp `json:"op"`
	Value    string   `json:"value"`
}

type PropertyQuery struct {
	EntityType string           `json:"entityType"` // required
	Filters    []PropertyFilter `json:"filters"`    // AND
	Limit      int              `json:"limit"`      // default 100
	Offset     int              `json:"offset"`
}

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

type PropertyType string

type Registry interface {
	// ObjectType operations
	RegisterType(ctx context.Context, t ObjectType) error
	GetType(ctx context.Context, name string) (*ObjectType, error)
	ListTypes(ctx context.Context) ([]ObjectType, error)
	DeprecateType(ctx context.Context, name string) error

	// PredicateDefinition operations
	RegisterPredicate(ctx context.Context, p PredicateDefinition) error
	GetPredicate(ctx context.Context, name string) (*PredicateDefinition, error)
	ListPredicates(ctx context.Context) ([]PredicateDefinition, error)
	DeprecatePredicate(ctx context.Context, name string) error

	// UpdateTypeStatus sets the status of an existing type by name.
	UpdateTypeStatus(ctx context.Context, name string, status SchemaStatus) error
	// UpdatePredicateStatus sets the status of an existing predicate by name.
	UpdatePredicateStatus(ctx context.Context, name string, status SchemaStatus) error
}

type ResultTriple struct {
	Subject     string            `json:"subject"`
	Predicate   string            `json:"predicate"`
	Object      string            `json:"object"`
	SubjectType string            `json:"subjectType,omitempty"`
	ObjectType  string            `json:"objectType,omitempty"`
	Metadata    map[string]string `json:"metadata,omitempty"`
}

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

type SchemaBundle struct {
	Version       int                   `json:"version"`       // bundle format version (1)
	SchemaVersion int                   `json:"schemaVersion"` // ontology version at export time
	ExportedAt    time.Time             `json:"exportedAt"`
	ExportedBy    string                `json:"exportedBy"` // DID or "local"
	Types         []SchemaTypeSlim      `json:"types"`
	Predicates    []SchemaPredicateSlim `json:"predicates"`
	Digest        string                `json:"digest"` // SHA256(canonical JSON of Types+Predicates)
}

type SchemaHealthReport struct {
	Types      map[SchemaStatus]int `json:"types"`
	Predicates map[SchemaStatus]int `json:"predicates"`
}

type SchemaPredicateSlim struct {
	Name        string   `json:"name"`
	Description string   `json:"description,omitempty"`
	SourceTypes []string `json:"sourceTypes,omitempty"`
	TargetTypes []string `json:"targetTypes,omitempty"`
	Cardinality string   `json:"cardinality"`
	Inverse     string   `json:"inverse,omitempty"`
}

type SchemaPropertySlim struct {
	Name     string `json:"name"`
	Type     string `json:"type"`
	Required bool   `json:"required"`
}

type SchemaStatus string

type SchemaTypeSlim struct {
	Name        string               `json:"name"`
	Description string               `json:"description,omitempty"`
	Properties  []SchemaPropertySlim `json:"properties,omitempty"`
	Extends     string               `json:"extends,omitempty"`
}

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

type TruthMaintainer interface {
	// AssertFact stores a triple with temporal metadata and detects conflicts
	// based on predicate cardinality (OneToOne, ManyToOne).
	AssertFact(ctx context.Context, input AssertionInput) (*AssertionResult, error)

	// RetractFact sets ValidTo=now on a matching triple (soft delete).
	RetractFact(ctx context.Context, subject, predicate, object, reason string) error

	// ConflictSet returns conflicts for a given subject-predicate pair.
	ConflictSet(ctx context.Context, subject, predicate string) ([]Conflict, error)

	// ResolveConflict picks a winner and retracts losers.
	ResolveConflict(ctx context.Context, conflictID uuid.UUID, winnerObject, reason string) error

	// FactsAt returns triples valid at a specific point in time.
	FactsAt(ctx context.Context, subject string, validAt time.Time) ([]graph.Triple, error)

	// OpenConflicts returns all unresolved conflicts.
	OpenConflicts(ctx context.Context) ([]Conflict, error)
}

type TypeUsageInfo struct {
	TypeName  string       `json:"typeName"`
	Status    SchemaStatus `json:"status"`
	Version   int          `json:"version"`
	CreatedAt time.Time    `json:"createdAt"`
}