feature

type Action string

type Actions []Action

type ApplyMiddleware interface {
	Feature
	Apply(s System) (err error)
}

type AuthProvider interface {
	Feature

	AuthenticateRequest(w http.ResponseWriter, r *http.Request) (handled bool, modified *http.Request)
}

type BaseMakePreset[MakeTypedPreset interface{}] interface {
	// Include specifies additional features to be included during the build phase
	Include(features ...Feature) MakeTypedPreset

	// Prepend includes the specified features before all other features within the preset
	Prepend(features ...Feature) MakeTypedPreset

	// OmitTags specifies preset Feature.Tag()s to be omitted during the build phase
	OmitTags(features ...Tag) MakeTypedPreset

	// Overload provides a replacement for an existing feature (by tag)
	// Note: panics if tag specified is not found
	Overload(tag Tag, feature Feature) MakeTypedPreset
}

type Buildable interface {
	Builder
	signaling.SignalSupport

	// MakeEnvKey returns name with EnvPrefix (SCREAMING_SNAKE formatted)
	MakeEnvKey(name string) (key string)

	// MakeEnvKeys returns name with EnvPrefix (SCREAMING_SNAKE formatted)
	MakeEnvKeys(names ...string) (key []string)

	// RegisterPublicFileSystem mounts the given static FileSystems
	RegisterPublicFileSystem(mount string, filesystems ...fs.FileSystem)

	// RegisterTemplatePartial sets the named go-template content for inclusion at the specified block and position
	// Notes:
	//    * "block" must be one of "head" or "body"
	//    * position must be one of "head" or "tail"
	//    * adds the given name tmpl to the first feature.TemplatePartialsProvider
	//    * auto-adds a feature.TemplatePartialsProvider if none are present
	RegisterTemplatePartial(block, position, name, tmpl string) (err error)

	// Features provides access to the cache of enjin features
	Features() (cache *FeaturesCache)
}

type Builder interface {
	// SiteTag is the programmatic tag for identifying this particular enjin
	SiteTag(key string) Builder
	// SiteName is the name of the site, typically used in the branding header and browser tab titles
	SiteName(name string) Builder
	// SiteTagLine is an optional bit of text to display under the site name in the branding header
	SiteTagLine(title string) Builder

	// SiteCopyrightName specifies the first component of a standard copyright declaration for the site
	SiteCopyrightName(name string) Builder
	// SiteCopyrightYear specifies the year component of a standard copyright declaration and if left empty, the current
	// year is used in its place
	SiteCopyrightYear(year string) Builder
	// SiteCopyrightNotice specifies the last component of a standard copyright declaration and if left empty, the
	// phrase "All rights reserved" is used in its place
	SiteCopyrightNotice(notice string) Builder

	// SetEnjinTextFn is the means for translating the site name, tag line and copyright components at runtime using a
	// language printer for every request to the site
	SetEnjinTextFn(fn EnjinTextFn) Builder

	SiteLanguageMode(mode lang.Mode) Builder
	SiteDefaultLanguage(tag language.Tag) Builder
	SiteSupportedLanguages(tags ...language.Tag) Builder
	SiteLanguageDisplayNames(names map[language.Tag]string) Builder

	// Set a custom context key with value
	Set(key string, value interface{}) Builder

	// SetAlwaysHtmlRedirect configures the enjin to always use the HTML meta tag http-equiv=refresh method of
	// redirecting visitors to another page, the default is to use HTTP status 303 (See other) header redirections
	// unless explicitly calling the enjin ServeHtmlRedirect method
	SetAlwaysHtmlRedirect(always bool) Builder

	// SetHtmlRedirectDelay specifies the number of seconds to delay visitors when performing ServeHtmlRedirect calls,
	// the default is 0 seconds (immediately on load)
	SetHtmlRedirectDelay(seconds int) Builder

	// AddPreset includes the given presets just before the normal enjin Build() phase, presets are added in the same
	// order given and any features added will be inserted before all other enjin features present
	AddPreset(presets ...Preset) Builder

	// AddHtmlHeadTag adds a custom (singleton) HTML tag to the <head> section
	// of the page output, example meta tag:
	//   AddHtmlHeadTag("meta",map[string]string{"name":"og:thing","content":"stuff"})
	AddHtmlHeadTag(name string, attr map[string]string) Builder

	// AddDomains restricts inbound requests to only the domain names given
	AddDomains(domains ...string) Builder

	// AddFlags adds custom command line flags
	AddFlags(flags ...cli.Flag) Builder

	// AddCommands adds custom command line commands
	AddCommands(commands ...*cli.Command) Builder

	// AddConsole adds custom command line go-curses consoles (ctk.Window)
	AddConsole(c Console) Builder

	// AddFeature appends the given feature within the built Enjin (appends it to the end of the list of features
	// included)
	AddFeature(f ...Feature) Builder

	// PrependFeature prepends the given feature within the built Enjin (inserts it at the start of the list of
	// features included)
	PrependFeature(f Feature) Builder

	// AddRouteProcessor adds the given route processor to the Enjin route
	// processing middleware
	AddRouteProcessor(route string, processor ReqProcessFn) Builder

	// AddOutputTranslator adds the given output filter (for the given mime type)
	AddOutputTranslator(mime string, filter TranslateOutputFn) Builder

	// AddModifyHeadersFn adds the given headers.ModifyHeadersFn function to the
	// default headers enjin middleware layer
	AddModifyHeadersFn(fn headers.ModifyHeadersFn) Builder

	// AddModifyContentSecurityPolicyFn includes the given CSP modifier function with each request
	AddCspModifierFn(tag string, fn CspModifierFn) Builder

	AddNotifyHook(name string, hook NotifyHook) Builder

	// AddPageFromString is a convenience wrapper around AddPage
	AddPageFromString(path, raw string) Builder

	// SetStatusPage overrides specific HTTP error pages, ie: 404
	SetStatusPage(status int, path string) Builder

	// AddTheme includes the given theme within the built Enjin
	AddTheme(t Theme) Builder

	// SetTheme configures the default theme
	SetTheme(name string) Builder

	// HotReload enables or disables hot-reloading theme templates and content files
	HotReload(enabled bool) Builder

	// SetPublicAccess specifies the list of actions unauthorized visitors have
	//
	// Note: not specifying any public access results in no public access given
	SetPublicAccess(actions ...Action) Builder

	// AddUserAction adds the given actions to the overall known list of
	// registered user actions across all features
	AddUserAction(actions ...Action) Builder

	// Build constructs an Enjin Runner from the Builder configuration
	Build() Runner
}

type CConsole struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

type CEnjinBlock struct {
	CNjnFeature
}

type CEnjinField struct {
	CNjnFeature
}

type CFeature struct {
	KebabTag   string
	PackageTag Tag
	FeatureTag Tag

	Enjin Internals

	sync.RWMutex
	// contains filtered or unexported fields
}

type CMountPoint struct {
	// Path is the actual filesystem path
	Path string
	// Mount is the URL path prefix
	Mount string
	// ROFS is the read-only filesystem, always non-nil
	ROFS fs.FileSystem
	// RWFS is the write-only filesystem, nil when fs is read-only
	RWFS fs.RWFileSystem
}

type CNjnFeature struct {
	CFeature
}

type CPreset[MakeTypedPreset interface{}] struct {
	Name     string
	Features Features
	// contains filtered or unexported fields
}

type CSiteAuthClaims struct {
	// RID is the Real ID of the user
	RID string
	// EID is the Enjin ID of the user
	EID string
	// Email is the email address of the user
	Email string
	// Context is the variable metadata related to the user
	Context beContext.Context

	jwt.RegisteredClaims
}

type CSiteAuthClaimsFactor struct {
	// K is a kebab-cased feature.Tag
	K string `json:"k"`
	// N is a user-provided label for this factor
	N string `json:"n"`
	// E is an expiration unix epoch
	E int64 `json:"e"`
	// T is a timestamp unix epoch
	T int64 `json:"t"`
	// C is the challenge provided by the user
	C string `json:"c"`
}

