forma

type AttributeMetadata struct {
	AttributeName string    `json:"attr_name"`  // attr_name, JSON Path
	AttributeID   int16     `json:"attr_id"`    // attr_id
	ValueType     ValueType `json:"value_type"` // 'text', 'numeric', 'date', 'bool'
	// ItemsType is the element value type when ValueType is ValueTypeList.
	// Empty means text (see EffectiveItemsType).
	ItemsType      ValueType      `json:"items_type,omitempty"`
	RequiredPolicy RequiredPolicy `json:"required_policy,omitempty"`
	// Required is kept for backward compatibility with older metadata readers.
	// New code should use RequiredPolicy.
	Required      bool               `json:"required,omitempty"`
	ColumnBinding *MainColumnBinding `json:"column_binding,omitempty"`
	// Retired marks an attribute removed from the schema whose entry stays in
	// the attributes file as the attributeID ledger (#342). Retired attributes
	// are excluded from every active cache — reads skip their EAV rows (#294),
	// writes preserve them — but their (id, name, valueType) still guards
	// against rebinding the freed id to a different attribute.
	Retired bool `json:"retired,omitempty"`
}

type AttributeStorageLocation string

type BatchConfig struct {
	EnableDynamicSizing      bool `json:"enableDynamicSizing"`
	EnableParallelProcessing bool `json:"enableParallelProcessing"`
	EnableBatchStreaming     bool `json:"enableBatchStreaming"`
	ParallelThreshold        int  `json:"parallelThreshold"`
	StreamingThreshold       int  `json:"streamingThreshold"`
	MaxParallelWorkers       int  `json:"maxParallelWorkers"`
	StreamingChunkSize       int  `json:"streamingChunkSize"`
	StreamingDelay           int  `json:"streamingDelay"` // milliseconds
	MaxComplexityPerBatch    int  `json:"maxComplexityPerBatch"`
	AttributeComplexityScore int  `json:"attributeComplexityScore"`
	OptimalChunkSize         int  `json:"optimalChunkSize"`
}

type BatchOperation struct {
	Operations []EntityOperation `json:"operations"`
	Atomic     bool              `json:"atomic"` // Request all-or-nothing execution; may be rejected when unsupported.
}

type BatchResult struct {
	Successful []*DataRecord    `json:"successful"`
	Failed     []OperationError `json:"failed"`
	TotalCount int              `json:"totalCount"`
	Duration   int64            `json:"duration"` // microseconds
}

type CascadeAction string

type CascadeRule struct {
	SourceSchema string        `json:"sourceSchema"`
	TargetSchema string        `json:"targetSchema"`
	Action       CascadeAction `json:"action"`
	MaxDepth     int           `json:"maxDepth,omitempty"`
}

type CompositeCondition struct {
	Logic      Logic       `json:"l"`
	Conditions []Condition `json:"c"`
}

type Condition interface {
	IsLeaf() bool
}

type Config struct {
	Database       DatabaseConfig    `json:"database"`
	Query          QueryConfig       `json:"query"`
	Entity         EntityConfig      `json:"entity"`
	Transaction    TransactionConfig `json:"transaction"`
	Performance    PerformanceConfig `json:"performance"`
	Logging        LoggingConfig     `json:"logging"`
	Metrics        MetricsConfig     `json:"metrics"`
	Reference      ReferenceConfig   `json:"reference"`
	DuckDB         DuckDBConfig      `json:"duckdb"`
	SchemaRegistry SchemaRegistry    `json:"-"` // Custom schema registry implementation (optional)
}

type ConfigError struct {
	Field   string `json:"field"`
	Message string `json:"message"`
}

type CrossSchemaRequest struct {
	SchemaNames  []string  `json:"schema_names" validate:"required"`
	SearchTerm   string    `json:"search_term" validate:"required"`
	Page         int       `json:"page" validate:"min=1"`
	ItemsPerPage int       `json:"items_per_page" validate:"min=1,max=100"`
	Condition    Condition `json:"-"`               // Custom unmarshal, can be CompositeCondition or KvCondition
	Attrs        []string  `json:"attrs,omitempty"` // Attributes to return (field projection)
}

