frontend

type AccessPolicy interface {
	Allowed(*core.User, *core.Title) bool
}

type ActiveUserSource interface {
	ActiveUser(context.Context, int64) (*User, error)
}

type ActivityPage struct {
	Items      []Title
	Total      int
	TotalExact bool
	More       bool
}

type AiredMemo struct {
	Items []core.Title
	Total int
	Err   error
}

type Announcer interface {
	Start(context.Context) error
	Close() error
}

type AppConnectionAdmission interface {
	PrepareAppConnection(*http.Request, string, PlanRequest) error
}

type AppConnectionStatus interface {
	AppConnections(context.Context, string) (int, error)
}

type AppPasswordIdentity interface {
	AuthenticateAppPassword(context.Context, string, string) (*Viewer, error)
}

type Artwork interface {
	List(context.Context, ArtworkRequest) (images []Image, complete bool, err error)
	Read(context.Context, ArtworkRequest, Image, ArtworkTransform) (data []byte, contentType string, err error)
	RemoteCache() ArtworkImageCache
	PaletteCache() ArtworkPaletteCache
	PosterRenderer() TitlePosterRenderer
	ImageURLFunc() ImageURLFunc
}

type ArtworkAccessPolicy interface{ Restricted(*User) bool }

type ArtworkCollectionArt interface {
	CollectionArtwork(ctx context.Context, viewer *User, key RatingKey, element string, width int) ([]byte, string, bool, error)
}

type ArtworkImageCache interface {
	Get(ctx context.Context, u string, now time.Time) (*ArtworkRemoteImage, error)
	RasterFormat(ctx context.Context, data []byte, ct, format string, now time.Time) ([]byte, string, error)
	IsNotFound(err error) bool
}

type ArtworkImageFile = core.ArtworkImageFile

type ArtworkImages = core.ArtworkImages

type ArtworkOwner struct {
	Item          RatingKey
	Images        []Image
	Authoritative bool
}

type ArtworkPalette struct {
	TopLeft, TopRight, BottomLeft, BottomRight string
}

type ArtworkPaletteCache interface {
	Lookup(key RatingKey, path string) *ArtworkPalette
	Preload(ctx context.Context, wants []ArtworkPaletteWant)
	PersistFor(persist func(context.Context, RatingKey) bool)
}

type ArtworkPaletteWant struct {
	Key  RatingKey
	Path string
}

type ArtworkPersistenceCatalog interface {
	PersistsArtwork(context.Context, RatingKey) bool
}

type ArtworkRemoteImage struct {
	URL         string
	Data        []byte
	ContentType string
	FetchedAt   time.Time
}

type ArtworkRequest struct {
	Viewer *core.Viewer
	Device core.Device
	Item   core.RatingKey
	// Channel is a stable LiveTV channel ID. Exactly one of Item and Channel
	// identifies the subject.
	Channel string
}

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

type ArtworkSource interface {
	Artwork
	Warm(t Title, d Device)
	ChannelImage(viewer *Viewer, channel LiveTVChannel) Image
	ArtPath(ctx context.Context, req ArtworkRequest, element string) (path string, defWidth int, err error)
}

type ArtworkSourceConfig struct {
	Catalog          StoredTitleLookup
	CollectionDevice string
	Collections      Collections
	Playlists        Playlists
	Visibility       Visibility
	LiveTV           LiveTV
	Discovery        *DiscoveryFeatures
	Images           ArtworkImageCache
	ImageURL         ImageURLFunc
	Palettes         ArtworkPaletteCache
	Now              func() time.Time
	Variants         func(*Title, string) (*ArtworkImages, bool)
	Metadata         func(context.Context, ArtworkRequest, Image) Image
	VirtualSeason    func(context.Context, *User, RatingKey) (*Title, error)
	URLImages        UntrustedImageFetcher
	Raster           SVGRasterizer
	Generated        TitlePosterRenderer
}

type ArtworkTransform struct {
	Width, Height int
	Format        string
	Blur          bool
}

type AudioLimit = core.AudioLimit

type Auth = core.Auth

type AuthenticatedLazyStreams interface {
	ServeAuthenticated(http.ResponseWriter, *http.Request, string, PlanRequest)
}

type AvailabilitySource interface {
	Available(context.Context, RatingKey) (bool, bool)
}

type BIF = transcode.BIF

type BIFFrame = transcode.BIFFrame

type BackgroundWorker interface {
	BackgroundBusy() int
}

