admin

type AccountRow struct {
	ID, Email, Name, Role, Status, URL string
	Created                            string
	Admin                              bool
	Disabled                           bool
}

type AccountView struct {
	Email    string
	Name     string
	Role     string
	Password form.RenderModel
	Errors   form.FieldErrors
	// TwoStep is the card of two-step sign-in; nil when the accounts
	// service cannot keep its secrets (auth.Service.TwoStepAvailable).
	TwoStep *TwoStepView
}

type AccountsView struct {
	Users []AccountRow
	// Pager pages through many accounts.
	Pager       Pager
	Selected    *AccountRow
	Sessions    []SessionRow
	ProfileForm *form.RenderModel
	StatusForm  *form.RenderModel
	RoleForm    *form.RenderModel
	// DeleteForm is nil for the signed-in user's own account.
	DeleteForm *form.RenderModel
	// TwoStep says whether the selected account has two-step sign-in on,
	// as shown; empty when the accounts service cannot keep its secrets.
	TwoStep string
	// TwoStepForm turns two-step sign-in off for the selected account, for
	// someone who lost their phone; nil while it is off and for the
	// signed-in user's own account.
	TwoStepForm *form.RenderModel
	Membership  *MembershipForm
	Create      form.RenderModel
	Errors      form.FieldErrors
	// ProfileErrors and RoleErrors are the refusals of the selected
	// account's profile and role forms, shown at their fields.
	ProfileErrors form.FieldErrors
	RoleErrors    form.FieldErrors
}

type ActionGroup struct {
	Name    string
	Actions []QuickAction
}

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

type AttentionPanel struct {
	PanelState

	Reviews  []ReviewEntry
	Sections []NavigationLink
}

type CSVRow struct {
	Line   int
	Values []string
}

type Callout struct {
	// Title and Text are shown as written: translate them first (T).
	Title string
	Text  string
	// URL is where the card's button leads; Action is the button's text,
	// a translation key, such as "Continue setup".
	URL    string
	Action string
	// Done of Total show as a progress bar; a zero Total shows none.
	Done  int
	Total int
}

type DashboardView struct {
	// Actions are the quick actions shown as buttons; More holds the rest,
	// by navigation group, when there are many.
	Actions []QuickAction
	More    []ActionGroup
	// WebsiteURL is the root of the website, which leads to the home page in
	// its default language.
	WebsiteURL string
	// Callouts are the sections' cards above the panels (see
	// Section.Callout).
	Callouts []Callout
}

type FormPageView struct {
	Title string
	// Intro explains the form; Message reports the outcome of a post, and
	// Error why the page cannot be used, such as an expired link. Refusals
	// of single fields show at the field (see FieldError).
	Intro   string
	Message string
	Error   string
	// Form is nil when there is nothing to fill in, for example after a
	// reset link was requested.
	Form   *form.RenderModel
	Errors form.FieldErrors
	Links  []PageLink
}

type FormScreen[In any] struct {
	Admin *Admin
	// Title is the page heading: a translation key such as "Settings".
	Title string
	// BackURL links back to where the screen was opened from, such as the
	// module's list, with BackLabel as text (a translation key, or a name
	// chosen by the site owner, which shows as written).
	BackURL   string
	BackLabel string
	// Heading is the title of the form's box and Intro a muted paragraph
	// above the form, both translation keys; either may be empty.
	Heading string
	Intro   string
	// Action is where the form posts to, and where a saved form returns.
	// Empty is the address the screen is shown at, so a screen whose Show
	// and Post share an address, as above, needs none.
	Action string
	// Submit is the label of the button, a translation key; "Save" when
	// empty.
	Submit string
	// Load returns the stored values the form shows.
	Load func(ctx context.Context) (In, error)
	// Save stores a valid post. Refusals of single fields come back as
	// field errors (see FieldError); other errors fail the request.
	Save func(r *http.Request, in In) (form.FieldErrors, error)
}