type CursorQueryResult struct {
	Data          []*DataRecord `json:"data"`
	NextCursor    string        `json:"next_cursor,omitempty"`
	HasMore       bool          `json:"has_more"`
	ExecutionTime time.Duration `json:"execution_time"`
}

type DataRecord struct {
	SchemaName string         `json:"schema_name"`
	RowID      uuid.UUID      `json:"row_id"`
	Attributes map[string]any `json:"attributes"`
}

type DatabaseConfig struct {
	Host            string        `json:"host"`
	Port            int           `json:"port"`
	Database        string        `json:"database"`
	Username        string        `json:"username"`
	Password        string        `json:"password"`
	SSLMode         string        `json:"sslMode"`
	Schema          string        `json:"schema"`
	MaxConnections  int           `json:"maxConnections"`
	MaxIdleConns    int           `json:"maxIdleConns"`
	ConnMaxLifetime time.Duration `json:"connMaxLifetime"`
	ConnMaxIdleTime time.Duration `json:"connMaxIdleTime"`
	Timeout         time.Duration `json:"timeout"`
	TableNames      TableNames    `json:"tableNames"`
}

type DuckDBConfig struct {
	Enabled        bool          `json:"enabled"`
	DBPath         string        `json:"dbPath"`        // path to local DuckDB file (or ":memory:")
	MemoryLimitMB  int           `json:"memoryLimitMB"` // memory limit for DuckDB in MB
	EnableS3       bool          `json:"enableS3"`      // enable S3/http file system
	S3Endpoint     string        `json:"s3Endpoint"`    // custom S3 endpoint (for MinIO)
	S3AccessKey    string        `json:"s3AccessKey"`
	S3SecretKey    string        `json:"s3SecretKey"`
	S3Region       string        `json:"s3Region"`
	EnableParquet  bool          `json:"enableParquet"` // enable parquet extension
	Extensions     []string      `json:"extensions"`    // additional extensions to load
	MaxConnections int           `json:"maxConnections"`
	QueryTimeout   time.Duration `json:"queryTimeout"`   // per-query timeout for DuckDB access
	MaxParallelism int           `json:"maxParallelism"` // max threads/pragmas for DuckDB
	// Deprecated: ignored failure-rate threshold; use
	// CircuitBreakerFailureThreshold instead.
	CircuitBreakerThreshold float64 `json:"circuitBreakerThreshold"`

	// CircuitBreakerFailureThreshold is the number of consecutive failures that
	// opens the DuckDB circuit breaker. Zero means use the built-in default.
	CircuitBreakerFailureThreshold int `json:"circuitBreakerFailureThreshold"`
	// CircuitBreakerWindow is the sliding window for counting DuckDB failures.
	// Zero means use the built-in default.
	CircuitBreakerWindow time.Duration `json:"circuitBreakerWindow"`
	// CircuitBreakerOpenDuration is how long the DuckDB breaker stays open after
	// tripping. Zero means use the built-in default.
	CircuitBreakerOpenDuration time.Duration `json:"circuitBreakerOpenDuration"`

	// FlushVisibilityGraceMs is the #252 clock-skew margin for the federated
	// dirty barrier. Each query anchors its cutoff at the instant it resolved
	// its parquet path set: rows marked flushed after that instant (their
	// delta may be missing from the resolved set) stay hot-readable, minus
	// this margin to absorb CDC-host vs query-host clock skew. Zero (the
	// default) is the exact anchor — the steady state is never widened; a
	// positive value hot-serves rows flushed up to that long before the
	// query; a negative value disables the widening (the pre-#252 barrier).
	FlushVisibilityGraceMs int64 `json:"flushVisibilityGraceMs"`

	// S3Bucket is the bucket holding the lakehouse parquet files and the
	// manifests that index them. Required whenever ManifestTemplate is set.
	S3Bucket string `json:"s3Bucket"`
	// S3DataPrefix mirrors the CDC write side's S3Prefix (the prefix under
	// which delta/base parquet files are written). It is used *only* for the
	// legacy glob fallback covering schemas that have never been flushed and
	// therefore have no manifest object yet. Empty disables that fallback: a
	// schema without a manifest then resolves to zero parquet paths, and a
	// DuckDB-routed read of it fails fast with ErrNoParquetPaths — a
	// non-degradable read-path error naming the schema, distinct from the
	// transient failures AllowPartialDegradedMode absorbs (#299). Leave this
	// set unless every schema is known to be manifested.
	S3DataPrefix string `json:"s3DataPrefix"`
	// ManifestPrefix is the root prefix for manifest objects in S3. It must
	// match the CDC/compaction write side's ManifestPrefix.
	ManifestPrefix string `json:"manifestPrefix"`
	// ManifestTemplate is the manifest path template (e.g.
	// "manifest/{{.SchemaID}}.json") and doubles as the enable gate for
	// manifest-driven parquet resolution. It must be identical to the write
	// side's template: a writer-on/reader-off mismatch makes the reader miss
	// the cold tier entirely and lose those rows silently — no error is
	// raised, the result set is merely short. Empty (the default) keeps the
	// pre-existing glob-based read path.
	ManifestTemplate string `json:"manifestTemplate"`

	// AllowCallerParquetPaths opts the deployment into honoring the
	// per-request federated.s3_parquet_path_template field (#456). It defaults
	// to false: the field is a caller-controlled scan target, so on every
	// existing deployment a request carrying it is rejected. When true, a
	// caller template is still honored only for paths inside the configured
	// S3Bucket (see the engine's path resolver) — the flag is necessary, not
	// sufficient.
	AllowCallerParquetPaths bool `json:"allowCallerParquetPaths"`

	Routing RoutingPolicy `json:"routing"` // routing policy for federated queries
}

