query

type AncestorOptions struct {
	MaxGenerations int                                // Limit depth (0 = unlimited)
	IncludeSelf    bool                               // Include starting individual
	Filter         func(*types.IndividualRecord) bool // Custom filter function
	Order          Order                              // BFS or DFS order
}

type AncestorPath struct {
	Ancestor *types.IndividualRecord
	Path     *Path
	Depth    int
}

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

type BadgerDBStorage interface {
	BadgerDB() *badger.DB
}

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

type CacheConfig struct {
	// Hybrid cache sizes
	HybridNodeCacheSize  int `json:"hybrid_node_cache_size"`  // Default: 50000
	HybridXrefCacheSize  int `json:"hybrid_xref_cache_size"`  // Default: 25000
	HybridQueryCacheSize int `json:"hybrid_query_cache_size"` // Default: 5000

	// Query cache size (for in-memory graph)
	QueryCacheSize int `json:"query_cache_size"` // Default: 1000
}

type CacheStats struct {
	NodeCacheSize      int
	NodeCacheCapacity  int
	XrefCacheSize      int
	XrefCacheCapacity  int
	QueryCacheSize     int
	QueryCacheCapacity int
}

type CentralityMetric string

type ComponentOptions struct {
	MaxDepth int // Limit traversal depth (0 = unlimited)
	MaxSize  int // Limit result size (0 = unlimited)
}

type Config struct {
	// Cache configuration
	Cache CacheConfig `json:"cache"`

	// Timeout configuration
	Timeout TimeoutConfig `json:"timeout"`

	// Database configuration
	Database DatabaseConfig `json:"database"`
}

type DatabaseConfig struct {
	// SQLite configuration
	SQLiteMaxOpenConns int `json:"sqlite_max_open_conns"` // Default: 10
	SQLiteMaxIdleConns int `json:"sqlite_max_idle_conns"` // Default: 5

	// PostgreSQL configuration
	PostgreSQLMaxOpenConns    int           `json:"postgresql_max_open_conns"`     // Default: 25
	PostgreSQLMaxIdleConns    int           `json:"postgresql_max_idle_conns"`     // Default: 10
	PostgreSQLConnMaxLifetime time.Duration `json:"postgresql_conn_max_lifetime"`  // Default: 5m
	PostgreSQLConnMaxIdleTime time.Duration `json:"postgresql_conn_max_idle_time"` // Default: 1m
	PostgreSQLDatabaseURL     string        `json:"postgresql_database_url"`       // Default: from DATABASE_URL env var

	// BadgerDB configuration
	BadgerDBValueLogFileSize int64 `json:"badgerdb_value_log_file_size"` // Default: 1GB
}

type DescendantOptions struct {
	MaxGenerations int                                // Limit depth (0 = unlimited)
	IncludeSelf    bool                               // Include starting individual
	Filter         func(*types.IndividualRecord) bool // Custom filter function
	Order          Order                              // BFS or DFS order
}

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

type Direction string

type Edge struct {
	// Core data
	ID   string    // Unique edge ID
	From GraphNode // Source node
	To   GraphNode // Target node

	// Edge properties
	EdgeType  EdgeType    // Type of relationship
	Direction Direction   // Forward, Backward, Bidirectional
	Family    *FamilyNode // Family context (for FAMC/FAMS edges)

	// Metadata
	Properties map[string]interface{} // Additional edge properties
	Weight     float64                // Optional weight for algorithms
}

type EdgeData struct {
	FromID     uint32
	ToID       uint32
	EdgeType   EdgeType
	FamilyID   uint32 // For FAMC/FAMS edges
	Direction  Direction
	Properties map[string]interface{}
}

type EdgeType string

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

type EventFilter func(EventInfo) bool

type EventInfo struct {
	EventID     string
	EventType   string
	Date        string
	Place       string
	Description string
	Owner       GraphNode // Individual or Family that owns this event
}

type EventNode struct {
	*BaseNode
	EventID   string
	EventType string
	EventData map[string]interface{}

	// Cached relationships
	Owner   GraphNode
	Sources []*SourceNode
	Notes   []*NoteNode
}

type EventUniqueBy string

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

type FamilyFilter func(*types.FamilyRecord) bool

type FamilyNode struct {
	*BaseNode
	Family *types.FamilyRecord
	// contains filtered or unexported fields
}

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

type FamilyUniqueBy string

type Filter func(*types.IndividualRecord) bool

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

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

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

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

type GraphNode interface {
	// ID returns the unique identifier of the node.
	ID() string

	// NodeType returns the type of the node.
	NodeType() NodeType

	// Record returns the original GEDCOM record (if applicable).
	// Returns nil for EventNode which doesn't have a top-level record.
	Record() types.Record

	// InEdges returns all edges pointing TO this node.
	InEdges() []*Edge

	// OutEdges returns all edges pointing FROM this node.
	OutEdges() []*Edge

	// AddInEdge adds an incoming edge to this node.
	AddInEdge(*Edge)

	// AddOutEdge adds an outgoing edge from this node.
	AddOutEdge(*Edge)

	// RemoveInEdge removes an incoming edge from this node.
	RemoveInEdge(*Edge)

	// RemoveOutEdge removes an outgoing edge from this node.
	RemoveOutEdge(*Edge)

	// Neighbors returns all nodes connected to this node (via in or out edges).
	Neighbors() []GraphNode

	// Degree returns the total number of edges (in + out).
	Degree() int

	// InDegree returns the number of incoming edges.
	InDegree() int

	// OutDegree returns the number of outgoing edges.
	OutDegree() int
}

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

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