type CSiteAuthMultiFactorInfo struct {
	CSiteFeatureInfo
	// Ready is true when the current user has at least one provisioned factor of this type
	Ready bool `json:"ready"`
	// Factors is the list of provisioned factors, of this type, ready for challenging the current user
	Factors []string `json:"factors"`
	// Claimed is the list of provisioned factors which are present in the current user's claims
	Claimed []string `json:"claimed"`
	// Submit indicates whether to submit the feature.Tag in order to initiate the challenge process
	Submit bool `json:"submit"`
}

type CSiteFeatureInfo struct {
	// Tag is the kebab-cased feature.Tag
	Tag string `json:"tag"`
	// Key is a different kebab-cased tag than Tag
	Key string `json:"key"`
	// Icon is a font-awesome icon class
	Icon string `json:"icon"`
	// Label is a translated string label
	Label string `json:"label"`
	// Usage is a sentence or two describing how to use this feature
	Usage string `json:"usage"`
	// Hint is used in multiple-step authentications, typically as a button's title attribute
	Hint string `json:"hint"`
	// Placeholder is the string of text displayed in the challenge form input tag
	Placeholder string `json:"placeholder"`
	// Backup indicates whether this feature is a backup feature or not
	Backup bool `json:"backup"`
}

type CanSetupInternals interface {
	Setup(enjin Internals)
}

type CloudTag struct {
	Word   string
	Link   string
	Count  int
	Weight int
}

type CloudTagPage struct {
	Title   string
	Url     string
	Created time.Time
	Updated time.Time
	Tags    TagCloud
}

type Console interface {
	Tag() (tag Tag)
	Init(this interface{})
	This() (this interface{})
	Self() (self Console)
	Build(c Buildable) (err error)
	Depends() (deps Tags)
}

type ContentSecurityPolicyModifier interface {
	Feature
	ModifyContentSecurityPolicy(policy csp.Policy, r *http.Request) (modified csp.Policy)
}

type CspModifierFn func(policy csp.Policy, r *http.Request) (modified csp.Policy)

type DataRestrictionHandler interface {
	Feature
	RestrictServeData(data []byte, mime string, w http.ResponseWriter, r *http.Request) (modReq *http.Request, allow bool)
}

type Database interface {
	Feature

	// ListDB returns a sorted list of connected db tags for use with DB and
	// MustDB
	ListDB() (tags []string)

	// DB returns the database connection or an error
	DB(tag string) (db interface{}, err error)

	// MustDB returns the database connection or panics on error
	MustDB(tag string) (db interface{})
}

type EditorFeature interface {
	SiteFeature
	signaling.Signaling
	UserActionsProvider

	SelfEditor() (self EditorFeature)
	SetupEditor(editor EditorSite)
	SetupEditorRoute(r chi.Router)
	EditorMenu(r *http.Request) (m menu.Menu)

	GetEditorKey() (name string)
	GetEditorPath() (path string)
	GetEditorMenu() (m menu.Menu)

	PrepareEditPage(pageType, editorType string, r *http.Request) (pg Page, ctx beContext.Context, err error)
	ParseEditorUrlParams(r *http.Request) (fsid, code, file string, locale *language.Tag)
	ServePreparedEditPage(pg Page, ctx beContext.Context, w http.ResponseWriter, r *http.Request)

	UpdatePathInfo(info *editor.File, r *http.Request)
	UpdateFileInfo(info *editor.File, r *http.Request)
	UpdateFileInfoForEditing(info *editor.File, r *http.Request)
	PrepareEditableFile(r *http.Request, info *editor.File) (editFile *editor.File)

	ListFileSystems() (list editor.Files)
	ListFileSystemLocales(fsid string) (list editor.Files)
	ListFileSystemDirectories(r *http.Request, fsid, code, dirs string) (list editor.Files)
	ListFileSystemFiles(r *http.Request, fsid, code, dirs string) (list editor.Files)
	ProcessMountPointFile(r *http.Request, printer *message.Printer, eid, mpfBTag, mpfTag, code, dirs, file string, mountPoint *CMountPoint, draftWork bool) (ef *editor.File, ignored bool)

	LockEditorFile(eid, fsid, filePath string) (err error)
	IsEditorFileLocked(fsid, filePath string) (eid string, locked bool)
	UnLockEditorFile(fsid, filePath string) (err error)

	FileExists(info *editor.File) (exists bool)
	ReadFile(info *editor.File) (data []byte, err error)
	WriteFile(info *editor.File, data []byte) (err error)
	RemoveFile(info *editor.File) (err error)
	RemoveDirectory(info *editor.File) (err error)

	DraftExists(info *editor.File) (present bool)
	ReadDraft(info *editor.File) (contents []byte, err error)
	ReadDraftMatter(info *editor.File) (pm *matter.PageMatter, err error)
	WriteDraft(info *editor.File, contents []byte) (err error)
	RemoveDraft(info *editor.File) (err error)
	PublishDraft(info *editor.File) (err error)

	RenderFileBrowser(w http.ResponseWriter, r *http.Request)
	RenderFileEditor(w http.ResponseWriter, r *http.Request)
	ReceiveFileEditorChanges(w http.ResponseWriter, r *http.Request)

	OpFileUnlockHandler(r *http.Request, pg Page, ctx, form beContext.Context, info *editor.File, eid string) (redirect string)
	OpFileRetakeHandler(r *http.Request, pg Page, ctx, form beContext.Context, info *editor.File, eid string) (redirect string)
	OpFileDeleteValidate(r *http.Request, pg Page, ctx, form beContext.Context, info *editor.File, eid string) (err error)
	OpFileDeleteHandler(r *http.Request, pg Page, ctx, form beContext.Context, info *editor.File, eid string) (redirect string)
	OpFileCommitValidate(r *http.Request, pg Page, ctx, form beContext.Context, info *editor.File, eid string) (err error)
	OpFileCommitHandler(r *http.Request, pg Page, ctx, form beContext.Context, info *editor.File, eid string) (redirect string)
	OpFilePublishValidate(r *http.Request, pg Page, ctx, form beContext.Context, info *editor.File, eid string) (err error)
	OpFilePublishHandler(r *http.Request, pg Page, ctx, form beContext.Context, info *editor.File, eid string) (redirect string)
	OpFileCancelValidate(r *http.Request, pg Page, ctx, form beContext.Context, info *editor.File, eid string) (err error)
	OpFileCancelHandler(r *http.Request, pg Page, ctx, form beContext.Context, info *editor.File, eid string) (redirect string)
	OpFileMoveValidate(r *http.Request, pg Page, ctx, form beContext.Context, info *editor.File, eid string) (err error)
	OpFileMoveHandler(r *http.Request, pg Page, ctx, form beContext.Context, info *editor.File, eid string) (redirect string)
	OpFileCopyValidate(r *http.Request, pg Page, ctx, form beContext.Context, info *editor.File, eid string) (err error)
	OpFileCopyHandler(r *http.Request, pg Page, ctx, form beContext.Context, info *editor.File, eid string) (redirect string)
	OpFileTranslateValidate(r *http.Request, pg Page, ctx, form beContext.Context, info *editor.File, eid string) (err error)
	OpFileTranslateHandler(r *http.Request, pg Page, ctx, form beContext.Context, info *editor.File, eid string) (redirect string)

	OpPathDeleteValidate(r *http.Request, pg Page, ctx, form beContext.Context, info *editor.File, eid string) (err error)
	OpPathDeleteHandler(r *http.Request, pg Page, ctx, form beContext.Context, info *editor.File, eid string) (redirect string)
}

type EditorMakeFeature[MakeTypedFeature interface{}] interface {
	SiteMakeFeature[MakeTypedFeature]

	SetEditorName(name string) MakeTypedFeature
	SetEditorType(editorType string) MakeTypedFeature
	SetEditingTags(tags ...Tag) MakeTypedFeature
}