type Binding[R any] struct {
	ID          string // client "session" param
	StreamToken string // independent random capability; never a client-chosen ID
	PlayID      string // core.PlaySession.ID
	PlaybackID  string // explicit X-Plex-Session-IDentifier owning this encoder
	UserID      int64
	ClientID    string
	Key         core.RatingKey
	Requested   R // original Decision/start inputs, before policy refinement
	Decision    core.Decision
	Info        core.MediaInfo
	Subtitle    int // selected Subtitle's position in Info, -1 = none
	Caps        core.ClientCaps
	Opts        core.DecideOptions
	Offset      time.Duration
	Started     bool // StartHLS ran
	UpdatedAt   time.Time
	// A failed Decision for this binding (FailKey, FailErr at FailedAt):
	// the start request that follows it answers with the same error at
	// once instead of resolving again. One-shot and short-lived.
	FailKey  core.RatingKey
	FailErr  error
	FailedAt time.Time
}

type BindingTable[R any] struct {
	// contains filtered or unexported fields
}

type BitrateAccessPolicy = core.BitrateAccessPolicy

type BrowseBlocksPolicy interface {
	BrowseBlocks(*User) ([]string, []string)
}

type BrowseQuery = core.BrowseQuery

type BrowseShareFilterPolicy interface {
	BrowseShareFilter(*User, MediaType) Filter
}

type CachedMetadataOverlay = plexmeta.Cached

type CachedTitleBatchReader interface {
	CachedGetMany(context.Context, []RatingKey) (map[RatingKey]Title, error)
}

type CachedTitleReader interface {
	CachedGet(context.Context, RatingKey) (*Title, error)
}

type CachedTitleSource interface {
	CachedTitles(context.Context, []RatingKey) ([]Title, error)
}

type Capabilities interface {
	Build(context.Context, CapabilityRequest) (CapabilityResult, error)
	ApplyClientRules(HostQualityConfig, core.ClientCaps, *core.Viewer, string) core.ClientCaps
}

type CapabilityRequest struct {
	Viewer       *core.Viewer
	Device       caps.DeviceInfo
	Profile      caps.DeviceProfile
	ProtocolInfo []string
	UserAgent    string
}

type CapabilityResult struct {
	Client  core.ClientCaps
	Quality core.QualityProfile
}

type Catalog = core.Catalog

type CatalogSchedule interface {
	ScheduledEpisodes(context.Context, RatingKey) ([]Title, error)
}

type CertifiedApp struct {
	Name  string        `json:"name"`
	Steps []ConnectStep `json:"steps"`
}

type CinemaIntros interface {
	Trailers(context.Context, *core.Viewer, core.Device, core.RatingKey, int) ([]Extra, error)
}

type ClientCapabilityOverride = core.ClientCapabilityOverride

type ClientCaps = core.ClientCaps

type ClientPolicy = transcode.ClientPolicy

type ClusterBus = clusterbus.Bus

type ClusterNode = clusterbus.Node

type Collection = core.Collection

type CollectionPage struct {
	Items []core.Collection
	Total int
}

type CollectionQuery struct {
	Types         []core.MediaType
	Offset, Limit int
}

type Collections = core.Collections

type Command struct {
	Kind                CommandKind
	Position            time.Duration
	StreamIndex         int
	Message             string
	ControllerSessionID string
}

type CommandKind string

type CompletedShowsState interface {
	PlaybackCompletedShows(context.Context, int64, []RatingKey) (map[RatingKey]bool, error)
}

type ConnectStep string

type Continuation string

type Continue interface {
	WithoutFilter() Continue
	InProgress(ctx context.Context, viewer *core.User, t core.MediaType, limit int) ([]core.Title, map[core.RatingKey]core.WatchStatus)
	Row(ctx context.Context, viewer *core.User, kind core.MediaType, limit int) ([]core.Title, map[core.RatingKey]core.WatchStatus)
	Shelf(ctx context.Context, viewer *core.User, kind core.MediaType, limit int) ([]core.Title, map[core.RatingKey]core.WatchStatus, bool)
}

type ContinueDeck interface {
	Prepare(ctx context.Context, shows []core.RatingKey)
	Select(ctx context.Context, show core.RatingKey) (*core.Title, map[core.RatingKey]core.WatchStatus)
}