type EntityBatchCreator interface {
	BatchCreate(ctx context.Context, req *BatchOperation) (*BatchResult, error)
}

type EntityBatchOperator interface {
	BatchCreate(ctx context.Context, req *BatchOperation) (*BatchResult, error)
	BatchUpdate(ctx context.Context, req *BatchOperation) (*BatchResult, error)
	BatchDelete(ctx context.Context, req *BatchOperation) (*BatchResult, error)
}

type EntityConfig struct {
	EnableReferenceValidation bool          `json:"enableReferenceValidation"`
	EnableCascadeDelete       bool          `json:"enableCascadeDelete"`
	BatchSize                 int           `json:"batchSize"`
	CacheEnabled              bool          `json:"cacheEnabled"`
	CacheTTL                  time.Duration `json:"cacheTTL"`
	MaxEntitySize             int           `json:"maxEntitySize"`
	EnableVersioning          bool          `json:"enableVersioning"`
	SchemaDirectory           string        `json:"schemaDirectory"`

	// ValidateUpdatesStrict makes update payloads that violate the entity's
	// JSON Schema fail with 4xx instead of only being logged (#314).
	//
	// Default false: rows written before schema enforcement may already violate
	// their schema, and rejecting on update would make them un-updatable — a
	// caller touching one unrelated field would be refused for a pre-existing
	// violation elsewhere. Creates are always enforced; they have no legacy data.
	//
	// Whether it is safe to flip this yet is answered by the #317 aggregate:
	// the "report-only schema validation violations reached a milestone" Warn
	// line (per schema, at the 1st and every 100th accepted violation) and the
	// entity_report_only_validation_violation_total telemetry counter. While
	// those lines keep appearing for a schema, its rows are not yet repaired.
	// Their absence is not proof of the converse: the signal fires only when a
	// violating row is written, and only every 100th time thereafter within one
	// process (strictly, per EntityManager — the shipped wiring builds exactly
	// one), so a schema whose bad rows are never updated stays silent.
	// Confirm with an e2e pass over real data before flipping
	// (docs/error-handling.md).
	ValidateUpdatesStrict bool `json:"validateUpdatesStrict"`
}

