contract

type Container interface {
	Registrar

	Resolver

	OverrideService

	ScopeManager

	Names() []string

	Close() error
}

type OverrideService interface {
	OverrideInstance(serviceName string, value any) error

	MustOverrideInstance(serviceName string, value any)

	OverrideProtectedInstance(serviceName string, value any) error

	MustOverrideProtectedInstance(serviceName string, value any)
}

type Provider[T any] func(resolver Resolver) (T, error)

type RegisterOption func(option *RegisterOptions)

type RegisterOptions struct {
	AlsoRegisterType         bool
	TypeRegistrationIsStrict bool
	/* CollectionPriority orders this registration inside AllImplementing collections: a higher priority is collected earlier. Registrations sharing a priority keep the stable type-and-name order. */
	CollectionPriority int
}

type Registrar interface {
	Register(serviceName string, provider any, options ...RegisterOption) error

	MustRegister(serviceName string, provider any, options ...RegisterOption)
}

type Resolver interface {
	Get(serviceName string) (any, error)

	MustGet(serviceName string) any

	GetByType(targetType reflect.Type) (any, error)

	MustGetByType(targetType reflect.Type) any

	Has(serviceName string) bool

	HasType(targetType reflect.Type) bool
}

type Scope interface {
	Resolver

	OverrideService

	Close() error
}

type ScopeManager interface {
	NewScope() Scope
}

type ServiceReference struct {
	ServiceName string
	ServiceType reflect.Type
}

type TypeLister interface {
	TypesImplementing(interfaceType reflect.Type) []reflect.Type

	/* ReferencesImplementing lists every registration whose type satisfies the interface, one reference per registered name, ordered by descending collection priority and then by type and name so a collection never reorders between runs. */
	ReferencesImplementing(interfaceType reflect.Type) []ServiceReference
}