type ContinueDeckOptions struct {
	Load        func(context.Context, []core.RatingKey) (map[core.RatingKey][]core.Title, map[core.RatingKey]core.WatchStatus)
	Order       func(context.Context, core.RatingKey, []core.Title) ([]core.Title, error)
	Hydrate     func(context.Context, []core.RatingKey) []core.Title
	Unavailable func(context.Context, *core.Title) bool
	Fallback    func(context.Context, core.RatingKey, []core.Title, bool) (*core.Title, map[core.RatingKey]core.WatchStatus)
}

type ContinueEpisodesCatalog interface {
	ContinueEpisodes(context.Context, []RatingKey) (map[RatingKey]*Title, error)
}

type ContinueHider interface {
	HideContinue(context.Context, int64, RatingKey) error
}

type ContinueOptions struct {
	ShowOnDeck         func(context.Context, core.RatingKey) (*core.Title, map[core.RatingKey]core.WatchStatus)
	PrepareShowOnDeck  func(context.Context, []core.RatingKey)
	PrefetchTitles     func(context.Context, []core.RatingKey)
	Filter             func(context.Context, *core.User, []core.Title) []core.Title
	State              core.State
	EpisodeOrder       EpisodeOrderGrouped
	Now                func() time.Time
	Grandchildren      func(context.Context, core.RatingKey) ([]core.Title, error)
	NextEpisode        func(context.Context, core.RatingKey) (*core.Title, error)
	NextEpisodes       func(context.Context, []core.RatingKey) (map[core.RatingKey]*core.Title, error)
	Visible            func(context.Context, *core.User, *core.Title) bool
	SameDayUnavailable func(context.Context, *core.Title) bool
	GetTitles          func(context.Context, []core.RatingKey) []core.Title
	SectionAllowed     func(*core.User, core.MediaType) bool
	OnError            func(error)
	FavoriteShows      func(context.Context, *core.User) (map[core.RatingKey]bool, error)
	Unrestricted       func(*core.User) bool
}

type ContinueRestorer interface {
	RestoreContinue(context.Context, int64, RatingKey) error
}

type CredentialAcceptance = auth.Acceptance

type CredentialAcceptor interface {
	Accept(context.Context, string) (*Viewer, CredentialAcceptance, error)
	ReceiptCurrent(context.Context, CredentialAcceptance) error
}

type CreditFilter = core.CreditFilter

type DASHSession = core.DASHSession

type Dashboard interface {
	SeeDevice(clientID, name, platform string) StatisticsDevice
	Devices() []StatisticsDevice
	Device(id int64) (StatisticsDevice, bool)
	Bandwidth(StatisticsQuery) StatisticsPage
	Media(StatisticsQuery) StatisticsPage
	RecordBytes(accountID int64, accountName, clientID, deviceName, platform string, lan bool, n int64)
	RecordPlay(accountID int64, accountName, clientID string, metadataType int, durationSec int64)
}

type DateFilter = core.DateFilter

type DecideOptions = core.DecideOptions

type Decision = core.Decision

type DecisionArms interface {
	Expire(now time.Time)
	Arm(pr DecisionOwner, key core.RatingKey)
	Armed(pr DecisionOwner, key core.RatingKey) bool
	Disarm(pr DecisionOwner, key core.RatingKey)
	Refresh(now time.Time)
	ClearOwn()
}

type DecisionCandidate = core.DecisionCandidate

type DecisionKind = core.DecisionKind

type DecisionOwner struct {
	ID                  string
	UserID              int64
	ClientID, SessionID string
}

type DecisionTrace = core.DecisionTrace

type DelegationAuth interface {
	IssueDelegation(context.Context, int64) (string, error)
}

type DerivedPruner interface {
	Prune(context.Context) (int64, error)
}

type Descriptor struct {
	ID             Protocol       `json:"id"`
	Name           string         `json:"name"`
	Logo           string         `json:"logo,omitempty"`
	Version        string         `json:"version,omitempty"`
	DocsURL        string         `json:"docsUrl,omitempty"`
	DefaultPort    int            `json:"defaultPort,omitempty"`
	Clients        []string       `json:"clients,omitempty"`
	CertifiedApps  []CertifiedApp `json:"certifiedApps,omitempty"`
	SettingsSchema any            `json:"settingsSchema,omitempty"`
}

type DetailFacts struct {
	Header       string
	RatingsKnown bool
	Community    *float64
	Critic       *float64
	Sources      []ExternalRating
}

type DetailFactsSource interface {
	DetailFacts(context.Context, *core.Viewer, core.Title) DetailFacts
	PageRatings(context.Context, *core.Viewer, []core.Title) map[core.RatingKey]DetailFacts
}

