internal

type AccessMethod interface {
	DataAccess

	GetKind() string
	AccessSpec() AccessSpec
	MimeType
	Close() error
}

type AccessMethodSupport interface {
	GetContext() Context
	LocalSupportForAccessSpec(spec AccessSpec) bool
}

type AccessSpec interface {
	compdesc.AccessSpec
	Describe(Context) string
	IsLocal(Context) bool
	GlobalAccessSpec(Context) AccessSpec
	// AccessMethod provides an access method implementation for
	// an access spec. This might be a repository local implementation
	// or a global one. It might be implemented directly by the AccessSpec
	// for global AccessMethods or forwarded to the ComponentVersion for
	// local access methods. It may only be forwarded for AccessSpecs stating
	// to be local (IsLocal()==true).
	// This forwarding is necessary because the concrete implementation of
	// the currently used OCM Repository is not known to the AccessSpec.
	AccessMethod(access ComponentVersionAccess) (AccessMethod, error)
	// GetInexpensiveContentVersionIdentity implements a method that attempts to provide an inexpensive identity.
	// Therefore, an identity that can be provided without requiring the entire object (e.g. calculating the digest from
	// the bytes), which would defeat the purpose of caching.
	// It follows the same contract as AccessMethod.
	GetInexpensiveContentVersionIdentity(access ComponentVersionAccess) string
}

type AccessSpecDecoder = runtime.TypedObjectDecoder[AccessSpec]

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

type AccessType interface {
	runtime.VersionedTypedObjectType[AccessSpec]

	ConfigOptionTypeSetHandler() flagsets.ConfigOptionTypeSetHandler

	Description() string
	Format() string
}

type AccessTypeProvider = runtime.KnownTypesProvider[AccessSpec, AccessType]

type AccessTypeScheme interface {
	runtime.TypeScheme[AccessSpec, AccessType]

	CreateConfigTypeSetConfigProvider() flagsets.ConfigTypeOptionSetConfigProvider
}

type BaseAccess interface {
	ComponentVersion() ComponentVersionAccess
	Access() (AccessSpec, error)
	AccessMethod() (AccessMethod, error)
}

type BlobAccess = accessio.BlobAccess

type BlobDigester interface {
	GetType() DigesterType
	DetermineDigest(resType string, meth AccessMethod, preferred signing.Hasher) (*DigestDescriptor, error)
}

type BlobDigesterRegistry interface {
	IsInitial() bool
	// MustRegisterDigester registers a blob digester for a dedicated exact mime type
	//
	Register(handler BlobDigester, restypes ...string) error
	// GetDigester returns the digester for a given type
	GetDigester(typ DigesterType) BlobDigester

	GetDigesterForType(t string) []BlobDigester
	DetermineDigests(typ string, preferred signing.Hasher, registry signing.Registry, acc AccessMethod, typs ...DigesterType) ([]DigestDescriptor, error)

	Copy() BlobDigesterRegistry
}

type BlobHandler interface {
	// StoreBlob has the chance to decide to store a local blob
	// in a repository specific fashion providing external access.
	// If this is possible and done an appropriate access spec
	// must be returned, if this is not done, nil has to be returned
	// without error
	StoreBlob(blob BlobAccess, artType, hint string, global AccessSpec, ctx StorageContext) (AccessSpec, error)
}

type BlobHandlerConfig = registrations.HandlerConfig

type BlobHandlerKey struct {
	ImplementationRepositoryType `json:",inline"`
	ArtifactType                 string `json:"artifactType,omitempty"`
	MimeType                     string `json:"mimeType,omitempty"`
}

type BlobHandlerOption interface {
	ApplyBlobHandlerOptionTo(*BlobHandlerOptions)
}

type BlobHandlerOptions struct {
	BlobHandlerKey `json:",inline"`
	Priority       int `json:"priority,omitempty"`
}

type BlobHandlerRegistrationHandler = registrations.HandlerRegistrationHandler[Context, BlobHandlerOption]

type BlobHandlerRegistrationRegistry = registrations.HandlerRegistrationRegistry[Context, BlobHandlerOption]