type FormScreenView struct {
	Title     string
	BackURL   string
	BackLabel string
	Heading   string
	Intro     string
	Form      form.RenderModel
	Errors    form.FieldErrors
}

type GroupRow struct {
	Name    string
	URL     string
	Members int
}

type GroupsView struct {
	Groups []GroupRow
	Create form.RenderModel
	Errors form.FieldErrors
}

type HistoryEntry struct {
	Number int
	// When is the revision's time as shown; Time is the same in RFC 3339,
	// for the datetime attribute.
	When      string
	Time      string
	Author    string
	Note      string
	URL       string
	Published bool
	Selected  bool
	Restore   *form.RenderModel
	// Review names the revision's review state while the workflow is on,
	// such as "Approved"; empty otherwise.
	Review string
	// PreviewURL shows the revision on the website; empty without preview.
	PreviewURL string
}

type List[T any] struct {
	// Rows are the rows of the page.
	Rows []T
	// Pager links to the pages before and after this one.
	Pager Pager
}

type ListPage[T any] struct {
	// Path is the address of the list, such as Routes.URL("index"). The pager's
	// links point there and keep the request's other parameters, such as a
	// filter tab and the search.
	Path string
	// Size is the number of rows per page; DefaultPageSize when zero.
	Size int
	// Load returns at most limit rows starting at offset, and whether more
	// rows follow. The arguments are in the order of TrashRecords.Load and
	// SQL's LIMIT and OFFSET.
	Load func(ctx context.Context, limit, offset int) (rows []T, more bool, err error)
	// All returns every row, for lists that are read whole; it is used when
	// Load is nil.
	All func(ctx context.Context) ([]T, error)
	// Fields returns the texts of a row that a search looks in, such as a
	// name, an e-mail address and a message. Without Fields a search
	// matches nothing.
	Fields func(T) []string
}

type Locale string

type LocaleTab struct {
	Code string
	// Name is the language's own name, such as "Nederlands" (LanguageName),
	// with its code when another tab has the same name, such as
	// "Português (pt-BR)" next to "Português (pt)" (LanguageLabel).
	Name   string
	URL    string
	Active bool
	// Complete means the translation can be published; Started means some
	// text exists but it is not complete yet.
	Complete bool
	Started  bool
	// Overview tabs show only the language, without a translation status,
	// as on a list screen; see LocaleTabs.
	Overview bool
}

type LoginView struct {
	Form   form.RenderModel
	Errors form.FieldErrors
	// Message says why the sign-in was refused.
	Message string
	// Setup links to the first-run setup: no account exists yet.
	Setup bool
	// ForgotPassword links to the password reset: the admin can send mail.
	ForgotPassword bool
}

type MatrixCell struct {
	Value   string
	Allowed bool
	// Unavailable cells have no checkbox: the action does not apply to the
	// section, such as Review in a section without revisions, or Export in
	// a section without an export.
	Unavailable bool
}

type MatrixGroup struct {
	Name string
	Rows []MatrixRow
}

type MatrixRow struct {
	Title   string
	Section string
	Cells   []MatrixCell
	// contains filtered or unexported fields
}

type MatrixView struct {
	Name    string
	Form    form.RenderModel
	Errors  form.FieldErrors
	Actions []string
	// Rows are all sections; Groups are the same rows under the headings of
	// the navigation, in its order.
	Rows   []MatrixRow
	Groups []MatrixGroup
	// Columns is the number of columns: the section and one per action.
	Columns int
	Delete  form.RenderModel
}

type MembershipForm struct {
	// Form ticks the account's groups; nil while no group exists.
	Form *form.RenderModel
}

type Move struct {
	// URL is the form action that moves the item; empty shows the arrow
	// disabled, so the arrows of all rows stay aligned at the ends.
	URL string
	// Arrow is the button's symbol, such as "↑".
	Arrow string
	// Label is the translation key of the button's accessible name and
	// tooltip, such as "Move up".
	Label string
}

