registry

type Cancelable interface {
	Cancel() error
}

type ContainerAware interface {
	Container() Interface
}

type Definer[Type any] interface {
	Config(d TypeDefinition[Type]) error
}

type Disposer interface {
	Dispose()
}

type Initializer interface {
	Initialize(c Interface, value reflect.Value)
}

type InitializerFunc func(c Interface, value reflect.Value)

type Interface interface {
	// Container returns the underlying Registry
	Container() Interface

	// Load loads a value into the provided destination
	Load(dst interface{})

	// LoadValue loads a value into the provided reflect.Value
	LoadValue(dst reflect.Value)

	// Autowire walks the target looking for exported fields that match injectable types
	Autowire(target interface{})

	// InjectValue walks the struct value looking for injectable fields
	InjectValue(value reflect.Value)

	// MapProvider maps a provider for a type
	MapProvider(typ reflect.Type, provider Provider)

	// WithTypeAndProviderFunc maps a provider function for a type
	WithTypeAndProviderFunc(typ reflect.Type, provider ProviderFunc)

	// MapInitializer maps an initializer for a type
	MapInitializer(typ reflect.Type, initializer Initializer)

	// MapInitializerFunc maps an initializer function for a type
	MapInitializerFunc(typ reflect.Type, initializer InitializerFunc)

	// WithTypeAndValue sets a value for a type
	WithTypeAndValue(typOf reflect.Type, value interface{})

	// WithValues puts a list of values into the current context
	WithValues(values ...interface{})

	// Fork creates a new registry using the current one as parent
	Fork() Interface

	// LoadType returns a value for the specified type
	LoadType(typ reflect.Type) interface{}

	// Dispose releases all resources and returns the reference count
	Dispose() int64

	// MustDispose disposes and requires all references to be cleared
	MustDispose()
}

type LifeCycle string

type Provider interface {
	Provide(c Interface) interface{}
}

type ProviderFunc func(c Interface) interface{}

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

type TypeDefinition[Type any] struct {
	// contains filtered or unexported fields
}