fabric

type AuthConfigYAML struct {
	Type       string `yaml:"type"`
	Token      string `yaml:"token"`
	Username   string `yaml:"username"`
	Password   string `yaml:"password"`
	HeaderName string `yaml:"header_name"`
}

type BackendFactory func(config map[string]interface{}) (ExecutionBackend, error)

type BackendYAML struct {
	APIVersion      string                  `yaml:"apiVersion"`
	Kind            string                  `yaml:"kind"`
	Name            string                  `yaml:"name"`
	Description     string                  `yaml:"description"`
	Type            string                  `yaml:"type"`
	Database        *DatabaseConnectionYAML `yaml:"database"`
	Rest            *RestConnectionYAML     `yaml:"rest"`
	GraphQL         *GraphQLConnectionYAML  `yaml:"graphql"`
	GRPC            *GRPCConnectionYAML     `yaml:"grpc"`
	MCP             *MCPConnectionYAML      `yaml:"mcp"`
	SchemaDiscovery *SchemaDiscoveryYAML    `yaml:"schema_discovery"`
	ToolGeneration  *ToolGenerationYAML     `yaml:"tool_generation"`
	HealthCheck     *HealthCheckYAML        `yaml:"health_check"`
}

type Capabilities struct {
	// SupportsTransactions indicates if the backend supports transactions
	SupportsTransactions bool

	// SupportsConcurrency indicates if the backend supports concurrent operations
	SupportsConcurrency bool

	// SupportsStreaming indicates if the backend supports streaming results
	SupportsStreaming bool

	// MaxConcurrentOps is the maximum number of concurrent operations
	MaxConcurrentOps int

	// SupportedOperations lists supported custom operations
	SupportedOperations []string

	// Features lists backend-specific features
	Features map[string]bool

	// Limits contains backend-specific limits
	Limits map[string]int64
}

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

type CircuitBreakerConfig struct {
	FailureThreshold int           // Number of consecutive failures to open circuit (default: 5)
	SuccessThreshold int           // Number of consecutive successes to close from half-open (default: 2)
	Timeout          time.Duration // Time to wait before attempting half-open (default: 30s)
	OnStateChange    func(from, to CircuitState)
}

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

type CircuitBreakerStats struct {
	State            CircuitState
	FailureCount     int
	SuccessCount     int
	LastFailureTime  time.Time
	LastStateChange  time.Time
	FailureThreshold int
	SuccessThreshold int
	ConsecutiveOpens int
}

type CircuitState int

type Column struct {
	Name     string
	Type     string
	Nullable bool
}

type Correction struct {
	OriginalSQL     string
	CorrectedSQL    string
	Explanation     string
	ErrorCode       string
	ConfidenceLevel string // "high", "medium", "low"
}

type DatabaseConnectionYAML struct {
	DSN                      string `yaml:"dsn"`
	MaxConnections           int    `yaml:"max_connections"`
	MaxIdleConnections       int    `yaml:"max_idle_connections"`
	ConnectionTimeoutSeconds int    `yaml:"connection_timeout_seconds"`
	EnableSSL                bool   `yaml:"enable_ssl"`
	SSLCertPath              string `yaml:"ssl_cert_path"`
}

type ErrorAnalysisInfo struct {
	ErrorType   string   // e.g., "syntax_error", "permission_denied", "table_not_found"
	Summary     string   // Human-readable error summary
	Suggestions []string // Actionable suggestions for fixing
}

type ErrorRecord struct {
	SQL              string
	ErrorCode        string
	ErrorMessage     string
	Timestamp        string
	AttemptCount     int                // Tracks retry attempts
	PreviousAttempts []string           // History of failed SQL
	ErrorAnalysis    *ErrorAnalysisInfo // Enhanced error analysis
}

type ExecutionBackend interface {
	// Name returns the backend identifier (e.g., "teradata", "postgres", "rest-api")
	Name() string

	// ExecuteQuery executes a domain-specific query or operation.
	// For SQL backends: query is SQL, result contains rows/columns
	// For API backends: query is HTTP request spec, result contains response
	// For document backends: query is search criteria, result contains documents
	ExecuteQuery(ctx context.Context, query string) (*QueryResult, error)

	// GetSchema retrieves schema information for a resource.
	// For SQL: table/view schema with columns and types
	// For API: endpoint specifications
	// For documents: index schema
	GetSchema(ctx context.Context, resource string) (*Schema, error)

	// ListResources lists available resources with optional filtering.
	// For SQL: tables, views, procedures
	// For API: available endpoints
	// For documents: available indexes/collections
	ListResources(ctx context.Context, filters map[string]string) ([]Resource, error)

	// GetMetadata retrieves backend-specific metadata for a resource.
	// Examples: table statistics, index info, API rate limits, etc.
	GetMetadata(ctx context.Context, resource string) (map[string]interface{}, error)

	// Ping checks backend connectivity and health.
	Ping(ctx context.Context) error

	// Capabilities returns the backend's capabilities for feature discovery.
	Capabilities() *Capabilities

	// ExecuteCustomOperation allows backend-specific operations not covered by
	// the standard interface. This provides an extension point for specialized
	// functionality while maintaining interface compatibility.
	ExecuteCustomOperation(ctx context.Context, op string, params map[string]interface{}) (interface{}, error)

	// Close releases backend resources.
	Close() error
}