type EditorOperation struct {
	// Key is the submit button kebab-cased value
	Key string `json:"key"`
	// Confirm is the confirmation form parameter, leave empty for no confirmation step
	Confirm string `json:"confirm,omitempty"`
	// Action is the permission users are required to have in order to perform the operation
	Action Action
	// Validate is the handler called to sanitize the form ctx
	Validate EditorValidateFn
	// Operation is the handler called to perform the operation
	Operation EditorOperationFn
}

type EditorOperationFn = func(r *http.Request, pg Page, ctx, form beContext.Context, info *editor.File, eid string) (redirect string)

type EditorSite interface {
	SiteFeature

	ListPageTypes() (values []string)
	ListPageLayouts() (names []string)
}

type EditorValidateFn = func(r *http.Request, pg Page, ctx, form beContext.Context, info *editor.File, eid string) (err error)

type EmailProvider interface {
	Feature

	NewEmail(path string, bodyCtx beContext.Context) (message *gomail.Message, err error)
	MakeEmailBody(path string, ctx beContext.Context) (matter beContext.Context, body string, err error)

	ListTemplates() (names []string)
	HasTemplate(name string) (present bool)
}

type EmailSender interface {
	Feature

	HasEmailAccount(account string) (present bool)
	SendEmail(r *http.Request, account string, message *gomail.Message) (err error)
}

type EnjinBase interface {
	SiteTag() (key string)
	SiteName() (name string)
	SiteTagLine() (tagLine string)

	SiteCopyrightName() (name string)
	SiteCopyrightYear() (year string)
	SiteCopyrightNotice() (notice string)

	SiteLocales() (locales cllang.Tags)
	SiteLanguageMode() (mode lang.Mode)
	SiteLanguageCatalog() (c catalog.Catalog)
	SiteDefaultLanguage() (tag language.Tag)
	SiteSupportsLanguage(tag language.Tag) (supported bool)
	SiteLanguageDisplayName(tag language.Tag) (name string, ok bool)

	FindTranslations(url string) (pages Pages)
	FindTranslationUrls(url string) (pages map[language.Tag]string)
	FindPage(r *http.Request, tag language.Tag, url string) (p Page)
	FindPages(prefix string) (pages []Page)
}

type EnjinBlock interface {
	NjnFeature

	NjnBlockType() (name string)

	ProcessBlock(re EnjinRenderer, blockType string, data map[string]interface{}) (html template.HTML, redirect string, err error)

	PrepareBlock(re EnjinRenderer, blockType string, data map[string]interface{}) (block map[string]interface{}, redirect string, err error)
	RenderPreparedBlock(re EnjinRenderer, block map[string]interface{}) (html template.HTML, err error)
}

type EnjinContextProvider interface {
	Feature
	EnjinContext(r *http.Request) (ctx context.Context)
}

type EnjinField interface {
	NjnFeature

	NjnFieldNames() (tagNames []string)

	PrepareNjnData(re EnjinRenderer, tagName string, field map[string]interface{}) (data map[string]interface{}, err error)
}

type EnjinInfo struct {
	Tag string
	EnjinText
	Locales     []language.Tag
	LangMode    lang.Mode
	DefaultLang language.Tag
}

type EnjinRenderer interface {
	RequestArgv() (reqArgv *argv.Argv)
	RequestContext() (ctx context.Context)

	RenderNjnTemplate(tag string, data map[string]interface{}) (html template.HTML, err error)

	ProcessBlock(data map[string]interface{}) (html template.HTML, redirect string, err error)

	PrepareBlock(data map[string]interface{}) (block map[string]interface{}, redirect string, err error)
	RenderPreparedBlock(block map[string]interface{}) (html template.HTML, err error)

	PrepareGenericBlockData(contentData interface{}) (blockDataContent map[string]interface{}, err error)
	PrepareGenericBlock(typeName string, data map[string]interface{}) (preparedData map[string]interface{})

	GetData() (data interface{})
	GetBlockIndex() (index int)

	GetWithinAside() (within bool)
	SetWithinAside(within bool)

	GetCurrentDepth() (depth int)
	IncCurrentDepth() (depth int)
	DecCurrentDepth() (depth int)

	GetHeadingCount() (count int)
	SetHeadingCount(count int)
	IncHeadingCount()

	GetHeadingLevel() (level int)
	SetHeadingLevel(level int)
	IncHeadingLevel()
	DecHeadingLevel()

	AddFootnote(blockIndex int, field map[string]interface{}) (index int)
	PrepareFootnotes(blockIndex int) (footnotes []map[string]interface{}, err error)

	ParseTypeName(data map[string]interface{}) (name string, ok bool)
	ParseFieldAndTypeName(data interface{}) (field map[string]interface{}, name string, ok bool)

	PrepareStringTags(text string) (data []interface{}, err error)
	WalkStringTags(doc *html.Node) (prepared []interface{})

	PrepareBlockHeader(content map[string]interface{}) (combined []interface{}, ok bool)
	PrepareBlockFooter(content map[string]interface{}) (combined []interface{}, ok bool)

	ParseBlockHeadingLevel(count, current int, blockData map[string]interface{}) (level, headingReset, headingLevel int)
	RenderBlockHeader(content map[string]interface{}) (html template.HTML, ok bool)
	RenderBlockFooter(content map[string]interface{}) (html template.HTML, ok bool)

	PrepareInlineFieldText(field map[string]interface{}) (combined []interface{}, err error)
	PrepareInlineFieldList(list []interface{}) (combined []interface{}, err error)
	PrepareInlineFields(fields []interface{}) (combined []interface{}, err error)
	PrepareInlineField(field map[string]interface{}) (prepared map[string]interface{}, err error)

	PrepareContainerFieldText(field map[string]interface{}) (fields []interface{}, err error)
	PrepareContainerFieldList(list []interface{}) (fields []interface{}, err error)
	PrepareContainerFields(fields []interface{}) (combined []map[string]interface{}, err error)
	PrepareContainerField(field map[string]interface{}) (prepared map[string]interface{}, err error)

	RenderInlineField(field map[string]interface{}) (combined []template.HTML, err error)
	RenderInlineFields(fields []interface{}) (combined []template.HTML, err error)
	RenderInlineFieldList(list []interface{}) (html template.HTML, err error)
	RenderInlineFieldText(field map[string]interface{}) (text template.HTML, err error)

	RenderContainerField(field map[string]interface{}) (combined []template.HTML, err error)
	RenderContainerFields(fields []interface{}) (combined []template.HTML, err error)
	RenderContainerFieldList(list []interface{}) (html template.HTML, err error)
	RenderContainerFieldText(field map[string]interface{}) (text template.HTML, err error)
}

type EnjinRunner interface {
	Runner

	StartupString() (info string)

	Shutdown()

	Notify(tag string)
	NotifyF(tag, format string, argv ...interface{})
}

type EnjinSystem interface {
	InlineFields() (field map[string]EnjinField)
	ContainerFields() (field map[string]EnjinField)
	InlineBlocks() (field map[string]EnjinBlock)
	ContainerBlocks() (field map[string]EnjinBlock)
	StringTags() (names []string)
	FindField(tagClass NjnClass, fieldType string) (field EnjinField, ok bool)
	FindBlock(tagClass NjnClass, blockType string) (block EnjinBlock, ok bool)
}

type EnjinText struct {
	Name            string
	TagLine         string
	CopyrightName   string
	CopyrightYear   string
	CopyrightNotice string
}

type EnjinTextFn func(printer *message.Printer) (text EnjinText)

type ExtendedKeyValueStore interface {
	KeyValueStore

	Size() (count int)
	Keys(prefix string) (keys []string)
	Range(prefix string, fn KeyValueStoreRangeFn)
	StreamKeys(prefix string, ctx context.Context) (keys chan string)
}