type EntityIdentifier struct {
	SchemaName string    `json:"schemaName"`
	RowID      uuid.UUID `json:"rowId"`
}

type EntityManager interface {
	EntityWriter
	EntityReader
	EntityBatchOperator
	Close() error
}

type EntityOperation struct {
	EntityIdentifier
	Type    OperationType  `json:"type"`
	Data    map[string]any `json:"data,omitempty"`
	Updates map[string]any `json:"updates,omitempty"`
}

type EntityReader interface {
	Get(ctx context.Context, req *QueryRequest) (*DataRecord, error)
	Query(ctx context.Context, req *QueryRequest) (*QueryResult, error)
	CrossSchemaSearch(ctx context.Context, req *CrossSchemaRequest) (*QueryResult, error)
}

type EntityUpdate struct {
	EntityIdentifier
	Updates any `json:"updates"`
}

type EntityWriter interface {
	Create(ctx context.Context, req *EntityOperation) (*DataRecord, error)
	Update(ctx context.Context, req *EntityOperation) (*DataRecord, error)
	Delete(ctx context.Context, req *EntityOperation) error
}

type ExecutionMerge struct {
	Strategy   string   `json:"strategy,omitempty"`
	PreferHot  bool     `json:"prefer_hot,omitempty"`
	DedupKeys  []string `json:"dedup_keys,omitempty"`
	DurationMs int64    `json:"duration_ms,omitempty"`
}

type ExecutionPlan struct {
	Routing ExecutionRouting  `json:"routing"`
	Sources []ExecutionSource `json:"sources,omitempty"`
	Merge   *ExecutionMerge   `json:"merge,omitempty"`
	Timings map[string]int64  `json:"timings,omitempty"`
}

type ExecutionRouting struct {
	UsedDuckDB bool     `json:"used_duckdb"`
	Tiers      []string `json:"tiers,omitempty"`
	Reason     string   `json:"reason,omitempty"`
}

type ExecutionSource struct {
	Tier              string `json:"tier"`
	Engine            string `json:"engine,omitempty"`
	RowEstimate       int64  `json:"row_estimate,omitempty"`
	ActualRows        int64  `json:"actual_rows,omitempty"`
	PredicatePushdown bool   `json:"predicate_pushdown,omitempty"`
	DurationMs        int64  `json:"duration_ms,omitempty"`
	Reason            string `json:"reason,omitempty"`
}

type FederatedQueryRequest struct {
	Enabled                  bool     `json:"enabled,omitempty"`
	PreferredTiers           []string `json:"preferred_tiers,omitempty"`
	PreferHot                bool     `json:"prefer_hot,omitempty"`
	UseMainAsAnchor          bool     `json:"use_main_as_anchor,omitempty"`
	S3ParquetPathTemplate    string   `json:"s3_parquet_path_template,omitempty"`
	AllowPartialDegradedMode bool     `json:"allow_partial_degraded_mode,omitempty"`
	IncludeExecutionPlan     bool     `json:"include_execution_plan,omitempty"`
	ConsistencyMode          string   `json:"consistency_mode,omitempty"`
}

type FilterField string

type FilterType string

type JSONSchema struct {
	ID         int16                      `json:"id"`
	Name       string                     `json:"name"`
	Version    int                        `json:"version"`
	Schema     string                     `json:"schema"`
	Properties map[string]*PropertySchema `json:"properties"`
	Required   []string                   `json:"required"`
	CreatedAt  int64                      `json:"created_at"`
}

type KvCondition struct {
	Attr  string `json:"a"`
	Value string `json:"v"`
}