type ExecutionStats struct {
	// Duration in milliseconds
	DurationMs int64

	// BytesScanned for data operations
	BytesScanned int64

	// RowsAffected for write operations
	RowsAffected int64

	// Cost estimate (backend-specific units)
	EstimatedCost float64
}

type Field struct {
	Name        string
	Type        string
	Description string
	Nullable    bool
	PrimaryKey  bool
	ForeignKey  *ForeignKey
	Constraints []string
	Default     interface{}
}

type ForeignKey struct {
	ReferencedTable  string
	ReferencedColumn string
}

type GRPCConnectionYAML struct {
	Address        string            `yaml:"address"`
	UseTLS         bool              `yaml:"use_tls"`
	CertPath       string            `yaml:"cert_path"`
	Metadata       map[string]string `yaml:"metadata"`
	TimeoutSeconds int               `yaml:"timeout_seconds"`
}

type GraphQLConnectionYAML struct {
	Endpoint       string            `yaml:"endpoint"`
	Auth           *AuthConfigYAML   `yaml:"auth"`
	Headers        map[string]string `yaml:"headers"`
	TimeoutSeconds int               `yaml:"timeout_seconds"`
}

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

type HealthCheckYAML struct {
	Enabled         bool   `yaml:"enabled"`
	IntervalSeconds int    `yaml:"interval_seconds"`
	TimeoutSeconds  int    `yaml:"timeout_seconds"`
	Query           string `yaml:"query"`
}

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

type Issue struct {
	Severity    string // "error", "warning", "info"
	Message     string
	Suggestion  string
	LineNumber  int
	ColumnRange string
}

type MCPConnectionYAML struct {
	Command    string            `yaml:"command"`
	Args       []string          `yaml:"args"`
	Env        map[string]string `yaml:"env"`
	Transport  string            `yaml:"transport"`
	URL        string            `yaml:"url"`
	WorkingDir string            `yaml:"working_dir"`
}

type QueryResult struct {
	// Type indicates the result type (e.g., "rows", "document", "response")
	Type string

	// Data contains the actual result data (format varies by backend)
	// For small results (<100KB), data is stored here directly
	// For large results, use DataReference instead
	Data interface{}

	// Rows for tabular results (SQL)
	Rows []map[string]interface{}

	// Columns for tabular results (SQL)
	Columns []Column

	// RowCount for tabular results
	RowCount int

	// Metadata contains backend-specific result metadata
	Metadata map[string]interface{}

	// ExecutionStats tracks execution metrics
	ExecutionStats ExecutionStats

	// DataReference points to large result data stored in shared memory
	// If set, Data/Rows fields should be empty and actual data retrieved via reference
	DataReference *loomv1.DataReference
}

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

type Resource struct {
	Name        string
	Type        string
	Description string
	Metadata    map[string]interface{}
}

type RestConnectionYAML struct {
	BaseURL        string            `yaml:"base_url"`
	Auth           *AuthConfigYAML   `yaml:"auth"`
	Headers        map[string]string `yaml:"headers"`
	TimeoutSeconds int               `yaml:"timeout_seconds"`
	MaxRetries     int               `yaml:"max_retries"`
}

type Schema struct {
	// Resource name (table, endpoint, collection, etc.)
	Name string

	// Type of resource (table, view, api_endpoint, etc.)
	Type string

	// Fields/columns/properties
	Fields []Field

	// Metadata contains additional schema information
	Metadata map[string]interface{}
}

type SchemaDiscoveryYAML struct {
	Enabled         bool     `yaml:"enabled"`
	CacheTTLSeconds int      `yaml:"cache_ttl_seconds"`
	IncludeTables   []string `yaml:"include_tables"`
	ExcludeTables   []string `yaml:"exclude_tables"`
}

type SharedBackendConfig struct {
	// Backend is the underlying execution backend to wrap
	Backend ExecutionBackend

	// SharedMemory is the shared memory store
	SharedMemory *storage.SharedMemoryStore

	// Threshold is the size threshold for using shared memory (bytes)
	// Results larger than this will be stored in shared memory
	Threshold int64

	// AutoStore automatically stores large results (default: true)
	AutoStore bool

	// Logger for structured logging (default: NoOp logger)
	Logger *zap.Logger
}

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

type ToolGenerationYAML struct {
	Tools     []string `yaml:"tools"`
	EnableAll bool     `yaml:"enable_all"`
}

type Validator interface {
	Name() string
	Validate(ctx context.Context, sql string) []Issue
}