type Feature interface {
	// Construct is used as the last call within the standard NewTagged(tag) constructor and is used by extended types
	// to perform initializations which require the .FeatureTag set
	Construct(this interface{})
	// Init is used as the first call within the standard NewTagged(tag) constructor to perform initializations which
	// do not require the .FeatureTag set
	Init(this interface{})
	// Tag is the feature.Tag for this particular feature instance
	Tag() (tag Tag)
	// BaseTag is the stock tag common to all feature instances of this type
	BaseTag() (pkg Tag)
	// This returns an interface{} reference to the underlying structure instance
	This() (this interface{})
	// Self returns f.this, typed as a Feature, in such a way that calling f.Self().Thing() from a base type will invoke
	// the type's overloaded method; for example:
	//  - feature A implements `.Thing()` method and calls `f.Thing()` from some `.OtherThing()` method
	//  - feature B embeds feature A and overloads the `.Thing()` method
	//  - when feature A calls `f.Thing()` within `.OtherThing()`, feature A's method is invoked
	//  - if feature A instead calls `f.Self().Thing()` instead, feature B's method is invoked
	//
	// The example above is of course contrived as this only works with Feature methods, however, the design pattern can
	// be re-used in other systems to achieve the same effect, see EditorFeature.SelfEditor for another example.
	Self() (f Feature)
	State() (state LifeCycleState)
	Depends() (deps Tags)
	UsageNotes() (notes []string)
	Build(c Buildable) (err error)
	Setup(enjin Internals)
	Startup(ctx *cli.Context) (err error)
	Shutdown()
}

type Features []Feature

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

type FileProvider interface {
	Feature
	FindFile(url string) (data []byte, mime string, err error)
}

type FileSystemFeature interface {
	Feature
	IsLocalized() (supported bool)
	MountPathROFS(path string, point string, rofs fs.FileSystem)
	MountPathRWFS(path string, point string, rwfs fs.RWFileSystem)
	FindPathMountPoint(path string) (mps MountPoints)
	Exists(path string) (present bool)
	FindPageMatterPath(prefix string) (path string, err error)
	FindReadPageMatter(path string) (pm *matter.PageMatter, err error)
	ReadPageMatter(path string) (pm *matter.PageMatter, err error)
	WritePageMatter(pm *matter.PageMatter) (err error)
	GetMountedPoints() (mountPoints MountedPoints)
}

type FinalizeServeRequestFeature interface {
	Feature
	FinalizeServeRequest(w http.ResponseWriter, r *http.Request) (modified *http.Request)
}

type FuncMap textTemplate.FuncMap

type FuncMapProvider interface {
	Feature

	MakeFuncMap(ctx context.Context) (fm FuncMap)
}

type Group string

type Groups []Group

type GroupsProvider interface {
	Feature

	// IsUserInGroup returns true if the user is in the given group
	IsUserInGroup(eid string, group Group) (present bool)

	// GetUserGroups returns the user's list of groups
	GetUserGroups(eid string) (groups Groups)
}

type HeadersModifier interface {
	Feature
	ModifyHeaders(w http.ResponseWriter, r *http.Request)
}

type HotReloadableFeature interface {
	Feature
	HotReload() (err error)
}

type Internals interface {
	Service
	signaling.Signaling
	EnjinBase

	Self() (self interface{})

	Features() (cache *FeaturesCache)

	Pages() (pages map[string]Page)
	Theme() (theme string)
	Theming() (theming map[string]Theme)
	Headers() (headers []headers.ModifyHeadersFn)
	Domains() (domains []string)
	Consoles() (consoles map[Tag]Console)
	Processors() (processors map[string]ReqProcessFn)
	Translators() (translators map[string]TranslateOutputFn)
	Transformers() (transformers map[string]TransformOutputFn)
	Slugsums() (enabled bool)

	ReloadLocales()
	HotReloading() (enabled bool)

	DB(tag string) (db interface{}, err error)
	MustDB(tag string) (db interface{})
	SpecificDB(fTag Tag, tag string) (db interface{}, err error)
	MustSpecificDB(fTag Tag, tag string) (db interface{})

	MakeFuncMap(ctx context.Context) (fm FuncMap)

	PublicFileSystems() (registry fs.Registry)

	ListTemplatePartials(block, position string) (names []string)
	GetTemplatePartial(block, position, name string) (tmpl string, ok bool)

	MakeLanguagePrinter(requested string) (tag language.Tag, printer *message.Printer)

	PublicUserActions() (actions Actions)
	ValidateUserRequest(action Action, w http.ResponseWriter, r *http.Request) (valid bool)

	PageContextParsers() (parsers context.Parsers)
	MakePageContextField(key string, r *http.Request) (field *context.Field, ok bool)
	MakePageContextFields(r *http.Request) (fields context.Fields)
	ApplyPageContextUpdaters(r *http.Request, pages ...Page)

	GetFormatProviders() []PageFormatProvider
	GetRequestFilters() []RequestFilter
	GetPageContextModifiers() []PageContextModifier
	GetPageContextUpdaters() []PageContextUpdater
	GetPageRestrictionHandlers() []PageRestrictionHandler
	GetMenuProviders() []MenuProvider
	GetDataRestrictionHandlers() []DataRestrictionHandler
	GetOutputTranslators() []OutputTranslator
	GetOutputTransformers() []OutputTransformer
	GetPageTypeProcessors() []PageTypeProcessor
	GetServePathFeatures() []ServePathFeature
	GetDatabases() []Database
	GetEmailSenders() []EmailSender
	GetRequestModifiers() []RequestModifier
	GetRequestRewriters() []RequestRewriter
	GetPermissionsPolicyModifiers() []PermissionsPolicyModifier
	GetContentSecurityPolicyModifiers() []ContentSecurityPolicyModifier
	GetUseMiddlewares() []UseMiddleware
	GetHeadersModifiers() []HeadersModifier
	GetProcessors() []Processor
	GetApplyMiddlewares() []ApplyMiddleware
	GetPageProviders() []PageProvider
	GetFileProviders() []FileProvider
	GetQueryIndexFeatures() []QueryIndexFeature
	GetPageContextProviders() []PageContextProvider
	GetAuthProviders() []AuthProvider
	GetUserActionsProviders() []UserActionsProvider
	GetEnjinContextProvider() []EnjinContextProvider
	GetPageShortcodeProcessors() []PageShortcodeProcessor
	GetFuncMapProviders() []FuncMapProvider
	GetTemplatePartialsProvider() []TemplatePartialsProvider
	GetThemeRenderers() []ThemeRenderer
	GetServiceLoggers() []ServiceLogger
	GetLocalesProviders() []LocalesProvider
	GetPrepareServePagesFeatures() []PrepareServePagesFeature
	GetFinalizeServePagesFeatures() []FinalizeServeRequestFeature
	GetPageContextFieldsProviders() []PageContextFieldsProvider
	GetPageContextParsersProviders() []PageContextParsersProvider
	GetPanicHandler() PanicHandler
	GetLocaleHandler() LocaleHandler
	GetServiceListener() ServiceListener
	GetRoutePagesHandler() RoutePagesHandler
	GetServePagesHandler() ServePagesHandler
	GetServiceLogHandler() ServiceLogHandler
}

type KeyValueCache interface {
	// ListBuckets returns the names of all buckets
	ListBuckets() (names []string)
	// Bucket returns the named bucket or adds a new bucket and returns that
	Bucket(name string) (kvs KeyValueStore, err error)
	// MustBucket uses Bucket and on error will log.ErrorDF and panic
	MustBucket(name string) (kvs KeyValueStore)
	// AddBucket adds and returns a new bucket, errors if already exists
	AddBucket(name string) (kvs KeyValueStore, err error)
	// GetBucket returns a new bucket, errors if not found
	GetBucket(name string) (kvs KeyValueStore, err error)
	// GetBucketSource returns the underlying cache object, or nil if not found
	GetBucketSource(name string) (src interface{})
}