type LoggingConfig struct {
	Level                  string        `json:"level"`
	Format                 string        `json:"format"`
	EnableStructured       bool          `json:"enableStructured"`
	EnablePerformance      bool          `json:"enablePerformance"`
	EnableQueryLogging     bool          `json:"enableQueryLogging"`
	LogSlowQueries         bool          `json:"logSlowQueries"`
	SlowQueryThreshold     time.Duration `json:"slowQueryThreshold"`
	MaxLogSize             int           `json:"maxLogSize"`
	LogRotation            bool          `json:"logRotation"`
	SanitizeParameters     bool          `json:"sanitizeParameters"`
	LogQueries             bool          `json:"logQueries"`
	LogErrors              bool          `json:"logErrors"`
	LogSecurityEvents      bool          `json:"logSecurityEvents"`
	LogPerformanceWarnings bool          `json:"logPerformanceWarnings"`
	LogAllOperations       bool          `json:"logAllOperations"`
	EnableDetailedLogging  bool          `json:"enableDetailedLogging"`
}

type Logic string

type MainColumn string

type MainColumnBinding struct {
	ColumnName MainColumn         `json:"col_name"`
	Encoding   MainColumnEncoding `json:"encoding,omitempty"`
}

type MainColumnEncoding string

type MainColumnType string

type ManifestSchemaMismatchError struct {
	RequestedSchemaID int16
	ManifestSchemaID  int16
	Path              string
}

type MetricsConfig struct {
	Enabled                  bool              `json:"enabled"`
	Provider                 string            `json:"provider"` // prometheus, statsd, etc.
	Endpoint                 string            `json:"endpoint"`
	CollectionInterval       time.Duration     `json:"collectionInterval"`
	EnableHistograms         bool              `json:"enableHistograms"`
	EnableCounters           bool              `json:"enableCounters"`
	EnableGauges             bool              `json:"enableGauges"`
	Namespace                string            `json:"namespace"`
	Labels                   map[string]string `json:"labels"`
	MaxSamples               int               `json:"maxSamples"`
	EnableOperationMetrics   bool              `json:"enableOperationMetrics"`
	EnableTransactionMetrics bool              `json:"enableTransactionMetrics"`
	EnablePatternMetrics     bool              `json:"enablePatternMetrics"`
}

type NoParquetPathsError struct {
	SchemaID int16
	// SourceConfigured reports whether a parquet source was consulted and
	// returned nothing, as opposed to no source existing to consult.
	SourceConfigured bool
}

type OperationError struct {
	Operation EntityOperation `json:"operation"`
	Error     string          `json:"error"`
	Code      string          `json:"code"`
	Details   map[string]any  `json:"details,omitempty"`
}

type OperationType string

type Option func(*Config)

type OrderBy struct {
	Attribute string    `json:"attribute"`
	SortOrder SortOrder `json:"sort_order,omitempty"`
}

type ParquetSetInconsistentError struct {
	SchemaID    int16
	MissingKeys []string
}

type PartialResultInfo struct {
	Reason              string `json:"reason"`
	ExcludedObjectCount int    `json:"excluded_object_count,omitempty"`
}

type PerformanceConfig struct {
	EnableMonitoring          bool          `json:"enableMonitoring"`
	SlowQueryThreshold        time.Duration `json:"slowQueryThreshold"`
	SlowOperationThreshold    time.Duration `json:"slowOperationThreshold"`
	MetricsCollectionInterval time.Duration `json:"metricsCollectionInterval"`
	BatchSize                 int           `json:"batchSize"`
	MaxBatchSize              int           `json:"maxBatchSize"`
	Batch                     BatchConfig   `json:"batch"`

	// Unified monitoring settings
	MaxMetricsHistory      int           `json:"maxMetricsHistory"`
	MaxAlertsHistory       int           `json:"maxAlertsHistory"`
	MaxRecommendations     int           `json:"maxRecommendations"`
	EnableAlerting         bool          `json:"enableAlerting"`
	EnableRecommendations  bool          `json:"enableRecommendations"`
	AlertingInterval       time.Duration `json:"alertingInterval"`
	RecommendationInterval time.Duration `json:"recommendationInterval"`

	// Memory monitoring
	EnableMemoryMonitoring bool  `json:"enableMemoryMonitoring"`
	MemoryThreshold        int64 `json:"memoryThreshold"`

	// Correlation tracking
	EnableCorrelationTracking bool          `json:"enableCorrelationTracking"`
	CorrelationTTL            time.Duration `json:"correlationTTL"`
}