type BlobHandlerRegistry interface {
	// BlobHandlerRegistrationRegistry
	registrations.HandlerRegistrationRegistry[Context, BlobHandlerOption]

	IsInitial() bool

	// Copy provides a new independend copy of the registry.
	Copy() BlobHandlerRegistry
	// RegisterBlobHandler registers a blob handler. It must specify either a sole mime type,
	// or a context and repository type, or all three keys.
	Register(handler BlobHandler, opts ...BlobHandlerOption) BlobHandlerRegistry

	// GetHandler returns the handler with the given key.
	GetHandler(key BlobHandlerKey) BlobHandler

	// LookupHandler returns handler trying all matches in the following order:
	//
	// - a handler matching all keys
	// - handlers matching the repo and mime type (from specific to more general by discarding + components)
	//   - with artifact type
	//   - without artifact type
	// - handlers matching artifact type
	// - handlers matching a sole mimetype handler (from specific to more general by discarding + components)
	// - a handler matching the repo
	//
	LookupHandler(repotype ImplementationRepositoryType, artifacttype, mimeType string) BlobHandler
}

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

type ComponentAccess interface {
	resource.ResourceView[ComponentAccess]

	ComponentAccessImpl
}

type ComponentAccessImpl interface {
	GetContext() Context
	GetName() string

	ListVersions() ([]string, error)
	LookupVersion(version string) (ComponentVersionAccess, error)
	HasVersion(vers string) (bool, error)
	AddVersion(ComponentVersionAccess) error
	NewVersion(version string, overrides ...bool) (ComponentVersionAccess, error)

	Close() error
}

type ComponentLister interface {
	// NumComponents returns the number of components found for a prefix
	// If the given prefix does not end with a /, a repository with the
	// prefix name is included
	NumComponents(prefix string) (int, error)

	// GetNamespaces returns the name of namespaces found for a prefix
	// If the given prefix does not end with a /, a repository with the
	// prefix name is included
	GetComponents(prefix string, closure bool) ([]string, error)
}

type ComponentReference = compdesc.ComponentReference

type ComponentVersionAccess interface {
	resource.ResourceView[ComponentVersionAccess]

	ComponentVersionAccessImpl

	GetResources() []ResourceAccess
	GetResource(meta metav1.Identity) (ResourceAccess, error)
	GetResourceByIndex(i int) (ResourceAccess, error)
	GetResourcesByName(name string, selectors ...compdesc.IdentitySelector) ([]ResourceAccess, error)
	GetResourcesByIdentitySelectors(selectors ...compdesc.IdentitySelector) ([]ResourceAccess, error)
	GetResourcesByResourceSelectors(selectors ...compdesc.ResourceSelector) ([]ResourceAccess, error)

	GetSources() []SourceAccess
	GetSource(meta metav1.Identity) (SourceAccess, error)
	GetSourceByIndex(i int) (SourceAccess, error)

	GetReference(meta metav1.Identity) (ComponentReference, error)
	GetReferenceByIndex(i int) (ComponentReference, error)
	GetReferencesByName(name string, selectors ...compdesc.IdentitySelector) (compdesc.References, error)
	GetReferencesByIdentitySelectors(selectors ...compdesc.IdentitySelector) (compdesc.References, error)
	GetReferencesByReferenceSelectors(selectors ...compdesc.ReferenceSelector) (compdesc.References, error)

	// AddBlob adds a local blob and returns an appropriate local access spec.
	AddBlob(blob BlobAccess, artType, refName string, global AccessSpec) (AccessSpec, error)

	// AdjustResourceAccess is used to modify the access spec. The old and new one MUST refer to the same content.
	AdjustResourceAccess(meta *ResourceMeta, acc compdesc.AccessSpec) error
	SetResourceBlob(meta *ResourceMeta, blob BlobAccess, refname string, global AccessSpec) error
	AdjustSourceAccess(meta *SourceMeta, acc compdesc.AccessSpec) error
	SetSourceBlob(meta *SourceMeta, blob BlobAccess, refname string, global AccessSpec) error

	// AccessMethod provides an access method implementation for
	// an access spec. This might be a repository local implementation
	// or a global one. It might be called by the AccessSpec method
	// to map itself to a local implementation or called directly.
	// If called it should forward the call to the AccessSpec
	// if and only if this specs NOT states to be local IsLocal()==false
	// If the spec states to be local, the repository is responsible for
	// providing a local implementation or return nil if this is
	// not supported by the actual repository type.
	AccessMethod(AccessSpec) (AccessMethod, error)

	// GetInexpensiveContentVersionIdentity implements a method that attempts to provide an inexpensive identity for
	// the specified artifact. Therefore, an identity that can be provided without requiring the entire object (e.g.
	// calculating the digest from the bytes), which would defeat the purpose of caching.
	// It follows the same contract as AccessMethod.
	GetInexpensiveContentVersionIdentity(spec AccessSpec) string
}