type HybridQueryHelper interface {
	FindByXref(xref string) (uint32, error)
	FindXrefByID(nodeID uint32) (string, error)
	FindByName(pattern string) ([]uint32, error)
	FindByNameExact(name string) ([]uint32, error)
	FindByNameStarts(prefix string) ([]uint32, error)
	FindByBirthDate(start, end time.Time) ([]uint32, error)
	FindByBirthPlace(place string) ([]uint32, error)
	FindBySex(sex string) ([]uint32, error)
	HasChildren(nodeID uint32) (bool, error)
	HasSpouse(nodeID uint32) (bool, error)
	IsLiving(nodeID uint32) (bool, error)
	GetAllIndividualIDs() ([]uint32, error)
}

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

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

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

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

type IndividualNode struct {
	*BaseNode
	Individual *types.IndividualRecord
	// contains filtered or unexported fields
}

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

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

type Metrics struct {

	// Query metrics
	QueryCount     int64
	QueryTotalTime time.Duration
	QueryAvgTime   time.Duration
	QueryMaxTime   time.Duration
	QueryMinTime   time.Duration

	// Cache metrics
	CacheHits    int64
	CacheMisses  int64
	CacheHitRate float64

	// Storage metrics
	StorageReads     int64
	StorageWrites    int64
	StorageReadTime  time.Duration
	StorageWriteTime time.Duration

	// Graph metrics
	NodesLoaded    int64
	EdgesLoaded    int64
	GraphBuildTime time.Duration

	// Error metrics
	ErrorCount  int64
	ErrorByType map[string]int64
	// contains filtered or unexported fields
}

type MetricsSnapshot struct {
	QueryCount       int64
	QueryAvgTime     time.Duration
	QueryMaxTime     time.Duration
	QueryMinTime     time.Duration
	CacheHits        int64
	CacheMisses      int64
	CacheHitRate     float64
	StorageReads     int64
	StorageWrites    int64
	StorageReadTime  time.Duration
	StorageWriteTime time.Duration
	NodesLoaded      int64
	EdgesLoaded      int64
	GraphBuildTime   time.Duration
	ErrorCount       int64
	ErrorByType      map[string]int64
}

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

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

type NameCount struct {
	Name  string
	Count int
}

type NameInfo struct {
	IndividualXref string
	Name           *types.GedcomName
	IsPrimary      bool
}

type NameUniqueBy string

type NodeData struct {
	ID       uint32
	Xref     string
	NodeType NodeType
	// Event-specific fields (only used for NodeTypeEvent)
	EventType string
	EventData map[string]interface{}
}

type NodeMetadata struct {
	XrefID      string
	NodeType    NodeType
	ComponentID uint32 // For graph partitioning (0 = unassigned)
	Loaded      bool   // Whether the node is currently loaded in memory
}

type NodeType string

type NoteInfo struct {
	XrefID     string            // Empty for inline notes
	Text       string            // Note text content
	IsInline   bool              // True if inline, false if referenced
	NoteRecord *types.NoteRecord // nil for inline notes
}

type NoteNode struct {
	*BaseNode
	Note *types.NoteRecord

	// Cached relationships
	ReferencedBy []GraphNode
}

type Order string

type Path struct {
	Nodes  []GraphNode
	Edges  []*Edge
	Length int
	Type   PathType
}

type PathOptions struct {
	MaxLength      int  // Maximum path length (0 = unlimited, but defaults to 10)
	IncludeMarital bool // Include marital relationships
	IncludeBlood   bool // Include blood relationships
	ShortestOnly   bool // Return only shortest path
}

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

type PathType string

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

type PlaceUniqueBy string

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

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

type RelationshipResult struct {
	RelationshipType string
	Degree           int
	Removal          int
	Path             *Path
	AllPaths         []*Path
	IsDirect         bool
	IsAncestral      bool
	IsDescendant     bool
	IsCollateral     bool
}

type RepositoryNode struct {
	*BaseNode
	Repository *types.RepositoryRecord

	// Cached relationships
	Sources []*SourceNode
}

type SourceNode struct {
	*BaseNode
	Source *types.SourceRecord

	// Cached relationships
	ReferencedBy []GraphNode
	Repository   *RepositoryNode
}

type SubtreeOptions struct {
	AncestorGenerations   int                                // Max ancestor generations (0 = unlimited)
	DescendantGenerations int                                // Max descendant generations (0 = unlimited)
	IncludeSelf           bool                               // Include starting individual
	IncludeSiblings       bool                               // Include siblings
	IncludeSpouses        bool                               // Include spouses
	Filter                func(*types.IndividualRecord) bool // Custom filter function
}

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

type SubtreeResult struct {
	Root        *types.IndividualRecord   // The starting individual
	Ancestors   []*types.IndividualRecord // Ancestors (upward)
	Descendants []*types.IndividualRecord // Descendants (downward)
	Siblings    []*types.IndividualRecord // Siblings (if included)
	Spouses     []*types.IndividualRecord // Spouses (if included)
	All         []*types.IndividualRecord // Combined list (deduplicated)
}

type TimeoutConfig struct {
	// Database operation timeouts
	SQLiteQueryTimeout time.Duration `json:"sqlite_query_timeout"` // Default: 30s
	BadgerDBTimeout    time.Duration `json:"badgerdb_timeout"`     // Default: 10s

	// Graph building timeout
	BuildTimeout time.Duration `json:"build_timeout"` // Default: 5m

	// Query execution timeout
	QueryTimeout time.Duration `json:"query_timeout"` // Default: 1m
}