type PropertySchema struct {
	Name       string                     `json:"name"`
	Type       string                     `json:"type"` // "string", "integer", "number", "boolean", "array", "object", "null"
	Format     string                     `json:"format,omitempty"`
	Items      *PropertySchema            `json:"items,omitempty"`
	Properties map[string]*PropertySchema `json:"properties,omitempty"`
	Required   bool                       `json:"required"`
	Default    any                        `json:"default,omitempty"`
	Enum       []any                      `json:"enum,omitempty"`
	Minimum    *float64                   `json:"minimum,omitempty"`
	Maximum    *float64                   `json:"maximum,omitempty"`
	MinLength  *int                       `json:"minLength,omitempty"`
	MaxLength  *int                       `json:"maxLength,omitempty"`
	Pattern    string                     `json:"pattern,omitempty"`
	Relation   *RelationSchema            `json:"x-relation,omitempty"`
	LTBaseType string                     `json:"x-ltbase-type,omitempty"`      // "virtual" for virtual fields that are populated dynamically
	LTBaseNote string                     `json:"x-ltbase-note-prop,omitempty"` // Reference to note field: "${note_id}", "${owner_id}", "${note_data}"
}

type PublicError interface {
	error
	PublicMessage() string
}

type QueryConfig struct {
	DefaultTimeout     time.Duration `json:"defaultTimeout"`
	MaxRows            int           `json:"maxRows"`
	DefaultPageSize    int           `json:"defaultPageSize"`
	MaxPageSize        int           `json:"maxPageSize"`
	EnableQueryPlan    bool          `json:"enableQueryPlan"`
	EnableOptimization bool          `json:"enableOptimization"`
	CacheQueryPlans    bool          `json:"cacheQueryPlans"`
	QueryPlanCacheTTL  time.Duration `json:"queryPlanCacheTTL"`
}

type QueryRequest struct {
	SchemaName   string    `json:"schema_name" validate:"required"`
	Page         int       `json:"page" validate:"min=1"`
	ItemsPerPage int       `json:"items_per_page" validate:"min=1,max=100"`
	Condition    Condition `json:"-"` // Custom unmarshal, can be CompositeCondition or KvCondition
	SortBy       []string  `json:"sort_by,omitempty"`
	SortOrder    SortOrder `json:"sort_order,omitempty"`
	// Sort carries per-key sort directions (#240). Mutually exclusive with
	// SortBy/SortOrder; an entry's empty SortOrder defaults to asc.
	Sort      []OrderBy              `json:"sort,omitempty"`
	RowID     *uuid.UUID             `json:"row_id,omitempty"` // For entity-specific operations
	Attrs     []string               `json:"attrs,omitempty"`  // Attributes to return (field projection)
	Federated *FederatedQueryRequest `json:"federated,omitempty"`
}

type QueryResult struct {
	Data          []*DataRecord `json:"data"`
	TotalRecords  int           `json:"total_records"`
	TotalPages    int           `json:"total_pages"`
	CurrentPage   int           `json:"current_page"`
	ItemsPerPage  int           `json:"items_per_page"`
	HasNext       bool          `json:"has_next"`
	HasPrevious   bool          `json:"has_previous"`
	ExecutionTime time.Duration `json:"execution_time"`
	// ExecutionPlan is populated only for federated requests that set
	// federated.include_execution_plan; it reports the route the engine
	// actually took (DuckDB vs Postgres-only) and per-tier sources so callers
	// can distinguish federated reads from hot-path reads without guessing.
	ExecutionPlan *ExecutionPlan `json:"execution_plan,omitempty"`
	// Partial marks a response answered from an incomplete data surface
	// (#348); currently the only reason is the #251 corrupt-parquet
	// exclusion. Nil/omitted for complete answers. Unlike ExecutionPlan it
	// does not require federated.include_execution_plan.
	Partial *PartialResultInfo `json:"partial,omitempty"`
}