type ComponentVersionAccessImpl interface {
	common.VersionedElement

	Repository() Repository

	GetContext() Context

	GetDescriptor() *compdesc.ComponentDescriptor

	SetResource(*ResourceMeta, compdesc.AccessSpec) error
	SetSource(*SourceMeta, compdesc.AccessSpec) error

	SetReference(ref *ComponentReference) error

	DiscardChanges()

	io.Closer
}

type ComponentVersionResolver interface {
	LookupComponentVersion(name string, version string) (ComponentVersionAccess, error)
}

type ConsumerIdentityProvider = credentials.ConsumerIdentityProvider

type Context interface {
	datacontext.Context
	config.ContextProvider
	credentials.ContextProvider
	oci.ContextProvider
	ContextProvider

	RepositoryTypes() RepositoryTypeScheme
	AccessMethods() AccessTypeScheme

	RepositorySpecHandlers() RepositorySpecHandlers
	MapUniformRepositorySpec(u *UniformRepositorySpec) (RepositorySpec, error)

	BlobHandlers() BlobHandlerRegistry
	BlobDigesters() BlobDigesterRegistry

	RepositoryForSpec(spec RepositorySpec, creds ...credentials.CredentialsSource) (Repository, error)
	RepositoryForConfig(data []byte, unmarshaler runtime.Unmarshaler, creds ...credentials.CredentialsSource) (Repository, error)
	RepositorySpecForConfig(data []byte, unmarshaler runtime.Unmarshaler) (RepositorySpec, error)

	AccessSpecForSpec(spec compdesc.AccessSpec) (AccessSpec, error)
	AccessSpecForConfig(data []byte, unmarshaler runtime.Unmarshaler) (AccessSpec, error)

	Encode(AccessSpec, runtime.Marshaler) ([]byte, error)

	GetAlias(name string) RepositorySpec
	SetAlias(name string, spec RepositorySpec)

	GetResolver() ComponentVersionResolver
	AddResolverRule(prefix string, spec RepositorySpec, prio ...int)

	// Finalize finalizes elements implicitly opened during resource operations.
	// For example, registered blob handler may open objects, which are kept open
	// for performance reasons. At the end of a usage finalize should be called
	// to finalize those elements. This method can be called any time by a context
	// user to cleanup temporarily allocated resources. Therefore, only
	// elements should be added to the finalzer, which can be reopened/created
	// on-the fly whenever required.
	Finalize() error
	Finalizer() *Finalizer
}

type ContextProvider interface {
	OCMContext() Context
}

type DataAccess = accessio.DataAccess

type DelegationRegistry[C any, T runtime.TypedObject] interface {
	Register(name string, decoder PriorityDecoder[C, T])
	Get(name string) PriorityDecoder[C, T]
	Delegations() map[string]PriorityDecoder[C, T]
	Decode(ctx C, data []byte, unmarshaller runtime.Unmarshaler) (T, error)

	Copy() DelegationRegistry[C, T]
}

type DigestDescriptor = metav1.DigestSpec

type DigesterType struct {
	HashAlgorithm          string
	NormalizationAlgorithm string
}

type EvaluatableAccessSpec interface {
	AccessSpec
	Evaluate(ctx Context) (AccessSpec, error)
}

type GenericAccessSpec struct {
	runtime.UnstructuredVersionedTypedObject `json:",inline"`
}