type DetailPlanner interface {
	DetailPlan(ctx context.Context, request PlanRequest) (PlayPlan, error)
	ResolveDetailSource(ctx context.Context, scope VersionScope, handle string) (DetailSourceTarget, error)
	MatchDetailSession(ctx context.Context, scope VersionScope, handle, sessionID string) error
}

type DetailRelated interface {
	SourceVisible(ctx context.Context, viewer *core.User, key core.RatingKey) bool
	Rows(ctx context.Context, viewer *core.User, key core.RatingKey, count int) ([]core.Hub, error)
}

type DetailRelatedOptions struct {
	Source     core.Recommender
	Visibility Visibility
	Get        func(context.Context, core.RatingKey) (*core.Title, error)
}

type DetailSourceTarget struct {
	Item RatingKey
	ETag string
}

type DetailWarmer interface {
	WarmDetail(context.Context, PlanRequest) bool
}

type Device = core.Device

type DeviceIdentity interface {
	ResolveDevice(context.Context, string, Device) (*Viewer, time.Time, error)
}

type DiagnosticClientFacts = diagnostics.ClientFacts

type DiagnosticClientInput = diagnostics.ClientInput

type DiagnosticEvent = diagnostics.Event

type DiagnosticHubSummary = diagnostics.HubSummary

type DiagnosticKind = diagnostics.Kind

type DiagnosticPlaybackCandidate = diagnostics.PlaybackCandidate

type DiagnosticPlaybackDecision = diagnostics.PlaybackDecision

type DiagnosticPlaybackVariant = diagnostics.PlaybackVariant

type DiagnosticRecorder interface {
	Recording() bool
	BeginSample(string) bool
	EndSample()
	Observe(DiagnosticEvent)
}

type DiagnosticResponseSummary = diagnostics.ResponseSummary

type DiagnosticViewerCandidate = diagnostics.ViewerCandidate

type DiagnosticViewerFacts = diagnostics.ViewerFacts

type DiagnosticViewerSection = diagnostics.ViewerSection

type DiscoveryArtworkSelection struct {
	Title                                       *core.Title
	Enabled                                     bool
	PosterVersion, BackdropVersion, LogoVersion string
}

type DiscoveryCandidate struct {
	Index   int
	Purpose core.RowPurpose
	Items   []core.Title
}

type DiscoveryFeatures struct {
	Watchlist DiscoveryWatchlist
	Ratings   DiscoveryRatings
	Overlays  DiscoveryOverlays
	Personal  DiscoveryPersonal
	LLM       DiscoveryLLM
	// OverviewTranslate is optional. detail is true only when a viewer opened
	// the item. A library row passes false and must not call a model.
	OverviewTranslate func(ctx context.Context, t *core.Title, lang string, detail bool) (summary, tagline string, ok bool)
	SelectArtworkFn   func(ctx context.Context, viewer *core.User, t *core.Title, lang string) DiscoveryArtworkSelection
	PrepareArtworkFn  func(ctx context.Context, viewer *core.User, t *core.Title, lang string) (*core.Title, string, error)
	RenderArtworkFn   func(ctx context.Context, viewer *core.User, t *core.Title, kind, lang string) ([]byte, string, error)
	CachedRecapFn     func(viewer *core.User, t *core.Title, state core.State, now time.Time) string
}

type DiscoveryLLM interface {
	NaturalSearch(ctx context.Context, viewer *core.User, query string, limit int) ([]core.Title, error)
}

type DiscoveryOverlays interface {
	CustomPostersEnabled() bool
	Paths(ctx context.Context, viewer *core.User, t *core.Title, lang string) (string, string)
	WithSettingsSnapshot(ctx context.Context) context.Context
	WithArtworkPage(ctx context.Context, keys []core.RatingKey) (context.Context, error)
}

type DiscoveryPersonal interface {
	Hubs(ctx context.Context, viewer *core.User, limit int) ([]core.Hub, error)
	RemoveContinue(ctx context.Context, uid int64, key core.RatingKey) error
	RestoreContinue(ctx context.Context, uid int64, key core.RatingKey) error
	ContinueAllowed(ctx context.Context, uid int64, t *core.Title) bool
	FilterContinue(ctx context.Context, viewer *core.User, titles []core.Title) []core.Title
}

type DiscoveryRatingBadge struct {
	Source string
	Value  float64
	Image  string
}

