modular

type AppRegistry interface {
	SvcRegistry() ServiceRegistry
}

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

type ComplexFeeder interface {
	Feeder
	FeedKey(string, interface{}) error
}

type Config struct {
	*config.Config
	StructKeys map[string]interface{}
}

type ConfigProvider interface {
	GetConfig() any
}

type Feeder = config.Feeder

type Logger interface {
	Info(msg string, args ...any)
	Error(msg string, args ...any)
	Warn(msg string, args ...any)
	Debug(msg string, args ...any)
}

type Module interface {
	// RegisterConfig registers configuration requirements
	RegisterConfig(app *Application)

	// Init Initialize the module with the application context
	Init(app *Application) error

	// Start starts the module (non-blocking)
	Start(ctx context.Context) error

	// Stop gracefully stops the module
	Stop(ctx context.Context) error

	// Name returns the unique identifier for this module
	Name() string

	// Dependencies returns names of other modules this module depends on
	Dependencies() []string

	// ProvidesServices returns a list of services provided by this module
	ProvidesServices() []Service

	// RequiresServices returns a list of services required by this module
	RequiresServices() []ServiceDependency
}

type ModuleConstructor func(app *Application, services map[string]any) (Module, error)

type ModuleRegistry map[string]Module

type ModuleWithConstructor interface {
	Module
	Constructor() ModuleConstructor
}

type Service struct {
	Name        string
	Description string
	Instance    any
}

type ServiceDependency struct {
	Name               string
	Required           bool
	Type               reflect.Type // Concrete type (if known)
	SatisfiesInterface reflect.Type // Interface type (if known)
}

type ServiceRegistry map[string]any

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