type KeyValueCacheFeature interface {
	Build(b Buildable) (err error)
	Startup(ctx *cli.Context) (err error)
	Shutdown()
}

type KeyValueCaches interface {
	Feature

	Get(name string) (kvs KeyValueCache, err error)
}

type KeyValueStore interface {
	Get(key string) (value []byte, err error)
	Set(key string, value []byte) (err error)
	Delete(key string) (err error)
}

type KeyValueStoreRangeFn func(key string, value []byte) (stop bool)

type KeywordProvider interface {
	Feature
	Size() (count int)
	KnownKeywords() (keywords []string)
	KeywordStubs(keyword string) (stubs PageStubs)
	Range(prefix string, fn func(key string, value []string) (proceed bool))
}

type LifeCycleState uint8

type LocaleHandler interface {
	Feature
	LocaleHandler(next http.Handler) http.Handler
}

type LocalesProvider interface {
	Feature

	AddLocales(c beCatalog.Catalog)
}

type LoggerContext interface {
	// URL is the parsed request URL
	URL() (parsed *url.URL)
	// Size is the number of response bytes
	Size() (size int)
	// StatusCode is the HTTP status code of the response
	StatusCode() (status int)
	// TimeStamp returns when the request was first received
	TimeStamp() (when time.Time)
	// Duration returns the total time taken to complete the request
	Duration() (duration time.Duration)
	// Request returns the request object
	Request() (r *http.Request)
}

type MakeConsole interface {
	Make() Console
}

type MakeFeature interface {
	Make() Feature
}

type MakePreset interface {
	Make() Preset

	BaseMakePreset[MakePreset]
}

type MatcherFn func(path string, pg Page) (found string, ok bool)

type MenuProvider interface {
	Feature

	GetMenus(tag language.Tag) (found map[string]menu.Menu)
	GetAllMenus() (menus map[language.Tag]map[string]menu.Menu)
}

type MenuSupport struct {
	Key  string `json:"key"`
	Name string `json:"name"`
	Area string `json:"area"`
}

type MenuSupports []MenuSupport

type MessagePrinterFn func(printer *message.Printer) (text string)

type MiddlewareFn = func(next http.Handler) (this http.Handler)

type MountPoints []*CMountPoint

type MountedPoints map[string]MountPoints

type NjnClass uint

type NjnFeature interface {
	Feature

	NjnClass() (tagClass NjnClass)
	NjnCheckTag(tagName string) (allow bool)
	NjnCheckClass(tagClass NjnClass) (allow bool)
	NjnTagsAllowed() (allowed []string, ok bool)
	NjnTagsDenied() (denied []string, ok bool)
	NjnClassAllowed() (allowed NjnClass, ok bool)
}

type Nonce struct {
	// Key is the string to use with nonce factories
	Key string `json:"key"`
	// Name is the form hidden input name
	Name string `json:"name"`
	// Value is the actual nonce to be used with this key/name combination; Value may be omitted in which case the theme
	// must call `Nonce $nonce.Key` to get the correct nonce value to use
	Value string `json:"-"`
}

type NonceFactory interface {
	CreateNonce(key string) (value string)
	VerifyNonce(key, value string) (valid bool)
}

type NonceFactoryFeature interface {
	Feature
	NonceFactory
}

type Nonces []Nonce

type NotifyHook = func(format string, argv ...interface{})

type OutputTransformer interface {
	Feature
	CanTransform(mime string, r *http.Request) (ok bool)
	TransformOutput(mime string, input []byte) (output []byte)
}

type OutputTranslator interface {
	Feature
	CanTranslate(mime string) (ok bool)
	TranslateOutput(s Service, input []byte, inputMime string) (output []byte, mime string, err error)
}

type Page interface {
	Type() (pageType string)
	Format() (pageFormat string)
	Url() (url string)
	Slug() (slug string)
	Path() (path string)

	Title() (title string)
	Description() (description string)

	Layout() (layoutName string)
	Section() (section string)
	Archetype() (archetype string)

	Permalink() (id uuid.UUID)
	PermalinkSha() (shasum string)

	Language() (code string)
	LanguageTag() (tag language.Tag)
	Translates() (url string)

	Shasum() (shasum string)
	Content() (content string)
	FrontMatter() (frontMatter string)
	FrontMatterType() (frontMatterType matter.FrontMatterType)
	PageMatter() (pageMatter *matter.PageMatter)

	CreatedAt() (at time.Time)
	UpdatedAt() (at time.Time)
	DeletedAt() (at sql.NullTime)

	Context() (ctx beContext.Context)

	String() (jsonPage string)

	Match(path string) (found string, ok bool)
	MatchQL(query string) (ok bool, err error)
	MatchPrefix(prefix string) (found string, ok bool)
	Redirections() (redirects []string)
	IsRedirection(path string) (ok bool)
	IsTranslation(path string) (ok bool)
	HasTranslation() (ok bool)

	SetType(pageType string)
	SetFormat(pageFormat string) (path string)
	SetSlugUrl(url string)

	SetTitle(title string)
	SetDescription(description string)

	SetLayout(layoutName string)
	SetArchetype(archetype string)

	SetPermalink(value string) (err error)

	SetLanguage(tag language.Tag)
	SetTranslates(url string)

	SetContent(content string)

	SetFrontMatter(frontMatter string)
	SetFrontMatterType(frontMatterType matter.FrontMatterType)

	SetCreatedAt(at time.Time)
	SetUpdatedAt(at time.Time)
	SetDeletedAt(at sql.NullTime)

	Copy() (copy Page)
}

type PageContextFieldsProvider interface {
	Feature
	MakePageContextFields(r *http.Request) (fields context.Fields)
}

type PageContextFilterFn = func(ctx context.Context, r *http.Request) (modCtx context.Context)

type PageContextModifier interface {
	Feature
	FilterPageContext(themeCtx, pageCtx context.Context, r *http.Request) (themeOut context.Context)
}

type PageContextParsersProvider interface {
	Feature
	PageContextParsers() (fields context.Parsers)
}

type PageContextProvider interface {
	Feature
	FindPageStub(shasum string) (stub *PageStub)
	PageContextValuesCount(key string) (count uint64)
	PageContextValueCounts(key string) (counts map[interface{}]uint64)
	YieldPageContextValueStubs(key string) (pairs chan *ValueStubPair)
	YieldFilterPageContextValueStubs(include bool, key string, value interface{}) (pairs chan *ValueStubPair)
	FilterPageContextValueStubs(include bool, key string, value interface{}) (stubs PageStubs)
}

type PageContextUpdater interface {
	Feature
	UpdatePageContext(pageCtx context.Context, r *http.Request) (additions context.Context)
}

type PageFileSystemFeature interface {
	FileSystemFeature

	AddIndexing(filePath string)
	RemoveIndexing(filePath string)
}

type PageFormat interface {
	Feature
	Name() (name string)
	Label() (label string)
	Extensions() (extensions []string)
	Prepare(ctx context.Context, content string) (out context.Context, err error)
	Process(ctx context.Context, content string) (html template.HTML, redirect string, err error)
	IndexDocument(pg Page) (doc interface{}, err error)
	NewDocumentMapping(tag language.Tag) (doctype, analyzer string, dm *mapping.DocumentMapping)
}

type PageFormatProvider interface {
	ListFormats() (names []string)
	GetFormat(name string) (format PageFormat)
	MatchFormat(filename string) (format PageFormat, match string)
}

type PageIndexFeature interface {
	Feature
	AddToIndex(stub *PageStub, p Page) (err error)
	RemoveFromIndex(stub *PageStub, p Page) (err error)
}

type PageProvider interface {
	Feature
	FindRedirection(url string) (p Page)
	FindTranslations(url string) (pages []Page)
	FindTranslationUrls(url string) (pages map[language.Tag]string)
	FindPage(r *http.Request, tag language.Tag, url string) (p Page)
	LookupPrefixed(prefix string) (pages []Page)
}