type DiscoveryRatings interface {
	Cached(ctx context.Context, t *core.Title) ([]DiscoveryRatingBadge, error)
	Settings(ctx context.Context) (DiscoveryRatingsSettings, error)
	Queue(t core.Title)
	WithSettingsSnapshot(ctx context.Context) context.Context
}

type DiscoveryRatingsSettings struct {
	Enabled          bool
	Critic, Audience string
	Missing          string
}

type DiscoveryRequest struct {
	Data     []byte
	Peer     netip.AddrPort
	Endpoint string
}

type DiscoveryResponder interface {
	RespondDiscovery(context.Context, DiscoveryRequest) ([]byte, bool)
}

type DiscoverySelection interface {
	Load(ctx context.Context, viewer *core.User, limit int, load func(context.Context, int) []DiscoveryCandidate) []DiscoveryCandidate
}

type DiscoverySelectionOptions struct {
	Visibility   Visibility
	Unrestricted func(*core.User) bool
}

type DiscoveryWatchlist interface {
	Hubs(ctx context.Context, viewer *core.User, limit int) ([]core.Hub, error)
	RecapsEnabled(ctx context.Context) bool
	NaturalSearchEnabled(ctx context.Context) bool
}

type DownloadAccessPolicy = core.DownloadAccessPolicy

type DownloadItem struct {
	ID      int64
	QueueID int64
	Key     core.RatingKey
	Title   string // display Title, for the served filename

	Caps core.ClientCaps // as requested at add time (Download set at Run)
	User *core.User

	Status   string
	Error    string
	Progress float64 // 0..1
	Started  bool
	Cancel   context.CancelFunc
	// Run numbers each start of the Item, so a restarted job gets its own
	// playback session instead of sharing (and later stopping) the
	// previous Run's.
	Run int64

	Path       string
	Size       int64
	ReadyAt    time.Time
	VideoCodec string
	AudioCodec string
	Duration   time.Duration
	Bandwidth  int // requested maxVideoBitrate, kbps
	Burn       bool
}

type DownloadJob interface {
	Run(ctx context.Context, q DownloadRequest) (string, int64, error)
}

type DownloadPreparationError struct{ Err error }

type DownloadQueue struct {
	ID       int64
	UserID   int64
	ClientID string
	Items    []*DownloadItem
}

type DownloadQueuePersistence interface {
	Retain(path string, ready time.Time)
	Save() error
	Load(ctx context.Context)
	Run(ctx context.Context)
}

type DownloadQueueStore interface {
	QueueFor(UserID int64, ClientID string, create bool) *DownloadQueue
	QueueByID(ID, UserID int64, ClientID string) *DownloadQueue
	Add(q *DownloadQueue, u *core.User, t core.Title, caps core.ClientCaps, burn bool) *DownloadItem
	StartReady(ctx context.Context, perUser int, allowed func(*core.User) bool) []DownloadStart
	Expire(now time.Time, expiry time.Duration) []string
	StopForRestart()
	Remove(q *DownloadQueue, ids []int64) []*DownloadItem
	Restart(q *DownloadQueue, ids []int64, release func(string))
	CancelItem(it *DownloadItem) string
	Fail(ctx context.Context, it *DownloadItem, message string)
	Lock()
	Unlock()
	WakeDownloads()
	AllItems() []*DownloadItem
	Prepared(ctx context.Context, it *DownloadItem, info core.MediaInfo) bool
	Progress(ctx context.Context, it *DownloadItem, fraction float64)
	Complete(ctx context.Context, it *DownloadItem, path string, size int64, now time.Time) bool
}

type DownloadRemuxer = core.DownloadRemuxer

type DownloadRequest struct {
	Viewer    *core.User
	Item      core.RatingKey
	Caps      core.ClientCaps
	Run       int64
	NoRelease func(error) bool
	Prepared  func(*core.PlaySession) (core.DecideOptions, error)
	Progress  func(float64)
}

type DownloadStart struct {
	Item    *DownloadItem
	Context context.Context
	Run     int64
}

type EditionBatch interface {
	EditionsMany(context.Context, *core.Viewer, core.Device, []core.RatingKey) (map[core.RatingKey][]Version, error)
}

type Editions interface {
	Editions(context.Context, *core.Viewer, core.Device, core.RatingKey) ([]Version, error)
	Variants(ctx context.Context, req core.ResolveRequest, max int) ([]core.ReleaseVariant, error)
	RefillSearchCache(t *core.Title) <-chan struct{}
	Available(ctx context.Context, key core.RatingKey) (bool, bool)
}

