resource

type Cloner interface {
	Clone() Resource
}

type ContentProvider interface {
	// Content returns this resource's content. It will be equivalent to reading the content
	// that RelPermalink points to in the published folder.
	// The return type will be contextual, and should be what you would expect:
	// * Page: template.HTML
	// * JSON: String
	// * Etc.
	Content() (any, error)
}

type ContentResource interface {
	MediaType() media.Type
	ContentProvider
}

type Dated interface {
	// Date returns the date of the resource.
	Date() time.Time

	// Lastmod returns the last modification date of the resource.
	Lastmod() time.Time

	// PublishDate returns the publish date of the resource.
	PublishDate() time.Time

	// ExpiryDate returns the expiration date of the resource.
	ExpiryDate() time.Time
}

type Dates struct {
	FDate        time.Time
	FLastmod     time.Time
	FPublishDate time.Time
	FExpiryDate  time.Time
}

type ErrProvider interface {
	Err() ResourceError
}

type Identifier interface {
	Key() string
}

type LanguageProvider interface {
	Language() *langs.Language
}

type LengthProvider interface {
	Len() int
}

type MediaTypeProvider interface {
	// MediaType is this resource's MIME type.
	MediaType() media.Type
}

type OpenReadSeekCloser func() (hugio.ReadSeekCloser, error)

type OriginProvider interface {
	Origin() Resource
	GetFieldString(pattern string) (string, bool)
}

type ReadSeekCloserResource interface {
	MediaType() media.Type
	hugio.ReadSeekCloserProvider
}

type Resource interface {
	ResourceTypeProvider
	MediaTypeProvider
	ResourceLinksProvider
	ResourceMetaProvider
	ResourceParamsProvider
	ResourceDataProvider
	ErrProvider
}

type ResourceDataProvider interface {
	// Resource specific data set by Hugo.
	// One example would be.Data.Digest for fingerprinted resources.
	Data() any
}

type ResourceError interface {
	error
	ResourceDataProvider
}

type ResourceFinder interface {

	// Get locates the Resource with the given name in the current context (e.g. in .Page.Resources).
	//
	// It returns nil if no Resource could found, panics if name is invalid.
	Get(name any) Resource

	// GetMatch finds the first Resource matching the given pattern, or nil if none found.
	//
	// See Match for a more complete explanation about the rules used.
	//
	// It returns nil if no Resource could found, panics if pattern is invalid.
	GetMatch(pattern any) Resource

	// Match gets all resources matching the given base path prefix, e.g
	// "*.png" will match all png files. The "*" does not match path delimiters (/),
	// so if you organize your resources in sub-folders, you need to be explicit about it, e.g.:
	// "images/*.png". To match any PNG image anywhere in the bundle you can do "**.png", and
	// to match all PNG images below the images folder, use "images/**.jpg".
	//
	// The matching is case insensitive.
	//
	// Match matches by using a relative pathwith Unix style slashes (/) and no
	// leading slash, e.g. "images/logo.png".
	//
	// See https://github.com/gobwas/glob for the full rules set.
	//
	// See Match for a more complete explanation about the rules used.
	//
	// It returns nil if no Resources could found, panics if pattern is invalid.
	Match(pattern any) Resources

	// ByType returns resources of a given resource type (e.g. "image").
	// It returns nil if no Resources could found, panics if typ is invalid.
	ByType(typ any) Resources
}

type ResourceLinksProvider interface {
	// Permalink represents the absolute link to this resource.
	Permalink() string

	// RelPermalink represents the host relative link to this resource.
	RelPermalink() string
}

type ResourceMetaProvider interface {
	// Name is the logical name of this resource. This can be set in the front matter
	// metadata for this resource. If not set, Hugo will assign a value.
	// This will in most cases be the base filename.
	// So, for the image "/some/path/sunset.jpg" this will be "sunset.jpg".
	// The value returned by this method will be used in the GetByPrefix and ByPrefix methods
	// on Resources.
	Name() string

	// Title returns the title if set in front matter. For content pages, this will be the expected value.
	Title() string
}

type ResourceParamsProvider interface {
	// Params set in front matter for this resource.
	Params() maps.Params
}

type ResourceTypeProvider interface {
	// ResourceType is the resource type. For most file types, this is the main
	// part of the MIME type, e.g. "image", "application", "text" etc.
	// For content pages, this value is "page".
	ResourceType() string
}

type ResourceTypesProvider interface {
	ResourceTypeProvider
	MediaTypeProvider
}

type Resources []Resource

type ResourcesConverter interface {
	// For internal use.
	ToResources() Resources
}

type ResourcesLanguageMerger interface {
	MergeByLanguage(other Resources) Resources

	// Needed for integration with the tpl package.
	// For internal use.
	MergeByLanguageInterface(other any) (any, error)
}

type Source interface {
	Publish() error
}

type TranslationKeyProvider interface {
	TranslationKey() string
}

type UnmarshableResource interface {
	ReadSeekCloserResource
	Identifier
}