manager

type APIKeyClaims struct {
	UserID string `json:"uid"`
	jwt.StandardClaims
}

type Action struct {
	// At time in milliseconds the action should fire.
	At int64 `json:"at"`
	// Pos is the place in percent to move to.
	Pos int `json:"pos"`

	Slope     float64
	Intensity int64
	Speed     float64
}

type AutoTagMetadataInput struct {
	// Paths to tag, null for all files
	Paths []string `json:"paths"`
	// IDs of performers to tag files with, or "*" for all
	Performers []string `json:"performers"`
	// IDs of studios to tag files with, or "*" for all
	Studios []string `json:"studios"`
	// IDs of tags to tag files with, or "*" for all
	Tags []string `json:"tags"`
}

type CleanMetadataInput struct {
	Paths []string `json:"paths"`
	// Do a dry run. Don't delete any files
	DryRun bool `json:"dryRun"`
}

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

type ExportObjectTypeInput struct {
	Ids []string `json:"ids"`
	All *bool    `json:"all"`
}

type ExportObjectsInput struct {
	Scenes              *ExportObjectTypeInput `json:"scenes"`
	Images              *ExportObjectTypeInput `json:"images"`
	Studios             *ExportObjectTypeInput `json:"studios"`
	Performers          *ExportObjectTypeInput `json:"performers"`
	Tags                *ExportObjectTypeInput `json:"tags"`
	Movies              *ExportObjectTypeInput `json:"movies"`
	Galleries           *ExportObjectTypeInput `json:"galleries"`
	IncludeDependencies *bool                  `json:"includeDependencies"`
}

type ExportTask struct {
	DownloadHash string
	// contains filtered or unexported fields
}

type FaviconProvider struct {
	UIBox embed.FS
}

type FileReaderWriter interface {
	file.Store
	file.Finder
	Query(ctx context.Context, options models.FileQueryOptions) (*models.FileQueryResult, error)
	GetCaptions(ctx context.Context, fileID file.ID) ([]*models.VideoCaption, error)
	IsPrimary(ctx context.Context, fileID file.ID) (bool, error)
}

type FolderReaderWriter interface {
	file.FolderStore
	Find(ctx context.Context, id file.FolderID) (*file.Folder, error)
}

type GalleryReaderWriter interface {
	models.GalleryReaderWriter
	gallery.FinderCreatorUpdater
	gallery.Finder
	models.FileLoader
	GetManyFileIDs(ctx context.Context, ids []int) ([][]file.ID, error)
}

type GalleryService interface {
	AddImages(ctx context.Context, g *models.Gallery, toAdd ...int) error
	RemoveImages(ctx context.Context, g *models.Gallery, toRemove ...int) error

	Destroy(ctx context.Context, i *models.Gallery, fileDeleter *image.FileDeleter, deleteGenerated, deleteFile bool) ([]*models.Image, error)

	ValidateImageGalleryChange(ctx context.Context, i *models.Image, updateIDs models.UpdateIDs) error
}

type GenerateInteractiveHeatmapSpeedTask struct {
	Scene     models.Scene
	Overwrite bool

	TxnManager Repository
	// contains filtered or unexported fields
}

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

type GenerateMarkersTask struct {
	TxnManager Repository
	Scene      *models.Scene
	Marker     *models.SceneMarker
	Overwrite  bool

	ImagePreview bool
	Screenshot   bool
	// contains filtered or unexported fields
}

type GenerateMetadataInput struct {
	Sprites             *bool                        `json:"sprites"`
	Previews            *bool                        `json:"previews"`
	ImagePreviews       *bool                        `json:"imagePreviews"`
	PreviewOptions      *GeneratePreviewOptionsInput `json:"previewOptions"`
	Markers             *bool                        `json:"markers"`
	MarkerImagePreviews *bool                        `json:"markerImagePreviews"`
	MarkerScreenshots   *bool                        `json:"markerScreenshots"`
	Transcodes          *bool                        `json:"transcodes"`
	// Generate transcodes even if not required
	ForceTranscodes           *bool `json:"forceTranscodes"`
	Phashes                   *bool `json:"phashes"`
	InteractiveHeatmapsSpeeds *bool `json:"interactiveHeatmapsSpeeds"`
	// scene ids to generate for
	SceneIDs []string `json:"sceneIDs"`
	// marker ids to generate for
	MarkerIDs []string `json:"markerIDs"`
	// overwrite existing media
	Overwrite *bool `json:"overwrite"`
}

type GeneratePhashTask struct {
	File      *file.VideoFile
	Overwrite bool
	// contains filtered or unexported fields
}