type NavigationGroup struct {
	// Name is the translated heading; empty for the links at the top.
	Name string
	// Key is the untranslated name, by which the browser remembers that the
	// editor collapsed the group.
	Key   string
	Links []NavigationLink
	// Active groups hold the current page; they are never collapsed.
	Active bool
	// Badge is the total of the links' badges, shown while collapsed.
	Badge int
}

type NavigationLink struct {
	Title  string
	Path   string
	Icon   string
	Active bool
	// Badge is the section's count, such as new submissions; zero hides it.
	Badge int
	// contains filtered or unexported fields
}

type Options struct {
	// Path is where the admin is served, such as "/admin" (DefaultPath,
	// when empty) or "/toolbox": every address of the admin is below it.
	// Nothing in the admin, its sections or modules assumes it: they link
	// to named routes (see URL and RouteName).
	Path string
	// Title is shown in the header and browser tab.
	Title string
	// Language is the admin UI language, for example "en" or "nl".
	Language string
	// CatalogueDir is an optional folder of catalogues, <locale>.po such as
	// nl_NL.po, whose translations win over the built-in ones of the admin
	// and its sections. Nothing is written to it.
	CatalogueDir string
	// Secure marks cookies HTTPS-only. Disable only for local plain HTTP.
	Secure bool
	// Authorize replaces the built-in rules, by which administrators may do
	// everything and editors what their groups' matrix allows (see
	// auth.Group). It decides every permission check, for administrators
	// too. Sections that are AdminOnly, such as Accounts and Groups, always
	// need the administrator role as well, and Authorize is asked about them
	// too, so it can keep them from administrators but never open them to
	// editors. Nil applies the built-in rules.
	//
	// Authorize must be safe for concurrent use: requests ask it at the same
	// time, and so do background work such as finding the reviewers to
	// notify of a submitted revision.
	Authorize func(ctx context.Context, user auth.User, permission Permission) bool
	// Mail sends password reset links. Nil offers no password reset.
	Mail mail.Sender
	// SetupToken guards the first-run setup ("admin.setup"), which creates
	// the first administrator while no account exists: the screen opens
	// only with ?token=<SetupToken>, and answers 404 otherwise. Empty
	// disables it. webthings.App makes a new one at every start of a site
	// without accounts and logs the link.
	SetupToken string
	// RemindSetup is called when the sign-in page is shown while no
	// account exists, so whoever runs the site can find the setup link
	// again; webthings.App logs it once more, at most once a minute. The
	// link itself is never shown to visitors: the first to open it would
	// get the site. Nil reminds nobody.
	RemindSetup func()
	// AbsoluteURL makes an admin path absolute, for links in e-mail; nil uses
	// the address of the request.
	AbsoluteURL func(r *http.Request, path string) string
	// Timezone is the site's timezone, in which editors enter and read
	// scheduled times; nil uses UTC.
	Timezone func(ctx context.Context) *time.Location
	// Diagnostics is what the admin's renderer reports, such as render
	// metrics, and whether it shows template errors in detail
	// (development); see render.Diagnostics.
	Diagnostics render.Diagnostics
	// Review reports whether a section's review workflow is on, by the
	// section's permission ID; signed-in requests carry it (see
	// content.WithReview). Nil turns review off everywhere.
	Review content.ReviewPolicy
	// TrashDays reports after how many days the site deletes items in the
	// trash for good (see PurgeTrash), which the trash page says; nil, or
	// 0, is never.
	TrashDays func(ctx context.Context) int
	// Permanence keeps the items administrators marked permanent (see
	// Permanence and NewPermanence). Nil offers no permanent mark; items
	// that are permanent by their nature, such as the home page, stay
	// protected.
	Permanence Permanence
	// Router is the go-router the admin registers its routes on, at their
	// full paths below Path, such as one a site mounted at Path with
	// router.AbsolutePaths before it built the admin; nil makes one (see
	// Router).
	Router *router.Router
}

