registry

type ActivationController interface {
	ActiveStatusChecker
	ActivationSetter
}

type ActivationSetter interface {
	SetActive(active bool)
}

type ActiveStatusChecker interface {
	Active() bool
}

type BaseEntity struct {

	// Deprecated: Use ID() and SetID() methods instead
	BEId string
	// Deprecated: Use Name() and SetName() methods instead
	BEName string
	// Deprecated: Use Active() and SetActive() methods instead
	BEActive bool
	// Deprecated: Use Metadata() and related methods instead
	BEMetadata map[string]string
	// Deprecated: Use CreatedAt() and UpdatedAt() methods instead
	BECreatedAt time.Time
	// Deprecated: Use CreatedAt() and UpdatedAt() methods instead
	BEUpdatedAt time.Time
	// contains filtered or unexported fields
}

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

type Cache interface {
	Get(ctx context.Context, id string) (Entity, bool)
	Set(ctx context.Context, entity Entity) error
	Delete(ctx context.Context, id string) error
	Clear(ctx context.Context) error
	Size() int
}

type Config struct {
	Name             string        `json:"name"`
	MaxEntities      int           `json:"max_entities"`
	DefaultTTL       time.Duration `json:"default_ttl"`
	EnableEvents     bool          `json:"enable_events"`
	EnableValidation bool          `json:"enable_validation"`

	// Cache settings
	CacheSize int           `json:"cache_size"`
	CacheTTL  time.Duration `json:"cache_ttl"`

	// Redis cache settings
	RedisURL          string        `json:"redis_url"`            // Redis server URL
	RedisKeyPrefix    string        `json:"redis_key_prefix"`     // Prefix for Redis keys
	RedisPoolSize     int           `json:"redis_pool_size"`      // Max connections in pool
	RedisMinIdleConns int           `json:"redis_min_idle_conns"` // Min idle connections
	RedisMaxRetries   int           `json:"redis_max_retries"`    // Max retries for commands
	RedisDialTimeout  time.Duration `json:"redis_dial_timeout"`   // Dial timeout
	RedisReadTimeout  time.Duration `json:"redis_read_timeout"`   // Read timeout
	RedisWriteTimeout time.Duration `json:"redis_write_timeout"`  // Write timeout

	// Advanced features
	EnableCompression bool   `json:"enable_compression"`
	EnablePersistence bool   `json:"enable_persistence"`
	PersistencePath   string `json:"persistence_path"`

	// Auto-save settings
	AutoSaveInterval time.Duration `json:"auto_save_interval"`

	// Metadata validation
	RequiredMetadata   []string                      `json:"required_metadata"`
	ForbiddenMetadata  []string                      `json:"forbidden_metadata"`
	MetadataValidators map[string]func(string) error `json:"-"`
}

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

type Entity = EntityCore

type EntityCore interface {
	Identity
	Nameable
	ActivationController
	MetadataController
	Timestamped
}

type EntityFactory interface {
	NewEntity(id, name string) (EntityCore, error)
}

type EntityFull interface {
	EntityCore
	EntityValidator
	EntityLifecycle
}

type EntityLifecycle interface {
	BeforeCreate() error
	AfterCreate() error
	BeforeUpdate() error
	AfterUpdate() error
	BeforeDelete() error
	AfterDelete() error
}

type EntityValidator interface {
	Validate() error
}

type Event struct {
	Type      string         `json:"type"`
	EntityID  string         `json:"entity_id"`
	Entity    Entity         `json:"entity,omitempty"`
	Timestamp time.Time      `json:"timestamp"`
	Metadata  map[string]any `json:"metadata,omitempty"`
}

type EventBus interface {
	Subscribe(observer Observer) error
	Unsubscribe(observer Observer) error
	Emit(ctx context.Context, event Event) error
}

type Factory interface {
	Create(
		ctx context.Context,
		config Config,
	) (Provider, error)
	CreateWithPersistence(
		ctx context.Context,
		config Config,
		persistence Persistence,
	) (Provider, error)
	CreateWithCache(
		ctx context.Context,
		config Config,
		cache Cache,
	) (Provider, error)
	CreateWithMetrics(
		ctx context.Context,
		config Config,
		metrics Metrics,
	) (Provider, error)
}

type FactoryImpl struct{}

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

type Health interface {
	IsHealthy(ctx context.Context) bool
	GetHealthStatus(ctx context.Context) map[string]interface{}
	GetLastError() error
}

type IDSetter interface {
	SetID(id string) error
}

type Identifier interface {
	ID() string
}

type Identity interface {
	Identifier
	IDSetter
}

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

type MetadataClearer interface {
	ClearMetadata()
}

type MetadataController interface {
	MetadataReader
	MetadataWriter
	MetadataRemover
	MetadataClearer
}

type MetadataReader interface {
	Metadata() map[string]string
}

type MetadataRemover interface {
	RemoveMetadata(key string)
}

type MetadataWriter interface {
	SetMetadata(key, value string)
}

type Metrics interface {
	IncrementRegistration()
	IncrementUnregistration()
	IncrementLookup()
	IncrementError()
	SetEntityCount(count int)
	SetActiveCount(count int)
	RecordLatency(operation string, duration time.Duration)
}

type NameSetter interface {
	SetName(name string) error
}

type Nameable interface {
	Named
	NameSetter
}

type Named interface {
	Name() string
}

type Observer interface {
	OnEntityRegistered(ctx context.Context, entity Entity)
	OnEntityUnregistered(ctx context.Context, id string)
	OnEntityUpdated(ctx context.Context, entity Entity)
	OnEntityActivated(ctx context.Context, id string)
	OnEntityDeactivated(ctx context.Context, id string)
}

type Persistence interface {
	Save(ctx context.Context, entities []Entity) error
	Load(ctx context.Context) ([]Entity, error)
	Delete(ctx context.Context, id string) error
	Clear(ctx context.Context) error
}

type Provider interface {
	// Core operations
	Register(ctx context.Context, entity Entity) error
	Get(ctx context.Context, id string) (Entity, error)
	Unregister(ctx context.Context, id string) error
	IsRegistered(ctx context.Context, id string) bool

	// Listing operations
	List(ctx context.Context) ([]Entity, error)
	ListActive(ctx context.Context) ([]Entity, error)
	ListByMetadata(ctx context.Context, key, value string) ([]Entity, error)

	// Counting operations
	Count(ctx context.Context) (int, error)
	CountActive(ctx context.Context) (int, error)

	// Metadata operations
	GetMetadata(ctx context.Context, id, key string) (string, error)
	SetMetadata(ctx context.Context, id, key, value string) error
	RemoveMetadata(ctx context.Context, id, key string) error

	// Lifecycle operations
	Activate(ctx context.Context, id string) error
	Deactivate(ctx context.Context, id string) error

	// Search operations
	Search(ctx context.Context, query string) ([]Entity, error)
	SearchByMetadata(ctx context.Context, metadata map[string]string) ([]Entity, error)
}

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

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

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

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

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

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

type Timestamped interface {
	CreatedAt() time.Time
	UpdatedAt() time.Time
}

type Validator interface {
	Validate(ctx context.Context, entity Entity) error
	ValidateMetadata(ctx context.Context, metadata map[string]string) error
}