type GeneratePreviewOptionsInput struct {
	// Number of segments in a preview file
	PreviewSegments *int `json:"previewSegments"`
	// Preview segment duration, in seconds
	PreviewSegmentDuration *float64 `json:"previewSegmentDuration"`
	// Duration of start of video to exclude when generating previews
	PreviewExcludeStart *string `json:"previewExcludeStart"`
	// Duration of end of video to exclude when generating previews
	PreviewExcludeEnd *string `json:"previewExcludeEnd"`
	// Preset when generating preview
	PreviewPreset *models.PreviewPreset `json:"previewPreset"`
}

type GeneratePreviewTask struct {
	Scene        models.Scene
	ImagePreview bool

	Options generate.PreviewOptions

	Overwrite bool
	// contains filtered or unexported fields
}

type GenerateScreenshotTask struct {
	Scene        models.Scene
	ScreenshotAt *float64
	// contains filtered or unexported fields
}

type GenerateSpriteTask struct {
	Scene     models.Scene
	Overwrite bool
	// contains filtered or unexported fields
}

type GenerateTranscodeTask struct {
	Scene     models.Scene
	Overwrite bool

	// is true, generate even if video is browser-supported
	Force bool
	// contains filtered or unexported fields
}

type GradientTable []struct {
	Col colorful.Color
	Pos float64
}

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

type ImageReaderWriter interface {
	models.ImageReaderWriter
	image.FinderCreatorUpdater
	models.ImageFileLoader
	GetManyFileIDs(ctx context.Context, ids []int) ([][]file.ID, error)
}

type ImageService interface {
	Destroy(ctx context.Context, image *models.Image, fileDeleter *image.FileDeleter, deleteGenerated, deleteFile bool) error
	DestroyZipImages(ctx context.Context, zipFile file.File, fileDeleter *image.FileDeleter, deleteGenerated bool) ([]*models.Image, error)
}

type ImportDuplicateEnum string

type ImportObjectsInput struct {
	File                graphql.Upload              `json:"file"`
	DuplicateBehaviour  ImportDuplicateEnum         `json:"duplicateBehaviour"`
	MissingRefBehaviour models.ImportMissingRefEnum `json:"missingRefBehaviour"`
}

type ImportTask struct {
	BaseDir             string
	TmpZip              string
	Reset               bool
	DuplicateBehaviour  ImportDuplicateEnum
	MissingRefBehaviour models.ImportMissingRefEnum
	// contains filtered or unexported fields
}

type InteractiveHeatmapSpeedGenerator struct {
	InteractiveSpeed int
	Funscript        Script
	FunscriptPath    string
	HeatmapPath      string
	Width            int
	Height           int
	NumSegments      int
}

type Manager struct {
	Config *config.Instance
	Logger *log.Logger

	Paths *paths.Paths

	FFMPEG  ffmpeg.FFMpeg
	FFProbe ffmpeg.FFProbe

	ReadLockManager *fsutil.ReadLockManager

	SessionStore *session.Store

	JobManager *job.Manager

	PluginCache  *plugin.Cache
	ScraperCache *scraper.Cache

	DownloadStore *DownloadStore

	DLNAService *dlna.Service

	Database   *sqlite.Database
	Repository Repository

	SceneService   SceneService
	ImageService   ImageService
	GalleryService GalleryService

	Scanner *file.Scanner
	Cleaner *file.Cleaner
	// contains filtered or unexported fields
}

type MigrateHashTask struct {
	Scene *models.Scene
	// contains filtered or unexported fields
}

type MigrateInput struct {
	BackupPath string `json:"backupPath"`
}

type MovieNameFinder interface {
	FindByName(ctx context.Context, name string, nocase bool) (*models.Movie, error)
}

type PerformerNamesFinder interface {
	FindByNames(ctx context.Context, names []string, nocase bool) ([]*models.Performer, error)
}

type Repository struct {
	models.TxnManager

	File        FileReaderWriter
	Folder      FolderReaderWriter
	Gallery     GalleryReaderWriter
	Image       ImageReaderWriter
	Movie       models.MovieReaderWriter
	Performer   models.PerformerReaderWriter
	Scene       SceneReaderWriter
	SceneMarker models.SceneMarkerReaderWriter
	ScrapedItem models.ScrapedItemReaderWriter
	Studio      models.StudioReaderWriter
	Tag         models.TagReaderWriter
	SavedFilter models.SavedFilterReaderWriter
}

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

type ScanMetaDataFilterInput struct {
	// If set, files with a modification time before this time point are ignored by the scan
	MinModTime *time.Time `json:"minModTime"`
}