type EncodedMediaForwarder interface {
	ForwardEncodedMedia(w http.ResponseWriter, r *http.Request, id string) bool
}

type EncoderBindingDeleter interface {
	DeleteBinding(ctx context.Context, id string) error
}

type EncoderBindingStore interface {
	PlexHLSDistributed(id string) bool
	SavePlexBinding(ctx context.Context, id string, raw []byte) error
	LoadPlexBinding(ctx context.Context, id string) ([]byte, error)
}

type EncoderStatus = core.EncoderStatus

type EncoderStatusSession interface {
	EncoderStatus() *core.EncoderStatus
}

type EpisodeBatch interface {
	Load(ctx context.Context, viewer *core.User, ts []core.Title, selectionOnly bool) (map[core.RatingKey][]core.Title, map[core.RatingKey]core.WatchStatus)
}

type EpisodeBatchOptions struct {
	Catalog      core.Catalog
	State        core.State
	EpisodeOrder EpisodeOrderGrouped
}

type EpisodeOrder interface {
	Customized(context.Context, *Viewer) (bool, error)
	Grouped(context.Context, *Viewer, []RatingKey) (map[RatingKey]bool, error)
	Get(context.Context, *Viewer, RatingKey) (*Title, error)
	Children(context.Context, *Viewer, RatingKey) ([]Title, error)
	Grandchildren(context.Context, *Viewer, RatingKey) ([]Title, error)
	OrderStoredGrandchildren(context.Context, *Viewer, RatingKey, []Title) ([]Title, error)
	Position(context.Context, *Viewer, RatingKey) (season, episode int, name string, ok bool)
}

type EpisodeOrderGrouped interface {
	Grouped(context.Context, *core.User, []core.RatingKey) (map[core.RatingKey]bool, error)
}

type Estimator interface {
	Estimate(context.Context, *core.Title, core.ClientCaps) core.MediaInfo
	SessionFor(int64, string, core.RatingKey) (*core.PlaySession, bool)
}

type Event struct {
	Type     string
	ViewerID int64
	// ActorViewerID is set from the authenticated actor for SessionCommand;
	// zero denotes a system-originated stop without an authenticated actor.
	ActorViewerID int64
	Item          core.RatingKey
	SessionID     string
	// SubjectKind and SubjectID identify non-title user data such as a
	// favorite person, collection or channel. Item remains the title key.
	SubjectKind     string
	SubjectID       string
	OriginProtocol  Protocol
	OriginSessionID string
	OriginClientID  string
	Command         *Command
	TargetProtocol  Protocol
	TargetDeviceID  string
	Session         *Session
	Timeline        *Timeline
}

type EventScope struct {
	Viewer *core.Viewer
	Owner  bool
	// Protocol suppresses this surface's own user-data invalidations.
	Protocol Protocol
	// SessionID selects the authenticated client session for targeted commands.
	SessionID string
	// Device binds a socket before a playback session exists and remains valid
	// when this authenticated device's current session changes.
	Device core.Device
}

type ExactRater interface {
	RateExact(context.Context, int64, RatingKey, float64) error
}