type Page struct {
	// Title is the page title, shown in the header and browser tab: a
	// translation key, such as "Pages", or a name chosen by the site owner,
	// such as a module title, which shows as written without translation.
	Title string
	// Label is a page title that is shown exactly as written and never
	// translated, such as the title of the item being edited, a file name or
	// a group name: what editors type must not be looked up in the
	// catalogue. It replaces Title when set; Title stays the fallback for
	// an empty Label.
	Label string
	// Template is a template path in Files, or in the shared admin templates.
	Template string
	// Files are the section's templates; shared templates are found as well.
	Files fs.FS
	// Includes are extra templates the page calls, as paths or fs.Glob
	// patterns (see render.View.Includes).
	Includes []string
	Data     any
	// Dot, when set, replaces Data, such as a dot computed only when the
	// page's content renders, which a request for a fragment alone leaves
	// out (partial.DotFuncOf; see render.View.Dot).
	Dot    partial.Dot
	Status int
	// Fragments are parts of the page that can be asked for on their own,
	// by the ID of their element (see render.Fragment), such as the panels
	// of the dashboard that load after the page.
	Fragments []render.Fragment
}

type PageLink struct {
	URL   string
	Title string
}

type Pager struct {
	// Page is the current page number, from 1.
	Page        int
	PreviousURL string
	NextURL     string
}

type PanelHeading struct {
	// ID is the panel's element ID; the heading's is ID + "-title".
	ID string
	// Icon names the heading's icon in icons.svg.
	Icon string
	// Title is a translation key.
	Title string
}

type PanelState struct {
	Heading PanelHeading
	// Failed names the sections that failed or did not answer in time.
	Failed []string
}

type Permanence interface {
	// Permanent reports whether the item is marked permanent.
	Permanent(ctx context.Context, section, id string) (bool, error)
	// SetPermanent sets or removes the mark; the acting user is the one in
	// ctx (see db.WithActor).
	SetPermanent(ctx context.Context, section, id string, permanent bool) error
}

type Permission struct {
	Section string
	Action  string
}

type PresenceView struct {
	// Stream is the address of the page's stream, to which the browser adds
	// the tab's id; empty on pages without presence, such as the dashboard.
	Stream  string
	Viewers []PresenceViewer
	// More counts the viewers beyond those shown.
	More int
	// Label says who is on the page, for screen readers; MoreLabel names
	// the viewers counted in More.
	Label     string
	MoreLabel string
}

type PresenceViewer struct {
	Name     string
	Initials string
	// Title is "<name> is also on this page", the chip's tooltip.
	Title string
	// Hue colours the chip, the same for a user everywhere: one of
	// presenceHues, 0 to 11, the class presence-hue-<Hue> of the admin's
	// stylesheet, so the chip needs no style attribute, which a
	// Content-Security-Policy would block.
	Hue int
}

type QuickAction struct {
	Label   string
	Section string
	URL     string
}

type RecentEntry struct {
	Title   string
	URL     string
	Section string
	Icon    string
	Status  string
	// Author is the name of who made the change; empty when unknown.
	Author string
	// When is the time as shown, such as "Today 14:05"; Time is the same as
	// RFC 3339, for the datetime attribute.
	When string
	Time string
	// contains filtered or unexported fields
}

type RecentItem struct {
	Title string
	// URL is the item's editor, built from its route name.
	URL       string
	UpdatedAt time.Time
	// Status is a translation key such as "Draft" or "Published"; empty
	// shows none.
	Status string
	// Author is the ID of the user who made the change; empty when unknown.
	Author string
}

type RecentPanel struct {
	PanelState

	Items []RecentEntry
}