type PageRestrictionHandler interface {
	Feature
	RestrictServePage(ctx context.Context, w http.ResponseWriter, r *http.Request) (modCtx context.Context, modReq *http.Request, allow bool)
}

type PageShortcodeProcessor interface {
	Feature
	TranslateShortcodes(content string, ctx context.Context) (modified string)
}

type PageStub struct {
	Origin   string            `json:"origin"`
	FS       fs.FileSystem     `json:"fs"`
	Point    string            `json:"point"`
	Shasum   string            `json:"shasum"`
	Source   string            `json:"source"`
	Language language.Tag      `json:"language"`
	Fallback language.Tag      `json:"fallback"`
	EnjinCtx beContext.Context `json:"enjin-ctx"`
}

type PageStubs []*PageStub

type PageTypeProcessor interface {
	Feature
	PageTypeNames() (names []string)
	ProcessRequestPageType(r *http.Request, p Page) (pg Page, redirect string, processed bool, err error)
}

type Pages []Page

type PanicHandler interface {
	Feature
	PanicHandler(next http.Handler) http.Handler
}

type PermissionsPolicyModifier interface {
	Feature
	ModifyPermissionsPolicy(policy permissions.Policy, r *http.Request) (modified permissions.Policy)
}

type PostStartupFeature interface {
	Feature

	PostStartup(ctx *cli.Context) (err error)
}

type PrepareServePagesFeature interface {
	Feature
	PrepareServePage(ctx context.Context, t Theme, p Page, w http.ResponseWriter, r *http.Request) (out context.Context, modified *http.Request, stop bool)
}

type Preset interface {
	Label() (name string)
	Preset(b Builder) (err error)
}

type Processor interface {
	Feature
	Process(s Service, next http.Handler, w http.ResponseWriter, r *http.Request)
}

type QueryIndexFeature interface {
	Feature
	PerformQuery(input string) (stubs []*PageStub, err error)
	PerformSelect(input string) (selected map[string]interface{}, err error)
}

type ReloadableFeature interface {
	Reload()
}

type ReqProcessFn = func(s Service, w http.ResponseWriter, r *http.Request) (ok bool)

type RequestFilter interface {
	Feature
	FilterRequest(r *http.Request) (err error)
}

type RequestFilterFn = func(r *http.Request) (err error)

type RequestModifier interface {
	Feature
	ModifyRequest(w http.ResponseWriter, r *http.Request)
}

type RequestRewriter interface {
	Feature
	RewriteRequest(w http.ResponseWriter, r *http.Request) (modified *http.Request)
}

type RootInternals interface {
	Internals

	SetupRootEnjin(ctx *cli.Context) (err error)
}

type RoutePagesHandler interface {
	Feature
	RoutePage(w http.ResponseWriter, r *http.Request)
}

type Runner interface {
	String() string
	Run(argv []string) (err error)
}

type SearchDocumentMapperFeature interface {
	Feature
	SearchDocumentMapping(tag language.Tag) (doctype string, dm *mapping.DocumentMapping)
	AddSearchDocumentMapping(tag language.Tag, indexMapping *mapping.IndexMappingImpl)
}

type SearchEnjinFeature interface {
	Feature
	PrepareSearch(tag language.Tag, input string) (query string)
	PerformSearch(tag language.Tag, input string, size, pg int) (results *bleve.SearchResult, err error)
	AddToSearchIndex(stub *PageStub, p Page) (err error)
	RemoveFromSearchIndex(stub *PageStub, p Page)
}

type SecretsProvider interface {
	Feature

	// GetUserSecret returns the user's password hash, returns "" if the user
	// secret is not found
	GetUserSecret(id string) (hash string)
}

type ServePagesHandler interface {
	Feature
	ServePage(p Page, t Theme, ctx context.Context, w http.ResponseWriter, r *http.Request) (err error)
}

type ServePathFeature interface {
	Feature
	ServePath(path string, s System, w http.ResponseWriter, r *http.Request) (err error)
}

type Service interface {
	Prefix() (prefix string)
	Context(r *http.Request) (ctx context.Context)

	GetTheme() (t Theme, err error)
	MustGetTheme() (t Theme)
	ThemeNames() (names []string)
	GetThemeName() (name string)
	GetThemeNamed(name string) (t Theme, err error)
	MustGetThemeNamed(name string) (t Theme)

	ServerName() (name string)
	ServiceInfo() (scheme, listen string, port int)

	PermissionsPolicy() (handler *permissions.PolicyHandler)
	ContentSecurityPolicy() (handler *csp.PolicyHandler)

	FinalizeServeRequest(w http.ResponseWriter, r *http.Request) (modified *http.Request)

	ServeRedirect(destination string, w http.ResponseWriter, r *http.Request)
	ServeRedirectHomePath(w http.ResponseWriter, r *http.Request)

	Serve204(w http.ResponseWriter, r *http.Request)
	Serve400(w http.ResponseWriter, r *http.Request)
	Serve401(w http.ResponseWriter, r *http.Request)
	ServeBasic401(w http.ResponseWriter, r *http.Request)
	Serve403(w http.ResponseWriter, r *http.Request)
	Serve404(w http.ResponseWriter, r *http.Request)
	Serve405(w http.ResponseWriter, r *http.Request)
	Serve500(w http.ResponseWriter, r *http.Request)

	ServeNotFound(w http.ResponseWriter, r *http.Request)
	ServeForbidden(w http.ResponseWriter, r *http.Request)
	ServeInternalServerError(w http.ResponseWriter, r *http.Request)

	ServeStatusPage(status int, w http.ResponseWriter, r *http.Request)
	ServePage(p Page, w http.ResponseWriter, r *http.Request) (err error)
	ServePath(urlPath string, w http.ResponseWriter, r *http.Request) (err error)
	ServeJSON(v interface{}, w http.ResponseWriter, r *http.Request) (err error)
	ServeStatusJSON(status int, v interface{}, w http.ResponseWriter, r *http.Request) (err error)
	ServeData(data []byte, mime string, w http.ResponseWriter, r *http.Request)

	MatchQL(query string) (pages []Page)
	MatchStubsQL(query string) (stubs []*PageStub)
	SelectQL(query string) (selected map[string]interface{})

	CheckMatchQL(query string) (pages []Page, err error)
	CheckMatchStubsQL(query string) (stubs []*PageStub, err error)
	CheckSelectQL(query string) (selected map[string]interface{}, err error)

	FindPageStub(shasum string) (stub *PageStub)
	FindPage(r *http.Request, tag language.Tag, url string) (p Page)
	FindFile(path string) (data []byte, mime string, err error)

	FindEmailAccount(account string) (emailSender EmailSender)
	SendEmail(r *http.Request, account string, message *gomail.Message) (err error)

	GetPublicAccess() (actions Actions)
	FindAllUserActions() (list Actions)

	NonceFactory
	TokenFactory
	SyncLockerFactory

	Notify(tag string)
	NotifyF(tag, format string, argv ...interface{})

	TranslateShortcodes(content string, ctx context.Context) (modified string)

	GetThemeRenderer(ctx context.Context) (renderer ThemeRenderer)

	signaling.EmitterSupport
}

type ServiceListener interface {
	Feature
	ServiceInfo() (scheme, listen string, port int)
	StopListening() (err error)
	StartListening(router *chi.Mux, e EnjinRunner) (err error)
}

type ServiceLogHandler interface {
	Feature

	LogHandler(next http.Handler) (this http.Handler)
}

type ServiceLogger interface {
	Feature

	RequestLogger(ctx LoggerContext) (err error)
}

type ServiceResponseLogger interface {
	Size() int
	Status() int
}