type Reference struct {
	SourceSchemaName string        `json:"sourceSchemaName"`
	SourceRowID      uuid.UUID     `json:"sourceRowId"`
	SourceFieldName  string        `json:"sourceFieldName"`
	TargetSchemaName string        `json:"targetSchemaName"`
	TargetRowID      uuid.UUID     `json:"targetRowId"`
	ReferenceType    ReferenceType `json:"referenceType"`
}

type ReferenceConfig struct {
	ValidateOnCreate bool                   `json:"validateOnCreate"`
	ValidateOnUpdate bool                   `json:"validateOnUpdate"`
	CheckIntegrity   bool                   `json:"checkIntegrity"`
	CascadeDelete    bool                   `json:"cascadeDelete"`
	CascadeUpdate    bool                   `json:"cascadeUpdate"`
	MaxCascadeDepth  int                    `json:"maxCascadeDepth"`
	CascadeRules     map[string]CascadeRule `json:"cascadeRules,omitempty"`
	EnableCaching    bool                   `json:"enableCaching"`
	CacheTTL         time.Duration          `json:"cacheTTL"`
	MaxCacheSize     int                    `json:"maxCacheSize"`
	BatchSize        int                    `json:"batchSize"`
}

type ReferenceType string

type RelationSchema struct {
	Target      string `json:"target"`       // Target schema name
	Type        string `json:"type"`         // "reference" for foreign key relationships
	KeyProperty string `json:"key_property"` // child-side foreign key attribute
}

type RequiredPolicy string

type RoutingPolicy struct {
	Strategy          RoutingStrategy `json:"strategy"`          // "freshness-first", "cost-first", "hybrid"
	HotTTL            time.Duration   `json:"hotTTL"`            // TTL to consider data "hot"
	MaxDuckDBScanRows int             `json:"maxDuckDBScanRows"` // threshold for preferring cold scans
	AllowS3Fallback   bool            `json:"allowS3Fallback"`   // allow falling back to S3/DuckDB when PG not used
}

type RoutingStrategy string

type SchemaAttributeCache map[string]AttributeMetadata

type SchemaRegistry interface {
	// GetSchemaAttributeCacheByName retrieves schema ID and attribute cache by schema name
	GetSchemaAttributeCacheByName(name string) (int16, SchemaAttributeCache, error)
	// GetSchemaAttributeCacheByID retrieves schema name and attribute cache by schema ID
	GetSchemaAttributeCacheByID(id int16) (string, SchemaAttributeCache, error)

	GetSchemaByName(name string) (int16, JSONSchema, error)
	// GetSchemaAttributeCacheByID retrieves schema name and attribute cache by schema ID
	GetSchemaByID(id int16) (string, JSONSchema, error)
	ListSchemas() []string
}

type SortOrder string

type TableNames struct {
	SchemaRegistry string `json:"schemaRegistry"`
	EntityMain     string `json:"entityMain"`
	EAVData        string `json:"eavData"`
	ChangeLog      string `json:"changeLog"`
}

type TransactionConfig struct {
	DefaultTimeout           time.Duration `json:"defaultTimeout"`
	MaxTimeout               time.Duration `json:"maxTimeout"`
	MaxRetryAttempts         int           `json:"maxRetryAttempts"`
	RetryAttempts            int           `json:"retryAttempts"`
	RetryDelay               time.Duration `json:"retryDelay"`
	IsolationLevel           string        `json:"isolationLevel"`
	EnableDeadlockDetection  bool          `json:"enableDeadlockDetection"`
	DeadlockCheckInterval    time.Duration `json:"deadlockCheckInterval"`
	DeadlockMaxWaitTime      time.Duration `json:"deadlockMaxWaitTime"`
	SlowTransactionThreshold time.Duration `json:"slowTransactionThreshold"`
	MinSuccessRate           float64       `json:"minSuccessRate"`
	MaxAverageDuration       time.Duration `json:"maxAverageDuration"`
	MaxConnectionPoolUsage   float64       `json:"maxConnectionPoolUsage"`
}

type ValueType string