type ReviewEntry struct {
	Title   string
	URL     string
	Section string
	Icon    string
	// Author is the name of who asked for the review; empty when unknown.
	Author string
	// When is since when it waits, as shown; Time is the same as RFC 3339.
	When string
	Time string
	// contains filtered or unexported fields
}

type ReviewInput struct {
	Note    string `form:"textarea" label:"Note"                      maxLength:"500"`
	Publish bool   `form:"checkbox" label:"Publish this revision now"`
}

type ReviewItem struct {
	// Title names the item in the site's default language.
	Title string
	// URL opens the revision in its editor.
	URL string
	// SubmittedBy is the ID of the user who asked for the review, like
	// RecentItem.Author; SubmittedAt is when.
	SubmittedBy string
	SubmittedAt time.Time
}

type ReviewPanel struct {
	// State names the selected revision's state, such as "In review";
	// SubmittedBy/At and ReviewedBy/At say who did what and when, with the
	// reviewer's Note.
	State       string
	SubmittedBy string
	SubmittedAt string
	ReviewedBy  string
	ReviewedAt  string
	Note        string
	// SubmittedTime and ReviewedTime are SubmittedAt and ReviewedAt in RFC
	// 3339, for the datetime attribute.
	SubmittedTime string
	ReviewedTime  string
	// NeedsApproval is set when the selected revision cannot be published
	// or scheduled until a reviewer approves it.
	NeedsApproval bool
	// Submit asks for a review (editors); Approve and Reject decide on it
	// (reviewers). Nil when not possible.
	Submit  *form.RenderModel
	Approve *form.RenderModel
	Reject  *form.RenderModel
}

type ReviewSection struct {
	// ID is the section's permission ID, which the setting stores.
	ID string
	// Title is the section's translated title.
	Title string
}

type RevisionPanel struct {
	Selected     int
	Latest       int
	Published    int
	PreviewURL   string
	CanPublish   bool
	CanUnpublish bool
	Publish      form.RenderModel
	Unpublish    form.RenderModel
	History      []HistoryEntry
	// Schedule plans the publication of the selected revision and/or the
	// unpublication of the item; Unschedule cancels the plan. Both are nil
	// without the right to publish.
	Schedule   *form.RenderModel
	Unschedule *form.RenderModel
	// ScheduledRevision is published at PublishAt; UnpublishAt takes the item
	// offline. They are empty when not planned. All times, also those of
	// the history, are in Timezone, the site's timezone.
	ScheduledRevision int
	PublishAt         string
	UnpublishAt       string
	Timezone          string
	// PublishTime and UnpublishTime are PublishAt and UnpublishAt in RFC
	// 3339, for the datetime attribute.
	PublishTime   string
	UnpublishTime string
	// Permanent items cannot be unpublished; see Revisions.Permanent.
	Permanent bool
	// Review is on while the section's review workflow is (see
	// Revisions.Review); the rest describes the selected revision's review.
	Review bool
	ReviewPanel
}

type Revisions struct {
	// Section is the section ID, for permission checks.
	Section string
	// URL builds the address of one of the item's editor routes by its
	// short name, such as "edit" or "revision-publish" (see admin/editor),
	// with the item's ID filled in; args add the other route parameters and
	// url.Values for the query, as Admin.URL takes them. The panel only asks
	// for the review and schedule routes while Review or Schedule is set.
	URL    func(name string, args ...any) string
	Locale string
	// Selected is the revision in the editor; Latest is the newest number.
	Selected    content.Revision
	Latest      int
	PublishedID string
	History     []content.Revision
	// Names maps author IDs to display names.
	Names map[string]string
	// Preview adds a preview link when the website can render previews.
	Preview bool
	// Schedule is the item's planned publication change; nil when the content
	// cannot be scheduled.
	Schedule *content.Schedule
	// Permanent items must stay on the website, such as the home page: the
	// panel offers no unpublish and plans publications only.
	Permanent bool
	// Review is on while the section's review workflow is (see
	// content.WithReview): only approved revisions can be published or
	// scheduled, and the panel offers submitting, approving and rejecting.
	Review bool
}

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

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