type Site interface {
	Feature
	signaling.Signaling

	SitePath() (path string)
	SiteMenu(r *http.Request) (siteMenu beContext.Context)
	SiteTheme() (t Theme)
	SiteUsers() (sup SiteUsersProvider)
	SiteAuth() (sup SiteAuthFeature)

	SiteFeatures() (list SiteFeatures)

	PushImportantNotice(eid string, dismiss bool, message string, argv ...interface{})
	PushInfoNotice(eid string, dismiss bool, message string, argv ...interface{})
	PushWarnNotice(eid string, dismiss bool, message string, argv ...interface{})
	PushErrorNotice(eid string, dismiss bool, message string, argv ...interface{})
	PushNotices(eid string, notices ...*UserNotice)
	PullNotices(eid string) (notices UserNotices)

	GetContext(eid string) (ctx beContext.Context)
	SetContext(eid string, ctx beContext.Context)
	ApplyContext(eid string, changes beContext.Context)
	DeleteContextKeys(eid string, keys ...string)

	PreparePage(layout, pageType, pagePath string, t Theme, r *http.Request) (pg Page, ctx beContext.Context, err error)
	ServePreparedPage(pg Page, ctx beContext.Context, t Theme, w http.ResponseWriter, r *http.Request)
	PrepareAndServePage(layout, pageType, pagePath string, t Theme, w http.ResponseWriter, r *http.Request, ctx beContext.Context) (err error)

	RequireVerification(path string, w http.ResponseWriter, r *http.Request) (allowed bool)
	MustRequireVerification(path string, w http.ResponseWriter, r *http.Request) (allowed bool)
}

type SiteAuthClaimsFactors []*CSiteAuthClaimsFactor

type SiteAuthFeature interface {
	Feature

	Site() Site
	SiteFeatureKey() (name string)
	SiteFeaturePath() (path string)
	SiteFeatureTheme() (t Theme)

	SiteAuthSignInPath() (url string)
	SiteAuthSignOutPath() (url string)
	SiteAuthChallengePath() (path string)

	NumFactorsPresent() (count int)
	NumFactorsRequired() (count int)

	IsUserAllowed(email string) (allowed bool)
	GetSignUpsAllowed() (allowed bool)
	GetSessionDuration() (duration time.Duration)
	GetVerifiedDuration() (duration time.Duration)

	MakeAuthClaims(aud, email string, ctx context.Context) (claims *CSiteAuthClaims)
	GenerateJWT(claims *CSiteAuthClaims) (token string, err error)
	VerifyJWT(r *http.Request) (claims *CSiteAuthClaims, err error)
	ResetUserFactors(r *http.Request, eid string) (err error)
	SetUserFactor(r *http.Request, claim *CSiteAuthClaimsFactor)

	AuthorizeUserSignIn(w http.ResponseWriter, r *http.Request, claims *CSiteAuthClaims) (handled bool, modified *http.Request)

	SiteAuthRequestHandler

	ServeSignInPage(w http.ResponseWriter, r *http.Request)
	ServeSignOutPage(w http.ResponseWriter, r *http.Request)
	ServeChallengeRequest(w http.ResponseWriter, r *http.Request)

	ServeVerificationRequest(verifyTarget string, w http.ResponseWriter, r *http.Request) (handled bool, redirect string)
	RequireVerification(path string, w http.ResponseWriter, r *http.Request) (handled bool, redirect string)
}

type SiteAuthProvider interface {
	SiteFeature

	IsBackupProvider() (backup bool)

	SiteAuthLoginCallback(w http.ResponseWriter, r *http.Request, saf SiteAuthFeature) (err error)
	SiteAuthSignInHandler(w http.ResponseWriter, r *http.Request, saf SiteAuthFeature) (claims *CSiteAuthClaims, redirect string, err error)
	SiteAuthSignOutHandler(w http.ResponseWriter, r *http.Request, saf SiteAuthFeature) (handled bool, redirect string, err error)
}

type SiteAuthRequestHandler interface {
	SiteFeature

	AuthenticateSiteRequest(w http.ResponseWriter, r *http.Request) (handled bool, modified *http.Request)
	FinalizeSiteRequest(w http.ResponseWriter, r *http.Request) (modified *http.Request)
}

type SiteAuthSettingsPanel interface {
	SiteFeature

	SiteAuthSettingsPanel(settingsPath string, saf SiteAuthFeature) (serve, handle http.HandlerFunc)
}

type SiteFeature interface {
	Feature
	UserActionsProvider
	signaling.Signaling

	Site() (s Site)

	Action(verb string, details ...string) (action Action)

	SiteFeatureInfo(r *http.Request) (info *CSiteFeatureInfo)

	SiteFeatureKey() (name string)
	SiteFeatureIcon() (icon string)
	SiteFeaturePath() (path string)
	SiteFeatureMenu(r *http.Request) (m menu.Menu)
	SiteFeatureTheme() (t Theme)
	SiteFeatureLabel(printer *message.Printer) (label string)

	SetupSiteFeature(s Site) (err error)
	RouteSiteFeature(r chi.Router)

	SiteSettingsFields(r *http.Request) (fields beContext.Fields)
	SiteSettingsPanel(settingsPath string) (serve, handle http.HandlerFunc)
}

type SiteFeatureLabelFn func(printer *message.Printer) (label string)

type SiteFeatures TypedFeatures[SiteFeature]

type SiteInfosLookup[T interface{}] struct {
	// contains filtered or unexported fields
}

type SiteMakeFeature[MakeTypedFeature interface{}] interface {
	SetSiteFeatureKey(key string) MakeTypedFeature
	SetSiteFeatureIcon(icon string) MakeTypedFeature
	SetSiteFeatureTheme(name string) MakeTypedFeature
	SetSiteFeatureLabel(fn SiteFeatureLabelFn) MakeTypedFeature
}

type SiteMultiFactorProvider interface {
	SiteFeature
	SiteUserSetupStage

	SetupSiteAuthProvider(saf SiteAuthFeature)
	IsMultiFactorBackup() (backup bool)

	SiteMultiFactorKey() (key string)
	SiteMultiFactorInfo(r *http.Request) (info *CSiteAuthMultiFactorInfo)
	SiteMultiFactorLabel(printer *message.Printer) (label string)
	CurrentUserFactorsReady(r *http.Request) (names []string)
	CurrentUserFactorsReadyCount(r *http.Request) (count int)

	ResetUserFactors(r *http.Request, eid string) (err error)

	ProcessSetupPage(saf SiteAuthFeature, w http.ResponseWriter, r *http.Request) (handled bool)

	ProcessChallenge(factor, challenge string, saf SiteAuthFeature, claims *CSiteAuthClaims, w http.ResponseWriter, r *http.Request) (handled bool, redirect string)

	VerifyClaimFactor(claim *CSiteAuthClaimsFactor, saf SiteAuthFeature, r *http.Request) (verified bool)
	ProcessVerification(verifyTarget, factor, challenge string, saf SiteAuthFeature, claims *CSiteAuthClaims, w http.ResponseWriter, r *http.Request) (handled bool, redirect string)
}

type SiteRootFeature interface {
	SiteFeature

	SiteRootHandler() (this http.Handler)
}

type SiteUserRequestModifier interface {
	SiteFeature

	ModifyUserRequest(au User, r *http.Request) (modified *http.Request)
}

type SiteUserSetupStage interface {
	SiteFeature

	SiteUserSetupStageReady(eid string, r *http.Request) (ready bool)
	SiteUserSetupStageHandler(saf SiteAuthFeature, w http.ResponseWriter, r *http.Request)
}