type Experience interface {
	ExperienceServices
	LibraryGUIDs() LibraryGUIDs
	LibraryMetadata() LibraryMetadata
	MarkerRanges
	Views(context.Context, *core.Viewer) ([]View, error)
	Collections(context.Context, *core.Viewer, core.Device, CollectionQuery) (CollectionPage, error)
	NotInterested(context.Context, *core.Viewer, core.Device, PageQuery) (NotInterestedPage, error)
	NotInterestedItem(context.Context, *core.Viewer, core.Device, core.RatingKey) (NotInterestedEntry, error)
	// ResolveExternal resolves an IMDb ID without opening a release, and returns
	// a key only after enforcing current viewer and inherited-show policy.
	ResolveExternal(context.Context, *core.Viewer, core.Device, ExternalRequest) (core.RatingKey, error)
	Rows(context.Context, RowRequest) ([]Row, error)
	Item(context.Context, ItemRequest) (ItemDetail, error)
	Children(context.Context, *core.Viewer, core.Device, core.RatingKey, ItemQuery) (core.Page, error)
	LibraryItems(context.Context, *core.Viewer, core.Device, string, ItemQuery) (core.Page, error)
	Similar(context.Context, *core.Viewer, core.Device, core.RatingKey, ItemQuery) (SearchPage, error)
	Ancestors(context.Context, *core.Viewer, core.Device, core.RatingKey) ([]core.Title, error)
	Facets(context.Context, *core.Viewer, core.Device, string, string) ([]core.FacetValue, error)
	ResolveFacet(context.Context, *core.Viewer, core.Device, string, string, string) (core.FacetValue, error)
	// PersonFacetIDs returns IDs only for credited people of an authorized title.
	// Episode-only credits may not appear in library-wide Facets or ResolveFacet.
	// Requests are bounded to 256 positive TMDB IDs; missing credits are omitted.
	PersonFacetIDs(context.Context, *core.Viewer, core.Device, core.RatingKey, []int64) (map[int64]string, error)
	// NamedFacetIDs resolves exact genre or studio names on one visible title.
	// A request contains at most 256 nonempty names; missing names are omitted.
	NamedFacetIDs(context.Context, *core.Viewer, core.Device, core.RatingKey, string, []string) (map[string]string, error)
	Search(context.Context, *core.Viewer, core.Device, string, ItemQuery) (SearchPage, error)
	UserData(context.Context, *core.Viewer, []core.RatingKey) (map[core.RatingKey]core.WatchStatus, error)
	SetPlayed(context.Context, *core.Viewer, core.RatingKey) error
	SetUnplayed(context.Context, *core.Viewer, core.RatingKey) error
	SetFavorite(context.Context, *core.Viewer, core.RatingKey, bool) error
	SetNotInterested(context.Context, *core.Viewer, core.RatingKey, bool) error
	SetWatchlist(context.Context, *core.Viewer, core.RatingKey, bool) error
	SetEntityFavorite(context.Context, *core.Viewer, FavoriteRef, bool) error
	EntityFavorites(context.Context, *core.Viewer, []FavoriteRef) (map[FavoriteRef]bool, error)
	ResolveEventSubject(context.Context, *core.Viewer, core.Device, FavoriteRef) (ResolvedEventSubject, error)
	SetRating(context.Context, *core.Viewer, core.RatingKey, float64) error
	SetLikes(context.Context, *core.Viewer, core.RatingKey, *bool) error
	RemoveFromContinue(context.Context, *core.Viewer, core.RatingKey) error
}

type ExperienceServices interface {
	NewRecent(RecentOptions) Recent
	NewDetailRelated(DetailRelatedOptions) DetailRelated
	NewEpisodeBatch(EpisodeBatchOptions) EpisodeBatch
	NewContinueDeck(ContinueDeckOptions) ContinueDeck
	NewContinue(ContinueOptions) Continue
	NewRowSelection(RowSelectionOptions) RowSelection
	NewHomeSelection(HomeSelectionOptions) HomeSelection
	NewScopedCollection(ScopedCollectionOptions) ScopedCollection
	NewPlaylistSelection(PlaylistSelectionOptions) PlaylistSelection
	NewPostPlaySelection(PostPlaySelectionOptions) PostPlaySelection
	NewDiscoverySelection(DiscoverySelectionOptions) DiscoverySelection
	NewTrackPreferenceSelector(TrackPreferenceSelectorOptions) TrackPreferenceSelector
	SearchFor(src SearchSources, vis Visibility, unrestricted func(*core.User) bool) Search
	StatisticsDefaults(dashboard Dashboard, resources ResourceStatistics, now func() time.Time) (Dashboard, ResourceStatistics)
	MergeShareFilter(filter, share core.Filter) (core.Filter, bool)
	ArrangeHome(ctx context.Context, source core.Recommender, viewer *core.User, hc core.HubContext, section string, rows []core.Hub, candidates []core.NeutralHomeRow) ([]int, error)
	DetailExtras(ctx context.Context, source ExtrasSource, parent *core.Title, language string, wanted map[int]bool) ([]ExtraClip, error)
	DiscoverySearch(source *DiscoveryFeatures) func(context.Context, *core.User, string, int) ([]core.Title, bool)
	FamiliarFrom(st any) func(context.Context, *core.User, []core.RatingKey) map[core.RatingKey]int
	ContinueFilter(state core.State, personal func(context.Context, *core.User, []core.Title) []core.Title) func(context.Context, *core.User, []core.Title) []core.Title
	SameDayUnavailable(ctx context.Context, title *core.Title, now time.Time, filter func(context.Context, []core.Title) []core.Title, source AvailabilitySource) bool
	SeasonNextEpisode(eps []core.Title, st map[core.RatingKey]core.WatchStatus, now time.Time, unavailable func(*core.Title) bool) *core.Title
	ShowOnDeck(eps []core.Title, st map[core.RatingKey]core.WatchStatus, unavailable func(*core.Title) bool) *core.Title
	RequestDatabaseObservation(ctx context.Context) (int64, time.Duration)
	PlaybackMarkerRanges(ctx context.Context, source MarkerRanges, key core.RatingKey, info core.MediaInfo) ([]MarkerRange, error)

	CatalogSource() core.Catalog
	CollectionsSource() core.Collections
	StateSource() core.State
	PlaylistsSource() core.Playlists
	RecommenderSource() core.Recommender
	VibeSearchSource() VibeSearcher
	SearchSources() SearchSources
	FavoriteShowsFunc() func(context.Context, *core.User) (map[core.RatingKey]bool, error)
	FilterAvailableFunc() func(context.Context, []core.Title) []core.Title
	JudgedOnFactsFunc() func(context.Context) func(core.Title) bool
	PrioritizeAvailableFunc() func(context.Context, []core.Title) []core.Title
	EpisodeOrderSource() EpisodeOrder
	DiscoveryFeatures() *DiscoveryFeatures
	DashboardSource() Dashboard
	ResourcesSource() ResourceStatistics
	LibraryTitles() (movies, shows string)
	HomeRevision(ctx context.Context, viewer *core.User) (HomeRevision, bool, error)
	NoProviderWait(ctx context.Context) context.Context
}