type ScheduleInput struct {
	PublishAt   time.Time `form:"input,datetime-local" label:"Publish at"`
	UnpublishAt time.Time `form:"input,datetime-local" label:"Unpublish at"`
}

type ScheduledEntry struct {
	Title   string
	URL     string
	Section string
	Icon    string
	// Change is "Goes online" or "Goes offline", translated.
	Change string
	// Offline is set for an unpublication.
	Offline bool
	When    string
	Time    string
	// contains filtered or unexported fields
}

type ScheduledItem struct {
	Title string
	URL   string
	// PublishAt puts the item online, UnpublishAt takes it offline; zero
	// when not planned.
	PublishAt   time.Time
	UnpublishAt time.Time
}

type ScheduledPanel struct {
	PanelState

	Items []ScheduledEntry
}

type Search struct {
	// Text is the search as typed.
	Text string
	// contains filtered or unexported fields
}

type SearchBox struct {
	Text   string
	Action string
	// Keep are the other parameters of the page.
	Keep []SearchParam
	// ClearURL is the page without the search.
	ClearURL string
	// NewLabel, translated, and NewURL are the section's "new item" action,
	// such as "New post", on the overview of a section that has one
	// (Section.NewLabel) when the user may create; the empty list offers
	// it. Both are empty otherwise.
	NewLabel string
	NewURL   string
}

type SearchParam struct {
	Name  string
	Value string
}

type Section struct {
	// ID names the section, for example "pages" or "news".
	ID string
	// Permission is the section whose rights apply, when they are shared with
	// another section (News categories use "news"). Empty means ID.
	Permission string
	// AdminOnly sections are for administrators only and not in the matrix.
	AdminOnly bool
	// Title is the navigation label; it is translated.
	Title string
	// Path is the section's address below the admin, for example "/news"
	// for <admin path>/news; empty is "/" followed by ID. Links to
	// the section use its route names (see RouteName), so nothing depends
	// on where the admin is (see Options.Path).
	Path string
	// Icon is an icon name from assets/icons.svg; "box" when empty.
	Icon string
	// Group is the heading the section is listed under in the navigation,
	// such as "Website"; it is translated. Groups are sorted by name, and
	// GroupSystem comes last. Empty lists the section at the top, without
	// heading, as Pages and Media are. Modules set it with
	// webthings.Module.Group.
	Group string
	// Hidden keeps the section out of navigation.
	Hidden bool
	// Badge returns a count shown next to the section in the navigation, such
	// as new submissions; zero shows nothing. It runs on every admin page for
	// the sections the user may see, so it must be cheap. The dashboard lists
	// the sections with a count under "Needs attention".
	Badge func(ctx context.Context) int
	// Callout returns a card the dashboard shows above its panels, such as
	// the Site settings' "Finish setting up your site", and false to show
	// none. The dashboard asks it for users who may view the section, with
	// the request's context, which carries the signed-in user
	// (auth.CurrentUser); it runs on every dashboard view, so it must be
	// cheap.
	Callout func(ctx context.Context) (Callout, bool)
	// NewLabel with NewRoute or NewPath offers a quick action on the
	// dashboard, such as "New post", to users who may create in the
	// section. NewLabel is translated. NewRoute is the name of the
	// section's route for a new item, such as "new" (see RouteName);
	// NewPath is its path below the admin instead, such as "/news/new",
	// and is used only without NewRoute. Editor sections set NewLabel and
	// NewRoute.
	NewLabel string
	NewRoute string
	NewPath  string
	// Recent lists the section's most recently changed items, newest first
	// and at most limit, for the dashboard's "Recently edited". It runs on
	// every dashboard view for the sections the user may see, so it must
	// read no more than limit items (content stores have Recent) and leave
	// deleted items out. Editor sections set it.
	//
	// The dashboard's panels load after the page, each on its own, and ask
	// every section at the same time, so a slow section delays only its
	// panel. Recent, Scheduled, Review and Badge get a context that ends
	// after a few seconds; a section that has not answered by then is
	// named in the panel as one that could not be loaded.
	Recent func(ctx context.Context, limit int) ([]RecentItem, error)
	// Scheduled lists the section's planned publication changes, the
	// earliest first and at most limit, for the dashboard's "Scheduled".
	// Editor sections whose store can plan publication set it.
	Scheduled func(ctx context.Context, limit int) ([]ScheduledItem, error)
	// Review lists the section's revisions waiting for review, oldest
	// request first and at most limit, for the dashboard's "Needs
	// attention". The dashboard calls it for users who may review in the
	// section; it returns nothing while the section's review workflow is
	// off. Sections that set it are revisioned content that can be
	// reviewed: the permission matrix offers the Review right for them
	// only. Editor sections of revisioned stores set it.
	Review func(ctx context.Context, limit int) ([]ReviewItem, error)
	// Trash holds the section's deleted items, for the admin's trash (see
	// Trash). Editor sections set it; modules with records of their own
	// implement it.
	Trash Trash
	// Files holds the section's templates and translations/<locale>.po.
	Files fs.FS
	// Stylesheet names a CSS file in Files, for example "assets/stats.css",
	// that every admin page links. Scope its rules under classes of your own:
	// all sections share the page.
	Stylesheet string
	// MaxBodyBytes raises the 512 KiB request limit, for uploads.
	MaxBodyBytes int64
	// Routes registers the section's handlers.
	Routes func(*Routes)
}

