adapters

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

type ConfigProperty struct {
	Type        string      `json:"type"` // "string", "int", "bool", "array", "object"
	Description string      `json:"description"`
	Default     interface{} `json:"default,omitempty"`
	Examples    []string    `json:"examples,omitempty"`
}

type ConfigSchema struct {
	Properties map[string]ConfigProperty `json:"properties"`
	Required   []string                  `json:"required"`
}

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

type DefaultSourceMetrics struct{}

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

type FactMapping struct {
	SourceKey     string `json:"source_key" yaml:"source_key"`         // Source-specific key (topic, table, etc.)
	EffectusType  string `json:"effectus_type" yaml:"effectus_type"`   // Target Effectus fact type
	SchemaVersion string `json:"schema_version" yaml:"schema_version"` // Target schema version
}

type FactSource interface {
	// Subscribe to facts with schema validation
	Subscribe(ctx context.Context, factTypes []string) (<-chan *TypedFact, error)

	// Start the source (for sources that need initialization)
	Start(ctx context.Context) error

	// Stop the source gracefully
	Stop(ctx context.Context) error

	// Get schema information for this source
	GetSourceSchema() *Schema

	// Health check
	HealthCheck() error

	// Source metadata
	GetMetadata() SourceMetadata
}

type FormatConverter interface {
	// Convert raw data to proto message using target schema
	Convert(rawData []byte, targetSchema *Schema) (proto.Message, error)

	// Check if converter can handle the source->target conversion
	CanConvert(sourceFormat, targetFormat string) bool

	// Get supported formats
	GetSupportedFormats() []string
}

type Schema struct {
	Name    string
	Version string
	Fields  map[string]interface{}
}

type SchemaDefinition struct {
	Name    string       `json:"name" yaml:"name"`
	Version string       `json:"version" yaml:"version"`
	Format  SchemaFormat `json:"format" yaml:"format"`
	Data    []byte       `json:"-" yaml:"-"`
	Source  string       `json:"source,omitempty" yaml:"source,omitempty"`
}

type SchemaFormat string

type SchemaProvider interface {
	LoadSchemas(ctx context.Context) ([]SchemaDefinition, error)
	Close() error
}

type SchemaProviderFactory interface {
	Create(config SchemaSourceConfig) (SchemaProvider, error)
	ValidateConfig(config SchemaSourceConfig) error
	GetConfigSchema() ConfigSchema
}

type SchemaProviderRegistry interface {
	RegisterSchemaProvider(providerType string, factory SchemaProviderFactory) error
	CreateProvider(config SchemaSourceConfig) (SchemaProvider, error)
	GetAvailableTypes() []string
	GetTypeInfo(providerType string) SchemaProviderTypeInfo
}

type SchemaProviderTypeInfo struct {
	Type         string       `json:"type"`
	Description  string       `json:"description"`
	Capabilities []string     `json:"capabilities"`
	ConfigSchema ConfigSchema `json:"config_schema"`
	Examples     []string     `json:"examples"`
}

type SchemaSourceConfig struct {
	Name      string                 `json:"name" yaml:"name"`
	Type      string                 `json:"type" yaml:"type"`
	Namespace string                 `json:"namespace" yaml:"namespace"`
	Version   string                 `json:"version" yaml:"version"`
	Config    map[string]interface{} `json:"config" yaml:"config"`
	BaseDir   string                 `json:"-" yaml:"-"`
}

type SourceConfig struct {
	SourceID   string                 `json:"source_id" yaml:"source_id"`
	Type       string                 `json:"type" yaml:"type"`
	Config     map[string]interface{} `json:"config" yaml:"config"`
	Mappings   []FactMapping          `json:"mappings" yaml:"mappings"`
	Transforms []Transformation       `json:"transforms" yaml:"transforms"`
	Tags       []string               `json:"tags" yaml:"tags"`
}

type SourceError struct {
	SourceID  string `json:"source_id"`
	Operation string `json:"operation"`
	Message   string `json:"message"`
	Cause     error  `json:"-"`
}

type SourceFactory interface {
	// Create a new source instance
	Create(config SourceConfig) (FactSource, error)

	// Validate configuration before creating
	ValidateConfig(config SourceConfig) error

	// Get configuration schema for this source type
	GetConfigSchema() ConfigSchema
}

type SourceMetadata struct {
	SourceID      string            `json:"source_id"`
	SourceType    string            `json:"source_type"` // "kafka", "http", "database", "file"
	Version       string            `json:"version"`
	Capabilities  []string          `json:"capabilities"`   // ["streaming", "batch", "realtime"]
	SchemaFormats []string          `json:"schema_formats"` // ["protobuf", "json", "avro"]
	Config        map[string]string `json:"config,omitempty"`
	Tags          []string          `json:"tags,omitempty"`
}

type SourceMetrics interface {
	// Record facts processed
	RecordFactProcessed(sourceID, factType string)

	// Record processing errors
	RecordError(sourceID, operation string, err error)

	// Record processing latency
	RecordLatency(sourceID string, duration time.Duration)

	// Record source health
	RecordHealthCheck(sourceID string, healthy bool)
}

type SourceRegistry interface {
	// Register a source type with factory function
	RegisterSourceType(sourceType string, factory SourceFactory) error

	// Create a source instance from configuration
	CreateSource(config SourceConfig) (FactSource, error)

	// List available source types
	GetAvailableTypes() []string

	// Get source type information
	GetTypeInfo(sourceType string) SourceTypeInfo
}

type SourceTypeInfo struct {
	Type         string       `json:"type"`
	Description  string       `json:"description"`
	Capabilities []string     `json:"capabilities"`
	ConfigSchema ConfigSchema `json:"config_schema"`
	Examples     []string     `json:"examples"`
}

type Transformation struct {
	SourcePath string            `json:"source_path" yaml:"source_path"` // JSONPath or similar
	TargetType string            `json:"target_type" yaml:"target_type"` // Target fact type
	Mapping    map[string]string `json:"mapping" yaml:"mapping"`         // Field mappings
}

type TypedFact struct {
	SchemaName    string            `json:"schema_name"`
	SchemaVersion string            `json:"schema_version"`
	Data          proto.Message     `json:"-"`                  // Proto message data
	RawData       []byte            `json:"raw_data,omitempty"` // Original raw data
	Timestamp     time.Time         `json:"timestamp"`
	SourceID      string            `json:"source_id"`
	TraceID       string            `json:"trace_id,omitempty"`
	SpanID        string            `json:"span_id,omitempty"`
	Metadata      map[string]string `json:"metadata,omitempty"`

	// Acknowledge confirms that a source record reached the caller's durable
	// processing boundary. Sources that support acknowledgements leave the
	// record pending until this callback succeeds. The callback is safe to
	// retry; callers that do not invoke it intentionally request redelivery.
	Acknowledge func(context.Context) error `json:"-"`
}