type ExportPolicy struct {
	Stamp       string
	TitleJudged bool
}

type ExternalRating struct {
	Source, Name, Display string
	Score                 float64
	Votes                 int64
}

type ExternalRequest struct {
	Source          string
	ID              string
	Type            core.MediaType
	Season, Episode *int
}

type Extra struct {
	Key, ParentKey                          core.RatingKey
	Title, Kind, Source, SourceID, Language string
	Official                                bool
	PublishedAt                             time.Time
	Duration                                time.Duration
	Height                                  int
}

type ExtraClip struct {
	Key         core.RatingKey
	ParentKey   core.RatingKey
	ParentTitle string
	Title       string
	Subtype     string
	ExtraType   int
	Site        string
	SiteKey     string
	Language    string
	Official    bool
	PublishedAt time.Time
	Size        int
	Duration    time.Duration
	Source      string
}

type ExtraStreams interface {
	Lookup(core.RatingKey) (Extra, bool)
	Open(context.Context, core.RatingKey) (container, rawURL string, headers map[string]string, err error)
	Enabled() bool
	List(ctx context.Context, parent *core.Title, lang string) ([]ExtraClip, error)
	Clip(key core.RatingKey) (ExtraClip, bool)
	Resolve(ctx context.Context, e ExtraClip) (ResolvedExtra, error)
	PrewarmBytes() int64
}

type ExtrasSource interface {
	Enabled() bool
	List(context.Context, *core.Title, string) ([]ExtraClip, error)
}

type FacetFilterCatalog interface {
	FacetFilter(ctx context.Context, f Filter, facet string) ([]FacetValue, error)
}

type FacetPager interface {
	FacetPage(ctx context.Context, viewer *Viewer, device Device, viewID, kind string, offset, limit int) ([]FacetValue, int, error)
}

type FacetValue = core.FacetValue

type FailedStartRecorder interface {
	NoteFailedStart(sessionID, reason string)
}

type FamiliarSource interface {
	Familiar(ctx context.Context, userID int64, keys []core.RatingKey) (map[core.RatingKey]int, error)
}

type FavoriteKind string

type FavoriteRef struct {
	Kind FavoriteKind
	ID   string
}

type Filter = core.Filter

type FilterGroup = core.FilterGroup

type Frontend interface {
	Describe() Descriptor
	Mount(context.Context, Host) (Instance, error)
}

type GrantDeviceIdentity interface {
	ResolveGrantDevice(context.Context, string, string) (*Viewer, Device, time.Time, error)
}

type GrantMediaForwarder interface {
	ForwardGrantMedia(w http.ResponseWriter, r *http.Request, id string) bool
}

type GrantedImage struct {
	Image  Image
	Secret string
}

type HLSLadderSession = core.HLSLadderSession

type HLSRequest = core.HLSRequest

type HLSSession = core.HLSSession

type HTTPSession = core.HTTPSession