type SessionRow struct {
	Created, Expires, LastSeen string
	Active                     bool
	Revoke                     *form.RenderModel
}

type ShellView struct {
	Title        string
	PageTitle    string
	SectionTitle string
	SectionURL   string
	// Dashboard is set on the dashboard, where the breadcrumbs, which start
	// at the dashboard, show only the page.
	Dashboard bool
	Language  string
	// Stylesheets are the link tags of the sections' own stylesheets, with
	// their versions and integrity, on every page.
	Stylesheets []template.HTML
	// Navigation lists the links of Groups in their order.
	Navigation []NavigationLink
	// Groups are the navigation as shown: first the links without heading
	// (Dashboard, Pages, Media), then the named groups by name, and
	// GroupSystem last.
	Groups []NavigationGroup
	User   *auth.User
	Logout form.RenderModel
	// Presence is who else is on this page (see presence.go).
	Presence PresenceView
}

type Tab struct {
	// Label is the text of the link: a translation key such as "Pending",
	// or a name chosen by the site owner, which shows as written.
	Label string
	// Value is the value of the filter parameter the tab selects; empty for
	// the tab without the parameter, such as "All". FilterTabs uses it.
	Value string
	URL   string
	// Active marks the tab of the list being shown.
	Active bool
	// Count is shown as a badge after the label when Counted is set, such
	// as the number of messages with the tab's status.
	Count   int
	Counted bool
}

type Tabs struct {
	// Label names the row for screen readers: a translation key such as
	// "Status".
	Label string
	Items []Tab
}

type TranslationStatus func(locale string) (complete, started bool)

type Trash interface {
	// List returns the deleted items whose title or kind matches query (see
	// Matches; empty matches all), most recently deleted first: at most limit
	// of them from offset, and how many match in all.
	List(ctx context.Context, query string, limit, offset int) ([]TrashItem, int, error)
	// Restore brings items back. Items that cannot come back, such as an item
	// whose slug another item took meanwhile, are reported as TrashErrors
	// (see EachTrashItem) while the others are restored.
	Restore(ctx context.Context, ids []string) error
	// Purge removes items for good, with what belongs to them.
	Purge(ctx context.Context, ids []string) error
}