type ScanMetadataInput struct {
	Paths []string `json:"paths"`

	config.ScanMetadataOptions `mapstructure:",squash"`

	// Filter options for the scan
	Filter *ScanMetaDataFilterInput `json:"filter"`
}

type SceneCoverGetter interface {
	GetCover(ctx context.Context, sceneID int) ([]byte, error)
}

type SceneFilenameParser struct {
	Pattern     string
	ParserInput SceneParserInput
	Filter      *models.FindFilterType
	// contains filtered or unexported fields
}

type SceneFilenameParserRepository struct {
	Scene     scene.Queryer
	Performer PerformerNamesFinder
	Studio    studio.Queryer
	Movie     MovieNameFinder
	Tag       tag.Queryer
}

type SceneMissingHashCounter interface {
	CountMissingChecksum(ctx context.Context) (int, error)
	CountMissingOSHash(ctx context.Context) (int, error)
}

type SceneMovieID struct {
	MovieID    string  `json:"movie_id"`
	SceneIndex *string `json:"scene_index"`
}

type SceneParserInput struct {
	IgnoreWords          []string `json:"ignoreWords"`
	WhitespaceCharacters *string  `json:"whitespaceCharacters"`
	CapitalizeTitle      *bool    `json:"capitalizeTitle"`
	IgnoreOrganized      *bool    `json:"ignoreOrganized"`
}

type SceneParserResult struct {
	Scene        *models.Scene   `json:"scene"`
	Title        *string         `json:"title"`
	Details      *string         `json:"details"`
	URL          *string         `json:"url"`
	Date         *string         `json:"date"`
	Rating       *int            `json:"rating"`
	StudioID     *string         `json:"studio_id"`
	GalleryIds   []string        `json:"gallery_ids"`
	PerformerIds []string        `json:"performer_ids"`
	Movies       []*SceneMovieID `json:"movies"`
	TagIds       []string        `json:"tag_ids"`
}

type SceneReaderWriter interface {
	models.SceneReaderWriter
	scene.CreatorUpdater
	GetManyFileIDs(ctx context.Context, ids []int) ([][]file.ID, error)
}

type SceneServer struct {
	TxnManager       txn.Manager
	SceneCoverGetter SceneCoverGetter
}

type SceneService interface {
	Destroy(ctx context.Context, scene *models.Scene, fileDeleter *scene.FileDeleter, deleteGenerated, deleteFile bool) error
}

type SceneStreamEndpoint struct {
	URL      string  `json:"url"`
	MimeType *string `json:"mime_type"`
	Label    *string `json:"label"`
}

type Script struct {
	// Version of Launchscript
	Version string `json:"version"`
	// Inverted causes up and down movement to be flipped.
	Inverted bool `json:"inverted,omitempty"`
	// Range is the percentage of a full stroke to use.
	Range int `json:"range,omitempty"`
	// Actions are the timed moves.
	Actions      []Action `json:"actions"`
	AvarageSpeed int64
}

type SetupInput struct {
	// Empty to indicate $HOME/.stash/config.yml default
	ConfigLocation string                     `json:"configLocation"`
	Stashes        []*config.StashConfigInput `json:"stashes"`
	// Empty to indicate default
	DatabaseFile string `json:"databaseFile"`
	// Empty to indicate default
	GeneratedLocation string `json:"generatedLocation"`
}

type SpriteGenerator struct {
	Info *generatorInfo

	VideoChecksum   string
	ImageOutputPath string
	VTTOutputPath   string
	Rows            int
	Columns         int
	SlowSeek        bool // use alternate seek function, very slow!

	Overwrite bool
	// contains filtered or unexported fields
}

type StashBoxBatchPerformerTagInput struct {
	// Stash endpoint to use for the performer tagging
	Endpoint int `json:"endpoint"`
	// Fields to exclude when executing the performer tagging
	ExcludeFields []string `json:"exclude_fields"`
	// Refresh performers already tagged by StashBox if true. Only tag performers with no StashBox tagging if false
	Refresh bool `json:"refresh"`
	// If set, only tag these performer ids
	PerformerIds []string `json:"performer_ids"`
	// If set, only tag these performer names
	PerformerNames []string `json:"performer_names"`
}

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

type StreamRequestContext struct {
	context.Context
	ResponseWriter http.ResponseWriter
}

type SystemStatus struct {
	DatabaseSchema *int             `json:"databaseSchema"`
	DatabasePath   *string          `json:"databasePath"`
	ConfigPath     *string          `json:"configPath"`
	AppSchema      int              `json:"appSchema"`
	Status         SystemStatusEnum `json:"status"`
}

type SystemStatusEnum string

type Task interface {
	Start(context.Context)
	GetDescription() string
}