type SiteUsersProvider interface {
	Feature

	MakeRealID(email string) (rid string)
	MakeEnjinID(rid string) (eid string)

	GroupPresent(group Group) (present bool)
	CreateGroup(r *http.Request, group Group, permissions ...Action) (err error)
	RetrieveGroup(r *http.Request, group Group) (permissions Actions, err error)
	UpdateGroup(r *http.Request, group Group, permissions ...Action) (err error)
	DeleteGroup(r *http.Request, group Group) (err error)

	UserPresent(eid string) (present bool)

	IsUserLocked(r *http.Request, eid string) (locked bool)
	LockUser(r *http.Request, eid string)
	UnlockUser(r *http.Request, eid string)
	RLockUser(r *http.Request, eid string)
	RUnlockUser(r *http.Request, eid string)

	ListUsers(r *http.Request, pg, numPerPage int, sortDesc bool) (list []User, total int)
	SignUpUser(r *http.Request, claims *CSiteAuthClaims) (err error)
	CreateUser(r *http.Request, origin, rid, eid, email string) (err error)
	RetrieveUser(r *http.Request, eid string) (user User, err error)
	DeleteUser(r *http.Request, eid string) (err error)

	UpdateUserName(r *http.Request, eid string, name string) (err error)
	UpdateUserImage(r *http.Request, eid string, image string) (err error)
	UpdateUserContext(r *http.Request, eid string, ctx beContext.Context) (err error)
	UpdateUserGroups(r *http.Request, eid string, groups ...Group) (err error)
	UpdateUserPermissions(r *http.Request, eid string, permissions ...Action) (err error)

	SetUserName(r *http.Request, eid string, name string) (err error)
	SetUserImage(r *http.Request, eid string, image string) (err error)
	SetUserContext(r *http.Request, eid string, ctx beContext.Context) (err error)
	SetUserSetting(r *http.Request, eid string, key string, value interface{}) (err error)
	SetUserSettings(r *http.Request, eid string, ctx beContext.Context) (err error)
	SetUserGroups(r *http.Request, eid string, groups ...Group) (err error)
	SetUserPermissions(r *http.Request, eid string, permissions ...Action) (err error)

	UpdateUserActive(r *http.Request, eid string, active bool) (err error)
	UpdateUserAdminLocked(r *http.Request, eid string, active bool) (err error)
	SetUserActive(r *http.Request, eid string, active bool) (err error)
	SetUserAdminLocked(r *http.Request, eid string, active bool) (err error)

	GetUserStatus(r *http.Request, eid string) (active, locked, visitor bool, err error)
	GetUserActive(r *http.Request, eid string) (active bool, err error)
	GetUserAdminLocked(r *http.Request, eid string) (locked bool, err error)
}

type SyncLocker interface {
	IsLocked() (locked bool)
	Lock(key string)
	Unlock(key string)
}

type SyncLockerFactory interface {
	NewSyncLocker(tag Tag, key string, store KeyValueStore) (l SyncLocker)
	NewSyncLockerWith(tag Tag, key string, store KeyValueStore, timeout, interval time.Duration) (l SyncLocker)
	NewSyncRWLocker(tag Tag, key string, readStore, writeStore KeyValueStore) (l SyncRWLocker)
	NewSyncRWLockerWith(tag Tag, key string, readStore, writeStore KeyValueStore, timeout, interval time.Duration) (l SyncRWLocker)
}

type SyncLockerFactoryFeature interface {
	Feature
	SyncLockerFactory
}

type SyncRWLocker interface {
	SyncLocker
	RLock(key string)
	RUnlock(key string)
}

type System interface {
	Service
	signaling.Signaling

	Router() (router *chi.Mux)
}

type Tag string

type TagCloud []*CloudTag

type TagCloudProvider interface {
	Feature
	GetTagCloud() (tc TagCloud)
	GetPageTagCloud(shasum string) (tags TagCloud)
}

type Tags []Tag

type TemplatePartialsProvider interface {
	Feature
	RegisterTemplatePartial(block, position, name, tmpl string) (err error)
	ListTemplatePartials(block, position string) (names []string)
	GetTemplatePartial(block, position, name string) (tmpl string, ok bool)
}

type Theme interface {
	Name() (name string)

	GetParent() (parent Theme)
	GetBlockThemeNames() (names []string)

	ThemeFS() fs.FileSystem
	StaticFS() fs.FileSystem
	Locales() (locales fs.FileSystem, ok bool)

	ReadStaticFile(path string) (data []byte, mime string, err error)

	GetConfig() (config *ThemeConfig)

	Layouts() ThemeLayouts
	FindLayout(named string) (layout ThemeLayout, name string, ok bool)

	ListArchetypes() (names []string)
	MakeArchetype(enjin Internals, name string) (format string, data []byte, err error)

	AddFormatProvider(providers ...PageFormatProvider)
	PageFormatProvider

	Middleware(next http.Handler) http.Handler

	NewHtmlTemplate(enjin Internals, name string, ctx context.Context) (tmpl *htmlTemplate.Template, err error)
	NewTextTemplate(enjin Internals, name string, ctx context.Context) (tmpl *textTemplate.Template, err error)
}

type ThemeAuthor struct {
	Name     string
	Homepage string
}

type ThemeConfig struct {
	Name        string
	Parent      string
	License     string
	LicenseLink string
	Description string
	Homepage    string
	Authors     []ThemeAuthor
	Extends     string

	RootStyles  []template.CSS
	BlockStyles map[string][]template.CSS
	BlockThemes map[string]map[string]interface{}

	FontawesomeLinks   map[string]string
	FontawesomeClasses []string

	CacheControl string

	PermissionsPolicy     []permissions.Directive
	ContentSecurityPolicy csp.ContentSecurityPolicyConfig

	Supports ThemeSupports

	Context context.Context

	Err error
}

type ThemeLayout interface {
	Name() (name string)

	Apply(other ThemeLayout)
	CacheKeys() (keys []string)
	CacheValue(key string) (value string)

	NewHtmlTemplate(enjin Internals, ctx context.Context) (tmpl *htmlTemplate.Template, err error)
	NewTextTemplate(enjin Internals, ctx context.Context) (tmpl *textTemplate.Template, err error)

	NewHtmlTemplateFrom(enjin Internals, parent ThemeLayout, ctx context.Context) (tmpl *htmlTemplate.Template, err error)
	NewTextTemplateFrom(enjin Internals, parent ThemeLayout, ctx context.Context) (tmpl *textTemplate.Template, err error)

	ApplyHtmlTemplate(enjin Internals, tt *htmlTemplate.Template, ctx context.Context) (err error)
	ApplyTextTemplate(enjin Internals, tt *textTemplate.Template, ctx context.Context) (err error)
}

type ThemeLayouts interface {
	ListLayouts() (names []string)
	GetLayout(name string) (layout ThemeLayout)
	SetLayout(name string, layout ThemeLayout)

	NewHtmlTemplate(enjin Internals, name string, ctx context.Context) (tmpl *htmlTemplate.Template, err error)
	NewTextTemplate(enjin Internals, name string, ctx context.Context) (tmpl *textTemplate.Template, err error)

	ApplyHtmlTemplates(enjin Internals, tmpl *htmlTemplate.Template, ctx context.Context) (err error)
	ApplyTextTemplates(enjin Internals, tmpl *textTemplate.Template, ctx context.Context) (err error)
}

type ThemeRenderer interface {
	Feature
	Render(t Theme, view string, ctx context.Context) (data []byte, err error)
	RenderPage(t Theme, ctx context.Context, p Page) (data []byte, redirect string, err error)
	PrepareRenderPage(t Theme, ctx context.Context, p Page) (data htmlTemplate.HTML, redirect string, err error)

	NewHtmlTemplateWith(t Theme, name string, ctx context.Context) (tt *htmlTemplate.Template, err error)
	NewTextTemplateWith(t Theme, name string, ctx context.Context) (tt *textTemplate.Template, err error)

	RenderHtmlTemplateContent(t Theme, ctx context.Context, tmplContent string) (rendered string, err error)
	RenderTextTemplateContent(t Theme, ctx context.Context, tmplContent string) (rendered string, err error)

	NewHtmlTemplateFromContext(t Theme, view string, ctx context.Context) (tt *htmlTemplate.Template, err error)
	NewTextTemplateFromContext(t Theme, view string, ctx context.Context) (tt *textTemplate.Template, err error)
}