type TrashEntry struct {
	// Value identifies the item in the posted selection; empty when the user
	// may not restore or purge it.
	Value     string
	Title     string
	Kind      string
	URL       string
	DeletedBy string
	When      string
	Time      string
	// contains filtered or unexported fields
}

type TrashError struct {
	ID string
	// Reason explains it to the editor; it is translated, for example "Its
	// slug is used by another item now.".
	Reason string
	Err    error
}

type TrashGroup struct {
	Section string
	Title   string
	Icon    string
	Items   []TrashEntry
	Total   int
	// MoreURL shows all items of the section when the overview shows only
	// the first ones.
	MoreURL string
	// Error is set when the section could not list its trash.
	Error bool
}

type TrashItem struct {
	ID    string
	Title string
	// Kind names the type of item when a section keeps several, such as
	// "Submission"; it is translated. Empty shows none.
	Kind      string
	DeletedAt time.Time
	// DeletedBy is the ID of the user who deleted it; empty when unknown.
	DeletedBy string
	// URL shows the item somewhere, if it can be seen while deleted; empty
	// shows the title without link.
	URL string
}

type TrashRecords[T any] struct {
	// Load returns records in the trash, most recently deleted first: at
	// most limit of them from offset (all of them for a limit of 0), and how
	// many the trash holds in all. db.SoftTable.Trashed reads both.
	Load func(ctx context.Context, limit, offset int) ([]T, int, error)
	// Fields are the texts of a record that a search of the trash looks in,
	// such as a name and an e-mail address. Nil searches the title of Item.
	Fields func(record T) []string
	// Item describes a record in the trash's list.
	Item func(record T) TrashItem
	// Undelete brings the record with id back from the trash.
	Undelete func(ctx context.Context, id string) error
	// Purge removes the record with id for good.
	Purge func(ctx context.Context, id string) error
	// Reason explains to the editor why a record stays where it is, for the
	// module's own errors, such as "This redirect cannot be restored:
	// another redirect uses its old path now."; it is translated. A record
	// that is no longer in the trash (db.ErrNotFound) is explained already.
	// An error without a reason stops the whole action and is shown as a
	// failure.
	Reason func(err error) string
}

type TrashView struct {
	// Filters are the sections with a trash, for the filter tabs; the first
	// is all sections.
	Filters Tabs
	// Section is the section shown alone; empty shows all.
	Section string
	Groups  []TrashGroup
	// Action is where the selection is posted; it keeps the filter and the
	// search.
	Action string
	// Restore and Purge are offered when some listed item may be changed.
	CanChange bool
	// PurgeQuestion asks before deleting for good.
	PurgeQuestion string
	// Days is after how many days the site deletes items in the trash for
	// good (Options.TrashDays); 0 is never.
	Days int
	// Pager pages through one section.
	Pager Pager
}

type TwoStepSetup struct {
	// QR is the address of the QR code, a PNG.
	QR string
	// Key is the secret in groups of four characters, to type by hand.
	Key     string
	Confirm form.RenderModel
	Errors  form.FieldErrors
	Cancel  form.RenderModel
}

type TwoStepView struct {
	// On means that signing in asks for a code after the password.
	On bool
	// Start turns two-step sign-in on; nil while it is on or a setup waits
	// for its first code.
	Start *form.RenderModel
	// Setup is the setup that waits for its first code.
	Setup *TwoStepSetup
	// RecoveryCodes is the number of recovery codes not used yet.
	RecoveryCodes int
	// Codes are new recovery codes, shown on this page only: only their
	// digests are stored.
	Codes []string
	// Off turns two-step sign-in off and Recovery makes new recovery
	// codes; both are nil while it is off.
	Off            *form.RenderModel
	OffErrors      form.FieldErrors
	Recovery       *form.RenderModel
	RecoveryErrors form.FieldErrors
}