type GenericRepositorySpec struct {
	runtime.UnstructuredVersionedTypedObject `json:",inline"`
}

type HintProvider interface {
	GetReferenceHint(cv ComponentVersionAccess) string
}

type ImplementationRepositoryType struct {
	ContextType    string `json:"contextType,omitempty"`
	RepositoryType string `json:"repositoryType,omitempty"`
}

type IntermediateRepositorySpecAspect = oci.IntermediateRepositorySpecAspect

type LocalContextProvider interface {
	GetContext() Context
}

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

type MimeType = accessio.MimeType

type MultiBlobHandler []BlobHandler

type PrioBlobHandler struct {
	BlobHandler
	Prio int
}

type PriorityDecoder[C any, T runtime.TypedObject] interface {
	Decode(ctx C, data []byte, unmarshaler runtime.Unmarshaler) (T, error)
	Priority() int
}

type RegistrationHandlerInfo = registrations.RegistrationHandlerInfo[Context, BlobHandlerOption]

type Repository interface {
	resource.ResourceView[Repository]

	RepositoryImpl
}

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

type RepositoryDelegationRegistry = DelegationRegistry[Context, RepositorySpec]

type RepositoryImpl interface {
	GetContext() Context

	GetSpecification() RepositorySpec
	ComponentLister() ComponentLister

	ExistsComponentVersion(name string, version string) (bool, error)
	LookupComponentVersion(name string, version string) (ComponentVersionAccess, error)
	LookupComponent(name string) (ComponentAccess, error)

	Close() error
}

type RepositorySpec interface {
	runtime.VersionedTypedObject

	AsUniformSpec(Context) *UniformRepositorySpec
	Repository(Context, credentials.Credentials) (Repository, error)
}

type RepositorySpecDecoder = runtime.TypedObjectDecoder[RepositorySpec]

type RepositorySpecHandler interface {
	MapReference(ctx Context, u *UniformRepositorySpec) (RepositorySpec, error)
}

type RepositorySpecHandlers interface {
	Register(hdlr RepositorySpecHandler, types ...string)
	Copy() RepositorySpecHandlers
	KnownTypeNames() []string
	GetHandlers(typ string) []RepositorySpecHandler
	MapUniformRepositorySpec(ctx Context, u *UniformRepositorySpec) (RepositorySpec, error)
}

type RepositoryType interface {
	runtime.VersionedTypedObjectType[RepositorySpec]
}

type RepositoryTypeProvider = runtime.KnownTypesProvider[RepositorySpec, RepositoryType]

type RepositoryTypeScheme interface {
	runtime.TypeScheme[RepositorySpec, RepositoryType]
}

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

type ResourceAccess interface {
	Meta() *ResourceMeta
	BaseAccess
}

type ResourceMeta = compdesc.ResourceMeta

type SourceAccess interface {
	Meta() *SourceMeta
	BaseAccess
}

type SourceMeta = compdesc.SourceMeta

type StorageContext interface {
	GetContext() Context
	TargetComponentVersion() ComponentVersionAccess
	TargetComponentRepository() Repository
	GetImplementationRepositoryType() ImplementationRepositoryType
}

type UniformRepositorySpec struct {
	// Type
	Type string `json:"type,omitempty"`
	// Host is the hostname of an ocm ref.
	Host string `json:"host,omitempty"`
	// SubPath is the sub path spec used to host component versions
	SubPath string `json:"subPath,omitempty"`
	// Info is the file path used to host ctf component versions
	Info string `json:"filePath,omitempty"`

	// CreateIfMissing indicates whether a file based or dynamic repo should be created if it does not exist
	CreateIfMissing bool `json:"createIfMissing,omitempty"`
	// TypeHintshould be set if CreateIfMissing is true to help to decide what kind of repo to create
	TypeHint string `json:"typeHint,omitempty"`
}

type UnknownAccessSpec struct {
	runtime.UnstructuredVersionedTypedObject `json:",inline"`
}

type UnknownRepositorySpec struct {
	runtime.UnstructuredVersionedTypedObject `json:",inline"`
}