tsarr 2.6.0 → 2.7.0

package/dist/generated/seerr/types.gen.d.ts

@@ -0,0 +1,4867 @@
+export type ClientOptions = {
+    baseUrl: `${string}://{server}/api/v1` | (string & {});
+};
+export type Blocklist = {
+    tmdbId?: number;
+    title?: string;
+    media?: MediaInfo;
+    userId?: number;
+};
+export type Watchlist = {
+    readonly id?: number;
+    tmdbId?: number;
+    ratingKey?: string;
+    type?: string;
+    title?: string;
+    media?: MediaInfo;
+    readonly createdAt?: string;
+    readonly updatedAt?: string;
+    requestedBy?: User;
+};
+export type User = {
+    readonly id: number;
+    readonly email: string;
+    username?: string;
+    readonly plexUsername?: string;
+    readonly plexToken?: string;
+    readonly jellyfinAuthToken?: string;
+    readonly userType?: number;
+    permissions?: number;
+    readonly avatar?: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly requestCount?: number;
+};
+export type UserSettings = {
+    username?: string | null;
+    email?: string;
+    discordId?: string | null;
+    locale?: string | null;
+    discoverRegion?: string | null;
+    streamingRegion?: string | null;
+    originalLanguage?: string | null;
+    /**
+     * Maximum number of movie requests allowed
+     */
+    movieQuotaLimit?: number | null;
+    /**
+     * Time period in days for movie quota
+     */
+    movieQuotaDays?: number | null;
+    /**
+     * Maximum number of TV requests allowed
+     */
+    tvQuotaLimit?: number | null;
+    /**
+     * Time period in days for TV quota
+     */
+    tvQuotaDays?: number | null;
+    /**
+     * Global movie quota days setting
+     */
+    globalMovieQuotaDays?: number | null;
+    /**
+     * Global movie quota limit setting
+     */
+    globalMovieQuotaLimit?: number | null;
+    /**
+     * Global TV quota limit setting
+     */
+    globalTvQuotaLimit?: number | null;
+    /**
+     * Global TV quota days setting
+     */
+    globalTvQuotaDays?: number | null;
+    /**
+     * Enable watchlist sync for movies
+     */
+    watchlistSyncMovies?: boolean | null;
+    /**
+     * Enable watchlist sync for TV
+     */
+    watchlistSyncTv?: boolean | null;
+};
+export type MainSettings = {
+    readonly apiKey?: string;
+    appLanguage?: string;
+    applicationTitle?: string;
+    applicationUrl?: string;
+    hideAvailable?: boolean;
+    partialRequestsEnabled?: boolean;
+    localLogin?: boolean;
+    mediaServerType?: number;
+    newPlexLogin?: boolean;
+    defaultPermissions?: number;
+    enableSpecialEpisodes?: boolean;
+};
+export type NetworkSettings = {
+    csrfProtection?: boolean;
+    forceIpv4First?: boolean;
+    trustProxy?: boolean;
+    proxy?: {
+        enabled?: boolean;
+        hostname?: string;
+        port?: number;
+        useSsl?: boolean;
+        user?: string;
+        password?: string;
+        bypassFilter?: string;
+        bypassLocalAddresses?: boolean;
+    };
+    dnsCache?: {
+        enabled?: boolean;
+        forceMinTtl?: number;
+        forceMaxTtl?: number;
+    };
+};
+export type PlexLibrary = {
+    id: string;
+    name: string;
+    enabled: boolean;
+};
+export type PlexSettings = {
+    readonly name: string;
+    readonly machineId: string;
+    ip: string;
+    port: number;
+    useSsl?: boolean | null;
+    readonly libraries?: Array<PlexLibrary>;
+    webAppUrl?: string | null;
+};
+export type PlexConnection = {
+    protocol: string;
+    address: string;
+    port: number;
+    uri: string;
+    local: boolean;
+    status?: number;
+    message?: string;
+};
+export type PlexDevice = {
+    name: string;
+    product: string;
+    productVersion: string;
+    platform: string;
+    platformVersion?: string;
+    device: string;
+    clientIdentifier: string;
+    createdAt: string;
+    lastSeenAt: string;
+    provides: Array<string>;
+    owned: boolean;
+    ownerID?: string;
+    home?: boolean;
+    sourceTitle?: string;
+    accessToken?: string;
+    publicAddress?: string;
+    httpsRequired?: boolean;
+    synced?: boolean;
+    relay?: boolean;
+    dnsRebindingProtection?: boolean;
+    natLoopbackSupported?: boolean;
+    publicAddressMatches?: boolean;
+    presence?: boolean;
+    connection: Array<PlexConnection>;
+};
+export type JellyfinLibrary = {
+    id: string;
+    name: string;
+    enabled: boolean;
+};
+export type JellyfinSettings = {
+    readonly name?: string;
+    hostname?: string;
+    externalHostname?: string;
+    jellyfinForgotPasswordUrl?: string;
+    adminUser?: string;
+    adminPass?: string;
+    readonly libraries?: Array<JellyfinLibrary>;
+    readonly serverID?: string;
+};
+export type MetadataSettings = {
+    settings?: {
+        tv?: 'tvdb' | 'tmdb';
+        anime?: 'tvdb' | 'tmdb';
+    };
+};
+export type TautulliSettings = {
+    hostname?: string | null;
+    port?: number | null;
+    useSsl?: boolean | null;
+    apiKey?: string | null;
+    externalUrl?: string | null;
+};
+export type RadarrSettings = {
+    readonly id?: number;
+    name: string;
+    hostname: string;
+    port: number;
+    apiKey: string;
+    useSsl: boolean;
+    baseUrl?: string;
+    activeProfileId: number;
+    activeProfileName: string;
+    activeDirectory: string;
+    is4k: boolean;
+    minimumAvailability: string;
+    isDefault: boolean;
+    externalUrl?: string;
+    syncEnabled?: boolean;
+    preventSearch?: boolean;
+};
+export type SonarrSettings = {
+    readonly id?: number;
+    name: string;
+    hostname: string;
+    port: number;
+    apiKey: string;
+    useSsl: boolean;
+    baseUrl?: string;
+    activeProfileId: number;
+    activeProfileName: string;
+    activeDirectory: string;
+    activeLanguageProfileId?: number;
+    activeAnimeProfileId?: number | null;
+    activeAnimeLanguageProfileId?: number | null;
+    activeAnimeProfileName?: string | null;
+    activeAnimeDirectory?: string | null;
+    is4k: boolean;
+    enableSeasonFolders: boolean;
+    isDefault: boolean;
+    externalUrl?: string;
+    syncEnabled?: boolean;
+    preventSearch?: boolean;
+};
+export type ServarrTag = {
+    id?: number;
+    label?: string;
+};
+export type PublicSettings = {
+    initialized?: boolean;
+};
+export type MovieResult = {
+    id: number;
+    mediaType: string;
+    popularity?: number;
+    posterPath?: string;
+    backdropPath?: string;
+    voteCount?: number;
+    voteAverage?: number;
+    genreIds?: Array<number>;
+    overview?: string;
+    originalLanguage?: string;
+    title: string;
+    originalTitle?: string;
+    releaseDate?: string;
+    adult?: boolean;
+    video?: boolean;
+    mediaInfo?: MediaInfo;
+};
+export type TvResult = {
+    id?: number;
+    mediaType?: string;
+    popularity?: number;
+    posterPath?: string;
+    backdropPath?: string;
+    voteCount?: number;
+    voteAverage?: number;
+    genreIds?: Array<number>;
+    overview?: string;
+    originalLanguage?: string;
+    name?: string;
+    originalName?: string;
+    originCountry?: Array<string>;
+    firstAirDate?: string;
+    mediaInfo?: MediaInfo;
+};
+export type PersonResult = {
+    id?: number;
+    profilePath?: string;
+    adult?: boolean;
+    mediaType?: string;
+    knownFor?: Array<MovieResult | TvResult>;
+};
+export type Genre = {
+    id?: number;
+    name?: string;
+};
+export type Company = {
+    id?: number;
+    logo_path?: string | null;
+    name?: string;
+};
+export type ProductionCompany = {
+    id?: number;
+    logoPath?: string | null;
+    originCountry?: string;
+    name?: string;
+};
+export type Network = {
+    id?: number;
+    logoPath?: string | null;
+    originCountry?: string;
+    name?: string;
+};
+export type RelatedVideo = {
+    url?: string;
+    key?: string;
+    name?: string;
+    size?: number;
+    type?: 'Clip' | 'Teaser' | 'Trailer' | 'Featurette' | 'Opening Credits' | 'Behind the Scenes' | 'Bloopers';
+    site?: 'YouTube';
+};
+export type MovieDetails = {
+    readonly id?: number;
+    imdbId?: string;
+    adult?: boolean;
+    backdropPath?: string;
+    posterPath?: string;
+    budget?: number;
+    genres?: Array<Genre>;
+    homepage?: string;
+    relatedVideos?: Array<RelatedVideo>;
+    originalLanguage?: string;
+    originalTitle?: string;
+    overview?: string;
+    popularity?: number;
+    productionCompanies?: Array<ProductionCompany>;
+    productionCountries?: Array<{
+        iso_3166_1?: string;
+        name?: string;
+    }>;
+    releaseDate?: string;
+    releases?: {
+        results?: Array<{
+            iso_3166_1?: string;
+            rating?: string | null;
+            release_dates?: Array<{
+                certification?: string;
+                iso_639_1?: string | null;
+                note?: string | null;
+                release_date?: string;
+                type?: number;
+            }>;
+        }>;
+    };
+    revenue?: number | null;
+    runtime?: number;
+    spokenLanguages?: Array<SpokenLanguage>;
+    status?: string;
+    tagline?: string;
+    title?: string;
+    video?: boolean;
+    voteAverage?: number;
+    voteCount?: number;
+    credits?: {
+        cast?: Array<Cast>;
+        crew?: Array<Crew>;
+    };
+    collection?: {
+        id?: number;
+        name?: string;
+        posterPath?: string;
+        backdropPath?: string;
+    };
+    externalIds?: ExternalIds;
+    mediaInfo?: MediaInfo;
+    watchProviders?: Array<WatchProviders>;
+};
+export type Episode = {
+    id?: number;
+    name?: string;
+    airDate?: string | null;
+    episodeNumber?: number;
+    overview?: string;
+    productionCode?: string;
+    seasonNumber?: number;
+    showId?: number;
+    stillPath?: string | null;
+    voteAverage?: number;
+    voteCount?: number;
+};
+export type Season = {
+    id?: number;
+    airDate?: string | null;
+    episodeCount?: number;
+    name?: string;
+    overview?: string;
+    posterPath?: string;
+    seasonNumber?: number;
+    episodes?: Array<Episode>;
+};
+export type TvDetails = {
+    id?: number;
+    backdropPath?: string;
+    posterPath?: string;
+    contentRatings?: {
+        results?: Array<{
+            iso_3166_1?: string;
+            rating?: string;
+        }>;
+    };
+    createdBy?: Array<{
+        id?: number;
+        name?: string;
+        gender?: number;
+        profilePath?: string | null;
+    }>;
+    episodeRunTime?: Array<number>;
+    firstAirDate?: string;
+    genres?: Array<Genre>;
+    homepage?: string;
+    inProduction?: boolean;
+    languages?: Array<string>;
+    lastAirDate?: string;
+    lastEpisodeToAir?: Episode;
+    name?: string;
+    nextEpisodeToAir?: Episode;
+    networks?: Array<ProductionCompany>;
+    numberOfEpisodes?: number;
+    numberOfSeason?: number;
+    originCountry?: Array<string>;
+    originalLanguage?: string;
+    originalName?: string;
+    overview?: string;
+    popularity?: number;
+    productionCompanies?: Array<ProductionCompany>;
+    productionCountries?: Array<{
+        iso_3166_1?: string;
+        name?: string;
+    }>;
+    spokenLanguages?: Array<SpokenLanguage>;
+    seasons?: Array<Season>;
+    status?: string;
+    tagline?: string;
+    type?: string;
+    voteAverage?: number;
+    voteCount?: number;
+    credits?: {
+        cast?: Array<Cast>;
+        crew?: Array<Crew>;
+    };
+    externalIds?: ExternalIds;
+    keywords?: Array<Keyword>;
+    mediaInfo?: MediaInfo;
+    watchProviders?: Array<WatchProviders>;
+};
+export type MediaRequest = {
+    readonly id: number;
+    /**
+     * Status of the request. 1 = PENDING APPROVAL, 2 = APPROVED, 3 = DECLINED
+     */
+    readonly status: number;
+    media?: MediaInfo;
+    readonly createdAt?: string;
+    readonly updatedAt?: string;
+    requestedBy?: User;
+    modifiedBy?: User | string | null;
+    is4k?: boolean;
+    serverId?: number;
+    profileId?: number;
+    rootFolder?: string;
+};
+export type MediaInfo = {
+    readonly id?: number;
+    readonly tmdbId?: number;
+    readonly tvdbId?: number | null;
+    /**
+     * Availability of the media. 1 = `UNKNOWN`, 2 = `PENDING`, 3 = `PROCESSING`, 4 = `PARTIALLY_AVAILABLE`, 5 = `AVAILABLE`, 6 = `DELETED`
+     */
+    status?: number;
+    readonly requests?: Array<MediaRequest>;
+    readonly createdAt?: string;
+    readonly updatedAt?: string;
+};
+export type Cast = {
+    id?: number;
+    castId?: number;
+    character?: string;
+    creditId?: string;
+    gender?: number;
+    name?: string;
+    order?: number;
+    profilePath?: string | null;
+};
+export type Crew = {
+    id?: number;
+    creditId?: string;
+    gender?: number;
+    name?: string;
+    job?: string;
+    department?: string;
+    profilePath?: string | null;
+};
+export type ExternalIds = {
+    facebookId?: string | null;
+    freebaseId?: string | null;
+    freebaseMid?: string | null;
+    imdbId?: string | null;
+    instagramId?: string | null;
+    tvdbId?: number | null;
+    tvrageId?: number | null;
+    twitterId?: string | null;
+};
+export type ServiceProfile = {
+    id?: number;
+    name?: string;
+};
+export type PageInfo = {
+    page?: number;
+    pages?: number;
+    results?: number;
+};
+export type DiscordSettings = {
+    enabled?: boolean;
+    types?: number;
+    options?: {
+        botUsername?: string;
+        botAvatarUrl?: string;
+        webhookUrl?: string;
+        webhookRoleId?: string;
+        enableMentions?: boolean;
+    };
+};
+export type SlackSettings = {
+    enabled?: boolean;
+    types?: number;
+    options?: {
+        webhookUrl?: string;
+    };
+};
+export type WebPushSettings = {
+    enabled?: boolean;
+    types?: number;
+};
+export type WebhookSettings = {
+    enabled?: boolean;
+    types?: number;
+    options?: {
+        webhookUrl?: string;
+        authHeader?: string;
+        jsonPayload?: string;
+        supportVariables?: boolean;
+    };
+};
+export type TelegramSettings = {
+    enabled?: boolean;
+    types?: number;
+    options?: {
+        botUsername?: string;
+        botAPI?: string;
+        chatId?: string;
+        messageThreadId?: string;
+        sendSilently?: boolean;
+    };
+};
+export type PushbulletSettings = {
+    enabled?: boolean;
+    types?: number;
+    options?: {
+        accessToken?: string;
+        channelTag?: string | null;
+    };
+};
+export type PushoverSettings = {
+    enabled?: boolean;
+    types?: number;
+    options?: {
+        accessToken?: string;
+        userToken?: string;
+        sound?: string;
+    };
+};
+export type GotifySettings = {
+    enabled?: boolean;
+    types?: number;
+    options?: {
+        url?: string;
+        token?: string;
+    };
+};
+export type NtfySettings = {
+    enabled?: boolean;
+    types?: number;
+    options?: {
+        url?: string;
+        topic?: string;
+        authMethodUsernamePassword?: boolean;
+        username?: string;
+        password?: string;
+        authMethodToken?: boolean;
+        token?: string;
+    };
+};
+export type NotificationEmailSettings = {
+    enabled?: boolean;
+    types?: number;
+    options?: {
+        emailFrom?: string;
+        senderName?: string;
+        smtpHost?: string;
+        smtpPort?: number;
+        secure?: boolean;
+        ignoreTls?: boolean;
+        requireTls?: boolean;
+        authUser?: string | null;
+        authPass?: string | null;
+        allowSelfSigned?: boolean;
+    };
+};
+export type Job = {
+    id?: string;
+    type?: 'process' | 'command';
+    interval?: 'short' | 'long' | 'fixed';
+    name?: string;
+    nextExecutionTime?: string;
+    running?: boolean;
+};
+export type PersonDetails = {
+    id?: number;
+    name?: string;
+    deathday?: string;
+    knownForDepartment?: string;
+    alsoKnownAs?: Array<string>;
+    gender?: string;
+    biography?: string;
+    popularity?: string;
+    placeOfBirth?: string;
+    profilePath?: string;
+    adult?: boolean;
+    imdbId?: string;
+    homepage?: string;
+};
+export type CreditCast = {
+    id?: number;
+    originalLanguage?: string;
+    episodeCount?: number;
+    overview?: string;
+    originCountry?: Array<string>;
+    originalName?: string;
+    voteCount?: number;
+    name?: string;
+    mediaType?: string;
+    popularity?: number;
+    creditId?: string;
+    backdropPath?: string;
+    firstAirDate?: string;
+    voteAverage?: number;
+    genreIds?: Array<number>;
+    posterPath?: string;
+    originalTitle?: string;
+    video?: boolean;
+    title?: string;
+    adult?: boolean;
+    releaseDate?: string;
+    character?: string;
+    mediaInfo?: MediaInfo;
+};
+export type CreditCrew = {
+    id?: number;
+    originalLanguage?: string;
+    episodeCount?: number;
+    overview?: string;
+    originCountry?: Array<string>;
+    originalName?: string;
+    voteCount?: number;
+    name?: string;
+    mediaType?: string;
+    popularity?: number;
+    creditId?: string;
+    backdropPath?: string;
+    firstAirDate?: string;
+    voteAverage?: number;
+    genreIds?: Array<number>;
+    posterPath?: string;
+    originalTitle?: string;
+    video?: boolean;
+    title?: string;
+    adult?: boolean;
+    releaseDate?: string;
+    department?: string;
+    job?: string;
+    mediaInfo?: MediaInfo;
+};
+export type Keyword = {
+    id?: number;
+    name?: string;
+};
+export type SpokenLanguage = {
+    englishName?: string | null;
+    iso_639_1?: string;
+    name?: string;
+};
+export type Collection = {
+    id?: number;
+    name?: string;
+    overview?: string;
+    posterPath?: string;
+    backdropPath?: string;
+    parts?: Array<MovieResult>;
+};
+export type SonarrSeries = {
+    title?: string;
+    sortTitle?: string;
+    seasonCount?: number;
+    status?: string;
+    overview?: string;
+    network?: string;
+    airTime?: string;
+    images?: Array<{
+        coverType?: string;
+        url?: string;
+    }>;
+    remotePoster?: string;
+    seasons?: Array<{
+        seasonNumber?: number;
+        monitored?: boolean;
+    }>;
+    year?: number;
+    path?: string;
+    profileId?: number;
+    languageProfileId?: number;
+    seasonFolder?: boolean;
+    monitored?: boolean;
+    useSceneNumbering?: boolean;
+    runtime?: number;
+    tvdbId?: number;
+    tvRageId?: number;
+    tvMazeId?: number;
+    firstAired?: string;
+    lastInfoSync?: string | null;
+    seriesType?: string;
+    cleanTitle?: string;
+    imdbId?: string;
+    titleSlug?: string;
+    certification?: string;
+    genres?: Array<string>;
+    tags?: Array<string>;
+    added?: string;
+    ratings?: Array<{
+        votes?: number;
+        value?: number;
+    }>;
+    qualityProfileId?: number;
+    id?: number | null;
+    rootFolderPath?: string | null;
+    addOptions?: Array<{
+        ignoreEpisodesWithFiles?: boolean | null;
+        ignoreEpisodesWithoutFiles?: boolean | null;
+        searchForMissingEpisodes?: boolean | null;
+    }>;
+};
+export type UserSettingsNotifications = {
+    notificationTypes?: NotificationAgentTypes;
+    emailEnabled?: boolean;
+    pgpKey?: string | null;
+    discordEnabled?: boolean;
+    discordEnabledTypes?: number | null;
+    discordId?: string | null;
+    pushbulletAccessToken?: string | null;
+    pushoverApplicationToken?: string | null;
+    pushoverUserKey?: string | null;
+    pushoverSound?: string | null;
+    telegramEnabled?: boolean;
+    telegramBotUsername?: string | null;
+    telegramChatId?: string | null;
+    telegramMessageThreadId?: string | null;
+    telegramSendSilently?: boolean | null;
+};
+export type NotificationAgentTypes = {
+    discord?: number;
+    email?: number;
+    pushbullet?: number;
+    pushover?: number;
+    slack?: number;
+    telegram?: number;
+    webhook?: number;
+    webpush?: number;
+};
+export type WatchProviders = Array<{
+    iso_3166_1?: string;
+    link?: string;
+    buy?: Array<WatchProviderDetails>;
+    flatrate?: unknown;
+}>;
+export type WatchProviderDetails = {
+    displayPriority?: number;
+    logoPath?: string;
+    id?: number;
+    name?: string;
+};
+export type Issue = {
+    id?: number;
+    issueType?: number;
+    media?: MediaInfo;
+    createdBy?: User;
+    modifiedBy?: User;
+    comments?: Array<IssueComment>;
+};
+export type IssueComment = {
+    id?: number;
+    user?: User;
+    message?: string;
+};
+export type DiscoverSlider = {
+    id?: number;
+    type: number;
+    title: string | null;
+    isBuiltIn?: boolean;
+    enabled: boolean;
+    data: string | null;
+};
+export type WatchProviderRegion = {
+    iso_3166_1?: string;
+    english_name?: string;
+    native_name?: string;
+};
+export type OverrideRule = {
+    id?: string;
+};
+export type Certification = {
+    certification: string;
+    meaning?: string | null;
+    order?: number | null;
+};
+export type CertificationResponse = {
+    certifications?: {
+        [key: string]: Array<Certification>;
+    };
+};
+export type BlocklistWritable = {
+    tmdbId?: number;
+    title?: string;
+    media?: MediaInfoWritable;
+    userId?: number;
+};
+export type WatchlistWritable = {
+    tmdbId?: number;
+    ratingKey?: string;
+    type?: string;
+    title?: string;
+    media?: MediaInfoWritable;
+    requestedBy?: UserWritable;
+};
+export type UserWritable = {
+    username?: string;
+    permissions?: number;
+};
+export type MainSettingsWritable = {
+    appLanguage?: string;
+    applicationTitle?: string;
+    applicationUrl?: string;
+    hideAvailable?: boolean;
+    partialRequestsEnabled?: boolean;
+    localLogin?: boolean;
+    mediaServerType?: number;
+    newPlexLogin?: boolean;
+    defaultPermissions?: number;
+    enableSpecialEpisodes?: boolean;
+};
+export type PlexSettingsWritable = {
+    ip: string;
+    port: number;
+    useSsl?: boolean | null;
+    webAppUrl?: string | null;
+};
+export type JellyfinSettingsWritable = {
+    hostname?: string;
+    externalHostname?: string;
+    jellyfinForgotPasswordUrl?: string;
+    adminUser?: string;
+    adminPass?: string;
+};
+export type RadarrSettingsWritable = {
+    name: string;
+    hostname: string;
+    port: number;
+    apiKey: string;
+    useSsl: boolean;
+    baseUrl?: string;
+    activeProfileId: number;
+    activeProfileName: string;
+    activeDirectory: string;
+    is4k: boolean;
+    minimumAvailability: string;
+    isDefault: boolean;
+    externalUrl?: string;
+    syncEnabled?: boolean;
+    preventSearch?: boolean;
+};
+export type SonarrSettingsWritable = {
+    name: string;
+    hostname: string;
+    port: number;
+    apiKey: string;
+    useSsl: boolean;
+    baseUrl?: string;
+    activeProfileId: number;
+    activeProfileName: string;
+    activeDirectory: string;
+    activeLanguageProfileId?: number;
+    activeAnimeProfileId?: number | null;
+    activeAnimeLanguageProfileId?: number | null;
+    activeAnimeProfileName?: string | null;
+    activeAnimeDirectory?: string | null;
+    is4k: boolean;
+    enableSeasonFolders: boolean;
+    isDefault: boolean;
+    externalUrl?: string;
+    syncEnabled?: boolean;
+    preventSearch?: boolean;
+};
+export type MovieResultWritable = {
+    id: number;
+    mediaType: string;
+    popularity?: number;
+    posterPath?: string;
+    backdropPath?: string;
+    voteCount?: number;
+    voteAverage?: number;
+    genreIds?: Array<number>;
+    overview?: string;
+    originalLanguage?: string;
+    title: string;
+    originalTitle?: string;
+    releaseDate?: string;
+    adult?: boolean;
+    video?: boolean;
+    mediaInfo?: MediaInfoWritable;
+};
+export type TvResultWritable = {
+    id?: number;
+    mediaType?: string;
+    popularity?: number;
+    posterPath?: string;
+    backdropPath?: string;
+    voteCount?: number;
+    voteAverage?: number;
+    genreIds?: Array<number>;
+    overview?: string;
+    originalLanguage?: string;
+    name?: string;
+    originalName?: string;
+    originCountry?: Array<string>;
+    firstAirDate?: string;
+    mediaInfo?: MediaInfoWritable;
+};
+export type PersonResultWritable = {
+    id?: number;
+    profilePath?: string;
+    adult?: boolean;
+    mediaType?: string;
+    knownFor?: Array<MovieResultWritable | TvResultWritable>;
+};
+export type MovieDetailsWritable = {
+    imdbId?: string;
+    adult?: boolean;
+    backdropPath?: string;
+    posterPath?: string;
+    budget?: number;
+    genres?: Array<Genre>;
+    homepage?: string;
+    relatedVideos?: Array<RelatedVideo>;
+    originalLanguage?: string;
+    originalTitle?: string;
+    overview?: string;
+    popularity?: number;
+    productionCompanies?: Array<ProductionCompany>;
+    productionCountries?: Array<{
+        iso_3166_1?: string;
+        name?: string;
+    }>;
+    releaseDate?: string;
+    releases?: {
+        results?: Array<{
+            iso_3166_1?: string;
+            rating?: string | null;
+            release_dates?: Array<{
+                certification?: string;
+                iso_639_1?: string | null;
+                note?: string | null;
+                release_date?: string;
+                type?: number;
+            }>;
+        }>;
+    };
+    revenue?: number | null;
+    runtime?: number;
+    spokenLanguages?: Array<SpokenLanguage>;
+    status?: string;
+    tagline?: string;
+    title?: string;
+    video?: boolean;
+    voteAverage?: number;
+    voteCount?: number;
+    credits?: {
+        cast?: Array<Cast>;
+        crew?: Array<Crew>;
+    };
+    collection?: {
+        id?: number;
+        name?: string;
+        posterPath?: string;
+        backdropPath?: string;
+    };
+    externalIds?: ExternalIds;
+    mediaInfo?: MediaInfoWritable;
+    watchProviders?: Array<WatchProviders>;
+};
+export type TvDetailsWritable = {
+    id?: number;
+    backdropPath?: string;
+    posterPath?: string;
+    contentRatings?: {
+        results?: Array<{
+            iso_3166_1?: string;
+            rating?: string;
+        }>;
+    };
+    createdBy?: Array<{
+        id?: number;
+        name?: string;
+        gender?: number;
+        profilePath?: string | null;
+    }>;
+    episodeRunTime?: Array<number>;
+    firstAirDate?: string;
+    genres?: Array<Genre>;
+    homepage?: string;
+    inProduction?: boolean;
+    languages?: Array<string>;
+    lastAirDate?: string;
+    lastEpisodeToAir?: Episode;
+    name?: string;
+    nextEpisodeToAir?: Episode;
+    networks?: Array<ProductionCompany>;
+    numberOfEpisodes?: number;
+    numberOfSeason?: number;
+    originCountry?: Array<string>;
+    originalLanguage?: string;
+    originalName?: string;
+    overview?: string;
+    popularity?: number;
+    productionCompanies?: Array<ProductionCompany>;
+    productionCountries?: Array<{
+        iso_3166_1?: string;
+        name?: string;
+    }>;
+    spokenLanguages?: Array<SpokenLanguage>;
+    seasons?: Array<Season>;
+    status?: string;
+    tagline?: string;
+    type?: string;
+    voteAverage?: number;
+    voteCount?: number;
+    credits?: {
+        cast?: Array<Cast>;
+        crew?: Array<Crew>;
+    };
+    externalIds?: ExternalIds;
+    keywords?: Array<Keyword>;
+    mediaInfo?: MediaInfoWritable;
+    watchProviders?: Array<WatchProviders>;
+};
+export type MediaRequestWritable = {
+    media?: MediaInfoWritable;
+    requestedBy?: UserWritable;
+    modifiedBy?: UserWritable | string | null;
+    is4k?: boolean;
+    serverId?: number;
+    profileId?: number;
+    rootFolder?: string;
+};
+export type MediaInfoWritable = {
+    /**
+     * Availability of the media. 1 = `UNKNOWN`, 2 = `PENDING`, 3 = `PROCESSING`, 4 = `PARTIALLY_AVAILABLE`, 5 = `AVAILABLE`, 6 = `DELETED`
+     */
+    status?: number;
+};
+export type CreditCastWritable = {
+    id?: number;
+    originalLanguage?: string;
+    episodeCount?: number;
+    overview?: string;
+    originCountry?: Array<string>;
+    originalName?: string;
+    voteCount?: number;
+    name?: string;
+    mediaType?: string;
+    popularity?: number;
+    creditId?: string;
+    backdropPath?: string;
+    firstAirDate?: string;
+    voteAverage?: number;
+    genreIds?: Array<number>;
+    posterPath?: string;
+    originalTitle?: string;
+    video?: boolean;
+    title?: string;
+    adult?: boolean;
+    releaseDate?: string;
+    character?: string;
+    mediaInfo?: MediaInfoWritable;
+};
+export type CreditCrewWritable = {
+    id?: number;
+    originalLanguage?: string;
+    episodeCount?: number;
+    overview?: string;
+    originCountry?: Array<string>;
+    originalName?: string;
+    voteCount?: number;
+    name?: string;
+    mediaType?: string;
+    popularity?: number;
+    creditId?: string;
+    backdropPath?: string;
+    firstAirDate?: string;
+    voteAverage?: number;
+    genreIds?: Array<number>;
+    posterPath?: string;
+    originalTitle?: string;
+    video?: boolean;
+    title?: string;
+    adult?: boolean;
+    releaseDate?: string;
+    department?: string;
+    job?: string;
+    mediaInfo?: MediaInfoWritable;
+};
+export type CollectionWritable = {
+    id?: number;
+    name?: string;
+    overview?: string;
+    posterPath?: string;
+    backdropPath?: string;
+    parts?: Array<MovieResultWritable>;
+};
+export type IssueWritable = {
+    id?: number;
+    issueType?: number;
+    media?: MediaInfoWritable;
+    createdBy?: UserWritable;
+    modifiedBy?: UserWritable;
+    comments?: Array<IssueCommentWritable>;
+};
+export type IssueCommentWritable = {
+    id?: number;
+    user?: UserWritable;
+    message?: string;
+};
+export type GetStatusData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/status';
+};
+export type GetStatusResponses = {
+    /**
+     * Returned status
+     */
+    200: {
+        version?: string;
+        commitTag?: string;
+        updateAvailable?: boolean;
+        commitsBehind?: number;
+        restartRequired?: boolean;
+    };
+};
+export type GetStatusResponse = GetStatusResponses[keyof GetStatusResponses];
+export type GetStatusAppdataData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/status/appdata';
+};
+export type GetStatusAppdataResponses = {
+    /**
+     * Application data volume status and path
+     */
+    200: {
+        appData?: boolean;
+        appDataPath?: string;
+        appDataPermissions?: boolean;
+    };
+};
+export type GetStatusAppdataResponse = GetStatusAppdataResponses[keyof GetStatusAppdataResponses];
+export type GetSettingsMainData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/main';
+};
+export type GetSettingsMainResponses = {
+    /**
+     * OK
+     */
+    200: MainSettings;
+};
+export type GetSettingsMainResponse = GetSettingsMainResponses[keyof GetSettingsMainResponses];
+export type PostSettingsMainData = {
+    body: MainSettingsWritable;
+    path?: never;
+    query?: never;
+    url: '/settings/main';
+};
+export type PostSettingsMainResponses = {
+    /**
+     * Values were sucessfully updated
+     */
+    200: MainSettings;
+};
+export type PostSettingsMainResponse = PostSettingsMainResponses[keyof PostSettingsMainResponses];
+export type GetSettingsNetworkData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/network';
+};
+export type GetSettingsNetworkResponses = {
+    /**
+     * OK
+     */
+    200: MainSettings;
+};
+export type GetSettingsNetworkResponse = GetSettingsNetworkResponses[keyof GetSettingsNetworkResponses];
+export type PostSettingsNetworkData = {
+    body: NetworkSettings;
+    path?: never;
+    query?: never;
+    url: '/settings/network';
+};
+export type PostSettingsNetworkResponses = {
+    /**
+     * Values were sucessfully updated
+     */
+    200: NetworkSettings;
+};
+export type PostSettingsNetworkResponse = PostSettingsNetworkResponses[keyof PostSettingsNetworkResponses];
+export type PostSettingsMainRegenerateData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/main/regenerate';
+};
+export type PostSettingsMainRegenerateResponses = {
+    /**
+     * OK
+     */
+    200: MainSettings;
+};
+export type PostSettingsMainRegenerateResponse = PostSettingsMainRegenerateResponses[keyof PostSettingsMainRegenerateResponses];
+export type GetSettingsJellyfinData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/jellyfin';
+};
+export type GetSettingsJellyfinResponses = {
+    /**
+     * OK
+     */
+    200: JellyfinSettings;
+};
+export type GetSettingsJellyfinResponse = GetSettingsJellyfinResponses[keyof GetSettingsJellyfinResponses];
+export type PostSettingsJellyfinData = {
+    body: JellyfinSettingsWritable;
+    path?: never;
+    query?: never;
+    url: '/settings/jellyfin';
+};
+export type PostSettingsJellyfinResponses = {
+    /**
+     * Values were successfully updated
+     */
+    200: JellyfinSettings;
+};
+export type PostSettingsJellyfinResponse = PostSettingsJellyfinResponses[keyof PostSettingsJellyfinResponses];
+export type GetSettingsJellyfinLibraryData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Syncs the current libraries with the current Jellyfin server
+         */
+        sync?: string | null;
+        /**
+         * Comma separated list of libraries to enable. Any libraries not passed will be disabled!
+         */
+        enable?: string | null;
+    };
+    url: '/settings/jellyfin/library';
+};
+export type GetSettingsJellyfinLibraryResponses = {
+    /**
+     * Jellyfin libraries returned
+     */
+    200: Array<JellyfinLibrary>;
+};
+export type GetSettingsJellyfinLibraryResponse = GetSettingsJellyfinLibraryResponses[keyof GetSettingsJellyfinLibraryResponses];
+export type GetSettingsJellyfinUsersData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/jellyfin/users';
+};
+export type GetSettingsJellyfinUsersResponses = {
+    /**
+     * Jellyfin users returned
+     */
+    200: Array<{
+        username?: string;
+        id?: string;
+        thumb?: string;
+        email?: string;
+    }>;
+};
+export type GetSettingsJellyfinUsersResponse = GetSettingsJellyfinUsersResponses[keyof GetSettingsJellyfinUsersResponses];
+export type GetSettingsJellyfinSyncData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/jellyfin/sync';
+};
+export type GetSettingsJellyfinSyncResponses = {
+    /**
+     * Status of Jellyfin sync
+     */
+    200: {
+        running?: boolean;
+        progress?: number;
+        total?: number;
+        currentLibrary?: JellyfinLibrary;
+        libraries?: Array<JellyfinLibrary>;
+    };
+};
+export type GetSettingsJellyfinSyncResponse = GetSettingsJellyfinSyncResponses[keyof GetSettingsJellyfinSyncResponses];
+export type PostSettingsJellyfinSyncData = {
+    body?: {
+        cancel?: boolean;
+        start?: boolean;
+    };
+    path?: never;
+    query?: never;
+    url: '/settings/jellyfin/sync';
+};
+export type PostSettingsJellyfinSyncResponses = {
+    /**
+     * Status of Jellyfin sync
+     */
+    200: {
+        running?: boolean;
+        progress?: number;
+        total?: number;
+        currentLibrary?: JellyfinLibrary;
+        libraries?: Array<JellyfinLibrary>;
+    };
+};
+export type PostSettingsJellyfinSyncResponse = PostSettingsJellyfinSyncResponses[keyof PostSettingsJellyfinSyncResponses];
+export type GetSettingsPlexData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/plex';
+};
+export type GetSettingsPlexResponses = {
+    /**
+     * OK
+     */
+    200: PlexSettings;
+};
+export type GetSettingsPlexResponse = GetSettingsPlexResponses[keyof GetSettingsPlexResponses];
+export type PostSettingsPlexData = {
+    body: PlexSettingsWritable;
+    path?: never;
+    query?: never;
+    url: '/settings/plex';
+};
+export type PostSettingsPlexResponses = {
+    /**
+     * Values were successfully updated
+     */
+    200: PlexSettings;
+};
+export type PostSettingsPlexResponse = PostSettingsPlexResponses[keyof PostSettingsPlexResponses];
+export type GetSettingsPlexLibraryData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Syncs the current libraries with the current Plex server
+         */
+        sync?: string | null;
+        /**
+         * Comma separated list of libraries to enable. Any libraries not passed will be disabled!
+         */
+        enable?: string | null;
+    };
+    url: '/settings/plex/library';
+};
+export type GetSettingsPlexLibraryResponses = {
+    /**
+     * Plex libraries returned
+     */
+    200: Array<PlexLibrary>;
+};
+export type GetSettingsPlexLibraryResponse = GetSettingsPlexLibraryResponses[keyof GetSettingsPlexLibraryResponses];
+export type GetSettingsPlexSyncData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/plex/sync';
+};
+export type GetSettingsPlexSyncResponses = {
+    /**
+     * Status of Plex scan
+     */
+    200: {
+        running?: boolean;
+        progress?: number;
+        total?: number;
+        currentLibrary?: PlexLibrary;
+        libraries?: Array<PlexLibrary>;
+    };
+};
+export type GetSettingsPlexSyncResponse = GetSettingsPlexSyncResponses[keyof GetSettingsPlexSyncResponses];
+export type PostSettingsPlexSyncData = {
+    body?: {
+        cancel?: boolean;
+        start?: boolean;
+    };
+    path?: never;
+    query?: never;
+    url: '/settings/plex/sync';
+};
+export type PostSettingsPlexSyncResponses = {
+    /**
+     * Status of Plex scan
+     */
+    200: {
+        running?: boolean;
+        progress?: number;
+        total?: number;
+        currentLibrary?: PlexLibrary;
+        libraries?: Array<PlexLibrary>;
+    };
+};
+export type PostSettingsPlexSyncResponse = PostSettingsPlexSyncResponses[keyof PostSettingsPlexSyncResponses];
+export type GetSettingsPlexDevicesServersData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/plex/devices/servers';
+};
+export type GetSettingsPlexDevicesServersResponses = {
+    /**
+     * OK
+     */
+    200: Array<PlexDevice>;
+};
+export type GetSettingsPlexDevicesServersResponse = GetSettingsPlexDevicesServersResponses[keyof GetSettingsPlexDevicesServersResponses];
+export type GetSettingsPlexUsersData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/plex/users';
+};
+export type GetSettingsPlexUsersResponses = {
+    /**
+     * Plex users
+     */
+    200: Array<{
+        id?: string;
+        title?: string;
+        username?: string;
+        email?: string;
+        thumb?: string;
+    }>;
+};
+export type GetSettingsPlexUsersResponse = GetSettingsPlexUsersResponses[keyof GetSettingsPlexUsersResponses];
+export type GetSettingsMetadatasData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/metadatas';
+};
+export type GetSettingsMetadatasResponses = {
+    /**
+     * OK
+     */
+    200: MetadataSettings;
+};
+export type GetSettingsMetadatasResponse = GetSettingsMetadatasResponses[keyof GetSettingsMetadatasResponses];
+export type PutSettingsMetadatasData = {
+    body: MetadataSettings;
+    path?: never;
+    query?: never;
+    url: '/settings/metadatas';
+};
+export type PutSettingsMetadatasResponses = {
+    /**
+     * Values were successfully updated
+     */
+    200: MetadataSettings;
+};
+export type PutSettingsMetadatasResponse = PutSettingsMetadatasResponses[keyof PutSettingsMetadatasResponses];
+export type PostSettingsMetadatasTestData = {
+    body: {
+        tmdb?: boolean;
+        tvdb?: boolean;
+    };
+    path?: never;
+    query?: never;
+    url: '/settings/metadatas/test';
+};
+export type PostSettingsMetadatasTestResponses = {
+    /**
+     * Succesfully connected to TVDB
+     */
+    200: {
+        message?: string;
+    };
+};
+export type PostSettingsMetadatasTestResponse = PostSettingsMetadatasTestResponses[keyof PostSettingsMetadatasTestResponses];
+export type GetSettingsTautulliData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/tautulli';
+};
+export type GetSettingsTautulliResponses = {
+    /**
+     * OK
+     */
+    200: TautulliSettings;
+};
+export type GetSettingsTautulliResponse = GetSettingsTautulliResponses[keyof GetSettingsTautulliResponses];
+export type PostSettingsTautulliData = {
+    body: TautulliSettings;
+    path?: never;
+    query?: never;
+    url: '/settings/tautulli';
+};
+export type PostSettingsTautulliResponses = {
+    /**
+     * Values were successfully updated
+     */
+    200: TautulliSettings;
+};
+export type PostSettingsTautulliResponse = PostSettingsTautulliResponses[keyof PostSettingsTautulliResponses];
+export type GetSettingsRadarrData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/radarr';
+};
+export type GetSettingsRadarrResponses = {
+    /**
+     * Values were returned
+     */
+    200: Array<RadarrSettings>;
+};
+export type GetSettingsRadarrResponse = GetSettingsRadarrResponses[keyof GetSettingsRadarrResponses];
+export type PostSettingsRadarrData = {
+    body: RadarrSettingsWritable;
+    path?: never;
+    query?: never;
+    url: '/settings/radarr';
+};
+export type PostSettingsRadarrResponses = {
+    /**
+     * New Radarr instance created
+     */
+    201: RadarrSettings;
+};
+export type PostSettingsRadarrResponse = PostSettingsRadarrResponses[keyof PostSettingsRadarrResponses];
+export type PostSettingsRadarrTestData = {
+    body: {
+        hostname: string;
+        port: number;
+        apiKey: string;
+        useSsl: boolean;
+        baseUrl?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/settings/radarr/test';
+};
+export type PostSettingsRadarrTestResponses = {
+    /**
+     * Succesfully connected to Radarr instance
+     */
+    200: {
+        profiles?: Array<ServiceProfile>;
+    };
+};
+export type PostSettingsRadarrTestResponse = PostSettingsRadarrTestResponses[keyof PostSettingsRadarrTestResponses];
+export type DeleteSettingsRadarrByRadarrIdData = {
+    body?: never;
+    path: {
+        /**
+         * Radarr instance ID
+         */
+        radarrId: number;
+    };
+    query?: never;
+    url: '/settings/radarr/{radarrId}';
+};
+export type DeleteSettingsRadarrByRadarrIdResponses = {
+    /**
+     * Radarr instance updated
+     */
+    200: RadarrSettings;
+};
+export type DeleteSettingsRadarrByRadarrIdResponse = DeleteSettingsRadarrByRadarrIdResponses[keyof DeleteSettingsRadarrByRadarrIdResponses];
+export type PutSettingsRadarrByRadarrIdData = {
+    body: RadarrSettingsWritable;
+    path: {
+        /**
+         * Radarr instance ID
+         */
+        radarrId: number;
+    };
+    query?: never;
+    url: '/settings/radarr/{radarrId}';
+};
+export type PutSettingsRadarrByRadarrIdResponses = {
+    /**
+     * Radarr instance updated
+     */
+    200: RadarrSettings;
+};
+export type PutSettingsRadarrByRadarrIdResponse = PutSettingsRadarrByRadarrIdResponses[keyof PutSettingsRadarrByRadarrIdResponses];
+export type GetSettingsRadarrByRadarrIdProfilesData = {
+    body?: never;
+    path: {
+        /**
+         * Radarr instance ID
+         */
+        radarrId: number;
+    };
+    query?: never;
+    url: '/settings/radarr/{radarrId}/profiles';
+};
+export type GetSettingsRadarrByRadarrIdProfilesResponses = {
+    /**
+     * Returned list of profiles
+     */
+    200: Array<ServiceProfile>;
+};
+export type GetSettingsRadarrByRadarrIdProfilesResponse = GetSettingsRadarrByRadarrIdProfilesResponses[keyof GetSettingsRadarrByRadarrIdProfilesResponses];
+export type GetSettingsSonarrData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/sonarr';
+};
+export type GetSettingsSonarrResponses = {
+    /**
+     * Values were returned
+     */
+    200: Array<SonarrSettings>;
+};
+export type GetSettingsSonarrResponse = GetSettingsSonarrResponses[keyof GetSettingsSonarrResponses];
+export type PostSettingsSonarrData = {
+    body: SonarrSettingsWritable;
+    path?: never;
+    query?: never;
+    url: '/settings/sonarr';
+};
+export type PostSettingsSonarrResponses = {
+    /**
+     * New Sonarr instance created
+     */
+    201: SonarrSettings;
+};
+export type PostSettingsSonarrResponse = PostSettingsSonarrResponses[keyof PostSettingsSonarrResponses];
+export type PostSettingsSonarrTestData = {
+    body: {
+        hostname: string;
+        port: number;
+        apiKey: string;
+        useSsl: boolean;
+        baseUrl?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/settings/sonarr/test';
+};
+export type PostSettingsSonarrTestResponses = {
+    /**
+     * Succesfully connected to Sonarr instance
+     */
+    200: {
+        profiles?: Array<ServiceProfile>;
+    };
+};
+export type PostSettingsSonarrTestResponse = PostSettingsSonarrTestResponses[keyof PostSettingsSonarrTestResponses];
+export type DeleteSettingsSonarrBySonarrIdData = {
+    body?: never;
+    path: {
+        /**
+         * Sonarr instance ID
+         */
+        sonarrId: number;
+    };
+    query?: never;
+    url: '/settings/sonarr/{sonarrId}';
+};
+export type DeleteSettingsSonarrBySonarrIdResponses = {
+    /**
+     * Sonarr instance updated
+     */
+    200: SonarrSettings;
+};
+export type DeleteSettingsSonarrBySonarrIdResponse = DeleteSettingsSonarrBySonarrIdResponses[keyof DeleteSettingsSonarrBySonarrIdResponses];
+export type PutSettingsSonarrBySonarrIdData = {
+    body: SonarrSettingsWritable;
+    path: {
+        /**
+         * Sonarr instance ID
+         */
+        sonarrId: number;
+    };
+    query?: never;
+    url: '/settings/sonarr/{sonarrId}';
+};
+export type PutSettingsSonarrBySonarrIdResponses = {
+    /**
+     * Sonarr instance updated
+     */
+    200: SonarrSettings;
+};
+export type PutSettingsSonarrBySonarrIdResponse = PutSettingsSonarrBySonarrIdResponses[keyof PutSettingsSonarrBySonarrIdResponses];
+export type GetSettingsPublicData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/public';
+};
+export type GetSettingsPublicResponses = {
+    /**
+     * Public settings returned
+     */
+    200: PublicSettings;
+};
+export type GetSettingsPublicResponse = GetSettingsPublicResponses[keyof GetSettingsPublicResponses];
+export type PostSettingsInitializeData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/initialize';
+};
+export type PostSettingsInitializeResponses = {
+    /**
+     * Public settings returned
+     */
+    200: PublicSettings;
+};
+export type PostSettingsInitializeResponse = PostSettingsInitializeResponses[keyof PostSettingsInitializeResponses];
+export type GetSettingsJobsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/jobs';
+};
+export type GetSettingsJobsResponses = {
+    /**
+     * Scheduled jobs returned
+     */
+    200: Array<Job>;
+};
+export type GetSettingsJobsResponse = GetSettingsJobsResponses[keyof GetSettingsJobsResponses];
+export type PostSettingsJobsByJobIdRunData = {
+    body?: never;
+    path: {
+        jobId: string;
+    };
+    query?: never;
+    url: '/settings/jobs/{jobId}/run';
+};
+export type PostSettingsJobsByJobIdRunResponses = {
+    /**
+     * Invoked job returned
+     */
+    200: Job;
+};
+export type PostSettingsJobsByJobIdRunResponse = PostSettingsJobsByJobIdRunResponses[keyof PostSettingsJobsByJobIdRunResponses];
+export type PostSettingsJobsByJobIdCancelData = {
+    body?: never;
+    path: {
+        jobId: string;
+    };
+    query?: never;
+    url: '/settings/jobs/{jobId}/cancel';
+};
+export type PostSettingsJobsByJobIdCancelResponses = {
+    /**
+     * Canceled job returned
+     */
+    200: Job;
+};
+export type PostSettingsJobsByJobIdCancelResponse = PostSettingsJobsByJobIdCancelResponses[keyof PostSettingsJobsByJobIdCancelResponses];
+export type PostSettingsJobsByJobIdScheduleData = {
+    body: {
+        schedule?: string;
+    };
+    path: {
+        jobId: string;
+    };
+    query?: never;
+    url: '/settings/jobs/{jobId}/schedule';
+};
+export type PostSettingsJobsByJobIdScheduleResponses = {
+    /**
+     * Rescheduled job
+     */
+    200: Job;
+};
+export type PostSettingsJobsByJobIdScheduleResponse = PostSettingsJobsByJobIdScheduleResponses[keyof PostSettingsJobsByJobIdScheduleResponses];
+export type GetSettingsCacheData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/cache';
+};
+export type GetSettingsCacheResponses = {
+    /**
+     * Caches returned
+     */
+    200: {
+        imageCache?: {
+            tmdb?: {
+                size?: number;
+                imageCount?: number;
+            };
+            avatar?: {
+                size?: number;
+                imageCount?: number;
+            };
+        };
+        dnsCache?: {
+            stats?: {
+                size?: number;
+                maxSize?: number;
+                hits?: number;
+                misses?: number;
+                failures?: number;
+                ipv4Fallbacks?: number;
+                hitRate?: number;
+            };
+            entries?: Array<unknown>;
+        };
+        apiCaches?: Array<{
+            id?: string;
+            name?: string;
+            stats?: {
+                hits?: number;
+                misses?: number;
+                keys?: number;
+                ksize?: number;
+                vsize?: number;
+            };
+        }>;
+    };
+};
+export type GetSettingsCacheResponse = GetSettingsCacheResponses[keyof GetSettingsCacheResponses];
+export type PostSettingsCacheByCacheIdFlushData = {
+    body?: never;
+    path: {
+        cacheId: string;
+    };
+    query?: never;
+    url: '/settings/cache/{cacheId}/flush';
+};
+export type PostSettingsCacheByCacheIdFlushResponses = {
+    /**
+     * Flushed cache
+     */
+    204: void;
+};
+export type PostSettingsCacheByCacheIdFlushResponse = PostSettingsCacheByCacheIdFlushResponses[keyof PostSettingsCacheByCacheIdFlushResponses];
+export type PostSettingsCacheDnsByDnsEntryFlushData = {
+    body?: never;
+    path: {
+        dnsEntry: string;
+    };
+    query?: never;
+    url: '/settings/cache/dns/{dnsEntry}/flush';
+};
+export type PostSettingsCacheDnsByDnsEntryFlushResponses = {
+    /**
+     * Flushed dns cache
+     */
+    204: void;
+};
+export type PostSettingsCacheDnsByDnsEntryFlushResponse = PostSettingsCacheDnsByDnsEntryFlushResponses[keyof PostSettingsCacheDnsByDnsEntryFlushResponses];
+export type GetSettingsLogsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        take?: number | null;
+        skip?: number | null;
+        filter?: 'debug' | 'info' | 'warn' | 'error';
+        search?: string | null;
+    };
+    url: '/settings/logs';
+};
+export type GetSettingsLogsResponses = {
+    /**
+     * Server log returned
+     */
+    200: Array<{
+        label?: string;
+        level?: string;
+        message?: string;
+        timestamp?: string;
+    }>;
+};
+export type GetSettingsLogsResponse = GetSettingsLogsResponses[keyof GetSettingsLogsResponses];
+export type GetSettingsNotificationsEmailData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/email';
+};
+export type GetSettingsNotificationsEmailResponses = {
+    /**
+     * Returned email settings
+     */
+    200: NotificationEmailSettings;
+};
+export type GetSettingsNotificationsEmailResponse = GetSettingsNotificationsEmailResponses[keyof GetSettingsNotificationsEmailResponses];
+export type PostSettingsNotificationsEmailData = {
+    body: NotificationEmailSettings;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/email';
+};
+export type PostSettingsNotificationsEmailResponses = {
+    /**
+     * Values were sucessfully updated
+     */
+    200: NotificationEmailSettings;
+};
+export type PostSettingsNotificationsEmailResponse = PostSettingsNotificationsEmailResponses[keyof PostSettingsNotificationsEmailResponses];
+export type PostSettingsNotificationsEmailTestData = {
+    body: NotificationEmailSettings;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/email/test';
+};
+export type PostSettingsNotificationsEmailTestResponses = {
+    /**
+     * Test notification attempted
+     */
+    204: void;
+};
+export type PostSettingsNotificationsEmailTestResponse = PostSettingsNotificationsEmailTestResponses[keyof PostSettingsNotificationsEmailTestResponses];
+export type GetSettingsNotificationsDiscordData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/discord';
+};
+export type GetSettingsNotificationsDiscordResponses = {
+    /**
+     * Returned Discord settings
+     */
+    200: DiscordSettings;
+};
+export type GetSettingsNotificationsDiscordResponse = GetSettingsNotificationsDiscordResponses[keyof GetSettingsNotificationsDiscordResponses];
+export type PostSettingsNotificationsDiscordData = {
+    body: DiscordSettings;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/discord';
+};
+export type PostSettingsNotificationsDiscordResponses = {
+    /**
+     * Values were sucessfully updated
+     */
+    200: DiscordSettings;
+};
+export type PostSettingsNotificationsDiscordResponse = PostSettingsNotificationsDiscordResponses[keyof PostSettingsNotificationsDiscordResponses];
+export type PostSettingsNotificationsDiscordTestData = {
+    body: DiscordSettings;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/discord/test';
+};
+export type PostSettingsNotificationsDiscordTestResponses = {
+    /**
+     * Test notification attempted
+     */
+    204: void;
+};
+export type PostSettingsNotificationsDiscordTestResponse = PostSettingsNotificationsDiscordTestResponses[keyof PostSettingsNotificationsDiscordTestResponses];
+export type GetSettingsNotificationsPushbulletData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/pushbullet';
+};
+export type GetSettingsNotificationsPushbulletResponses = {
+    /**
+     * Returned Pushbullet settings
+     */
+    200: PushbulletSettings;
+};
+export type GetSettingsNotificationsPushbulletResponse = GetSettingsNotificationsPushbulletResponses[keyof GetSettingsNotificationsPushbulletResponses];
+export type PostSettingsNotificationsPushbulletData = {
+    body: PushbulletSettings;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/pushbullet';
+};
+export type PostSettingsNotificationsPushbulletResponses = {
+    /**
+     * Values were sucessfully updated
+     */
+    200: PushbulletSettings;
+};
+export type PostSettingsNotificationsPushbulletResponse = PostSettingsNotificationsPushbulletResponses[keyof PostSettingsNotificationsPushbulletResponses];
+export type PostSettingsNotificationsPushbulletTestData = {
+    body: PushbulletSettings;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/pushbullet/test';
+};
+export type PostSettingsNotificationsPushbulletTestResponses = {
+    /**
+     * Test notification attempted
+     */
+    204: void;
+};
+export type PostSettingsNotificationsPushbulletTestResponse = PostSettingsNotificationsPushbulletTestResponses[keyof PostSettingsNotificationsPushbulletTestResponses];
+export type GetSettingsNotificationsPushoverData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/pushover';
+};
+export type GetSettingsNotificationsPushoverResponses = {
+    /**
+     * Returned Pushover settings
+     */
+    200: PushoverSettings;
+};
+export type GetSettingsNotificationsPushoverResponse = GetSettingsNotificationsPushoverResponses[keyof GetSettingsNotificationsPushoverResponses];
+export type PostSettingsNotificationsPushoverData = {
+    body: PushoverSettings;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/pushover';
+};
+export type PostSettingsNotificationsPushoverResponses = {
+    /**
+     * Values were sucessfully updated
+     */
+    200: PushoverSettings;
+};
+export type PostSettingsNotificationsPushoverResponse = PostSettingsNotificationsPushoverResponses[keyof PostSettingsNotificationsPushoverResponses];
+export type PostSettingsNotificationsPushoverTestData = {
+    body: PushoverSettings;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/pushover/test';
+};
+export type PostSettingsNotificationsPushoverTestResponses = {
+    /**
+     * Test notification attempted
+     */
+    204: void;
+};
+export type PostSettingsNotificationsPushoverTestResponse = PostSettingsNotificationsPushoverTestResponses[keyof PostSettingsNotificationsPushoverTestResponses];
+export type GetSettingsNotificationsPushoverSoundsData = {
+    body?: never;
+    path?: never;
+    query: {
+        token: string;
+    };
+    url: '/settings/notifications/pushover/sounds';
+};
+export type GetSettingsNotificationsPushoverSoundsResponses = {
+    /**
+     * Returned Pushover settings
+     */
+    200: Array<{
+        name?: string;
+        description?: string;
+    }>;
+};
+export type GetSettingsNotificationsPushoverSoundsResponse = GetSettingsNotificationsPushoverSoundsResponses[keyof GetSettingsNotificationsPushoverSoundsResponses];
+export type GetSettingsNotificationsGotifyData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/gotify';
+};
+export type GetSettingsNotificationsGotifyResponses = {
+    /**
+     * Returned Gotify settings
+     */
+    200: GotifySettings;
+};
+export type GetSettingsNotificationsGotifyResponse = GetSettingsNotificationsGotifyResponses[keyof GetSettingsNotificationsGotifyResponses];
+export type PostSettingsNotificationsGotifyData = {
+    body: GotifySettings;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/gotify';
+};
+export type PostSettingsNotificationsGotifyResponses = {
+    /**
+     * Values were sucessfully updated
+     */
+    200: GotifySettings;
+};
+export type PostSettingsNotificationsGotifyResponse = PostSettingsNotificationsGotifyResponses[keyof PostSettingsNotificationsGotifyResponses];
+export type PostSettingsNotificationsGotifyTestData = {
+    body: GotifySettings;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/gotify/test';
+};
+export type PostSettingsNotificationsGotifyTestResponses = {
+    /**
+     * Test notification attempted
+     */
+    204: void;
+};
+export type PostSettingsNotificationsGotifyTestResponse = PostSettingsNotificationsGotifyTestResponses[keyof PostSettingsNotificationsGotifyTestResponses];
+export type GetSettingsNotificationsNtfyData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/ntfy';
+};
+export type GetSettingsNotificationsNtfyResponses = {
+    /**
+     * Returned ntfy.sh settings
+     */
+    200: NtfySettings;
+};
+export type GetSettingsNotificationsNtfyResponse = GetSettingsNotificationsNtfyResponses[keyof GetSettingsNotificationsNtfyResponses];
+export type PostSettingsNotificationsNtfyData = {
+    body: NtfySettings;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/ntfy';
+};
+export type PostSettingsNotificationsNtfyResponses = {
+    /**
+     * Values were sucessfully updated
+     */
+    200: NtfySettings;
+};
+export type PostSettingsNotificationsNtfyResponse = PostSettingsNotificationsNtfyResponses[keyof PostSettingsNotificationsNtfyResponses];
+export type PostSettingsNotificationsNtfyTestData = {
+    body: NtfySettings;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/ntfy/test';
+};
+export type PostSettingsNotificationsNtfyTestResponses = {
+    /**
+     * Test notification attempted
+     */
+    204: void;
+};
+export type PostSettingsNotificationsNtfyTestResponse = PostSettingsNotificationsNtfyTestResponses[keyof PostSettingsNotificationsNtfyTestResponses];
+export type GetSettingsNotificationsSlackData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/slack';
+};
+export type GetSettingsNotificationsSlackResponses = {
+    /**
+     * Returned slack settings
+     */
+    200: SlackSettings;
+};
+export type GetSettingsNotificationsSlackResponse = GetSettingsNotificationsSlackResponses[keyof GetSettingsNotificationsSlackResponses];
+export type PostSettingsNotificationsSlackData = {
+    body: SlackSettings;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/slack';
+};
+export type PostSettingsNotificationsSlackResponses = {
+    /**
+     * Values were sucessfully updated
+     */
+    200: SlackSettings;
+};
+export type PostSettingsNotificationsSlackResponse = PostSettingsNotificationsSlackResponses[keyof PostSettingsNotificationsSlackResponses];
+export type PostSettingsNotificationsSlackTestData = {
+    body: SlackSettings;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/slack/test';
+};
+export type PostSettingsNotificationsSlackTestResponses = {
+    /**
+     * Test notification attempted
+     */
+    204: void;
+};
+export type PostSettingsNotificationsSlackTestResponse = PostSettingsNotificationsSlackTestResponses[keyof PostSettingsNotificationsSlackTestResponses];
+export type GetSettingsNotificationsTelegramData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/telegram';
+};
+export type GetSettingsNotificationsTelegramResponses = {
+    /**
+     * Returned Telegram settings
+     */
+    200: TelegramSettings;
+};
+export type GetSettingsNotificationsTelegramResponse = GetSettingsNotificationsTelegramResponses[keyof GetSettingsNotificationsTelegramResponses];
+export type PostSettingsNotificationsTelegramData = {
+    body: TelegramSettings;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/telegram';
+};
+export type PostSettingsNotificationsTelegramResponses = {
+    /**
+     * Values were sucessfully updated
+     */
+    200: TelegramSettings;
+};
+export type PostSettingsNotificationsTelegramResponse = PostSettingsNotificationsTelegramResponses[keyof PostSettingsNotificationsTelegramResponses];
+export type PostSettingsNotificationsTelegramTestData = {
+    body: TelegramSettings;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/telegram/test';
+};
+export type PostSettingsNotificationsTelegramTestResponses = {
+    /**
+     * Test notification attempted
+     */
+    204: void;
+};
+export type PostSettingsNotificationsTelegramTestResponse = PostSettingsNotificationsTelegramTestResponses[keyof PostSettingsNotificationsTelegramTestResponses];
+export type GetSettingsNotificationsWebpushData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/webpush';
+};
+export type GetSettingsNotificationsWebpushResponses = {
+    /**
+     * Returned web push settings
+     */
+    200: WebPushSettings;
+};
+export type GetSettingsNotificationsWebpushResponse = GetSettingsNotificationsWebpushResponses[keyof GetSettingsNotificationsWebpushResponses];
+export type PostSettingsNotificationsWebpushData = {
+    body: WebPushSettings;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/webpush';
+};
+export type PostSettingsNotificationsWebpushResponses = {
+    /**
+     * Values were sucessfully updated
+     */
+    200: WebPushSettings;
+};
+export type PostSettingsNotificationsWebpushResponse = PostSettingsNotificationsWebpushResponses[keyof PostSettingsNotificationsWebpushResponses];
+export type PostSettingsNotificationsWebpushTestData = {
+    body: WebPushSettings;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/webpush/test';
+};
+export type PostSettingsNotificationsWebpushTestResponses = {
+    /**
+     * Test notification attempted
+     */
+    204: void;
+};
+export type PostSettingsNotificationsWebpushTestResponse = PostSettingsNotificationsWebpushTestResponses[keyof PostSettingsNotificationsWebpushTestResponses];
+export type GetSettingsNotificationsWebhookData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/webhook';
+};
+export type GetSettingsNotificationsWebhookResponses = {
+    /**
+     * Returned webhook settings
+     */
+    200: WebhookSettings;
+};
+export type GetSettingsNotificationsWebhookResponse = GetSettingsNotificationsWebhookResponses[keyof GetSettingsNotificationsWebhookResponses];
+export type PostSettingsNotificationsWebhookData = {
+    body: WebhookSettings;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/webhook';
+};
+export type PostSettingsNotificationsWebhookResponses = {
+    /**
+     * Values were sucessfully updated
+     */
+    200: WebhookSettings;
+};
+export type PostSettingsNotificationsWebhookResponse = PostSettingsNotificationsWebhookResponses[keyof PostSettingsNotificationsWebhookResponses];
+export type PostSettingsNotificationsWebhookTestData = {
+    body: WebhookSettings;
+    path?: never;
+    query?: never;
+    url: '/settings/notifications/webhook/test';
+};
+export type PostSettingsNotificationsWebhookTestResponses = {
+    /**
+     * Test notification attempted
+     */
+    204: void;
+};
+export type PostSettingsNotificationsWebhookTestResponse = PostSettingsNotificationsWebhookTestResponses[keyof PostSettingsNotificationsWebhookTestResponses];
+export type GetSettingsDiscoverData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/discover';
+};
+export type GetSettingsDiscoverResponses = {
+    /**
+     * Returned all discovery sliders
+     */
+    200: Array<DiscoverSlider>;
+};
+export type GetSettingsDiscoverResponse = GetSettingsDiscoverResponses[keyof GetSettingsDiscoverResponses];
+export type PostSettingsDiscoverData = {
+    body: Array<DiscoverSlider>;
+    path?: never;
+    query?: never;
+    url: '/settings/discover';
+};
+export type PostSettingsDiscoverResponses = {
+    /**
+     * Returned all newly updated discovery sliders
+     */
+    200: Array<DiscoverSlider>;
+};
+export type PostSettingsDiscoverResponse = PostSettingsDiscoverResponses[keyof PostSettingsDiscoverResponses];
+export type DeleteSettingsDiscoverBySliderIdData = {
+    body?: never;
+    path: {
+        sliderId: number;
+    };
+    query?: never;
+    url: '/settings/discover/{sliderId}';
+};
+export type DeleteSettingsDiscoverBySliderIdResponses = {
+    /**
+     * Slider successfully deleted
+     */
+    200: DiscoverSlider;
+};
+export type DeleteSettingsDiscoverBySliderIdResponse = DeleteSettingsDiscoverBySliderIdResponses[keyof DeleteSettingsDiscoverBySliderIdResponses];
+export type PutSettingsDiscoverBySliderIdData = {
+    body: {
+        title?: string;
+        type?: number;
+        data?: string;
+    };
+    path: {
+        sliderId: number;
+    };
+    query?: never;
+    url: '/settings/discover/{sliderId}';
+};
+export type PutSettingsDiscoverBySliderIdResponses = {
+    /**
+     * Returns newly added discovery slider
+     */
+    200: DiscoverSlider;
+};
+export type PutSettingsDiscoverBySliderIdResponse = PutSettingsDiscoverBySliderIdResponses[keyof PutSettingsDiscoverBySliderIdResponses];
+export type PostSettingsDiscoverAddData = {
+    body: {
+        title?: string;
+        type?: number;
+        data?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/settings/discover/add';
+};
+export type PostSettingsDiscoverAddResponses = {
+    /**
+     * Returns newly added discovery slider
+     */
+    200: DiscoverSlider;
+};
+export type PostSettingsDiscoverAddResponse = PostSettingsDiscoverAddResponses[keyof PostSettingsDiscoverAddResponses];
+export type GetSettingsDiscoverResetData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/discover/reset';
+};
+export type GetSettingsDiscoverResetResponses = {
+    /**
+     * All sliders reset to defaults
+     */
+    204: void;
+};
+export type GetSettingsDiscoverResetResponse = GetSettingsDiscoverResetResponses[keyof GetSettingsDiscoverResetResponses];
+export type GetSettingsAboutData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/settings/about';
+};
+export type GetSettingsAboutResponses = {
+    /**
+     * Returned about settings
+     */
+    200: {
+        version?: string;
+        totalRequests?: number;
+        totalMediaItems?: number;
+        tz?: string | null;
+        appDataPath?: string;
+    };
+};
+export type GetSettingsAboutResponse = GetSettingsAboutResponses[keyof GetSettingsAboutResponses];
+export type GetAuthMeData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/auth/me';
+};
+export type GetAuthMeResponses = {
+    /**
+     * Object containing the logged-in user in JSON
+     */
+    200: User;
+};
+export type GetAuthMeResponse = GetAuthMeResponses[keyof GetAuthMeResponses];
+export type PostAuthPlexData = {
+    body: {
+        authToken: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/auth/plex';
+};
+export type PostAuthPlexResponses = {
+    /**
+     * OK
+     */
+    200: User;
+};
+export type PostAuthPlexResponse = PostAuthPlexResponses[keyof PostAuthPlexResponses];
+export type PostAuthJellyfinData = {
+    body: {
+        username: string;
+        password: string;
+        hostname?: string;
+        email?: string;
+        serverType?: number;
+    };
+    path?: never;
+    query?: never;
+    url: '/auth/jellyfin';
+};
+export type PostAuthJellyfinResponses = {
+    /**
+     * OK
+     */
+    200: User;
+};
+export type PostAuthJellyfinResponse = PostAuthJellyfinResponses[keyof PostAuthJellyfinResponses];
+export type PostAuthLocalData = {
+    body: {
+        email: string;
+        password: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/auth/local';
+};
+export type PostAuthLocalResponses = {
+    /**
+     * OK
+     */
+    200: User;
+};
+export type PostAuthLocalResponse = PostAuthLocalResponses[keyof PostAuthLocalResponses];
+export type PostAuthLogoutData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/auth/logout';
+};
+export type PostAuthLogoutResponses = {
+    /**
+     * OK
+     */
+    200: {
+        status?: string;
+    };
+};
+export type PostAuthLogoutResponse = PostAuthLogoutResponses[keyof PostAuthLogoutResponses];
+export type PostAuthResetPasswordData = {
+    body: {
+        email: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/auth/reset-password';
+};
+export type PostAuthResetPasswordResponses = {
+    /**
+     * OK
+     */
+    200: {
+        status?: string;
+    };
+};
+export type PostAuthResetPasswordResponse = PostAuthResetPasswordResponses[keyof PostAuthResetPasswordResponses];
+export type PostAuthResetPasswordByGuidData = {
+    body: {
+        password: string;
+    };
+    path: {
+        guid: string;
+    };
+    query?: never;
+    url: '/auth/reset-password/{guid}';
+};
+export type PostAuthResetPasswordByGuidResponses = {
+    /**
+     * OK
+     */
+    200: {
+        status?: string;
+    };
+};
+export type PostAuthResetPasswordByGuidResponse = PostAuthResetPasswordByGuidResponses[keyof PostAuthResetPasswordByGuidResponses];
+export type GetUserData = {
+    body?: never;
+    path?: never;
+    query?: {
+        take?: number | null;
+        skip?: number | null;
+        sort?: 'created' | 'updated' | 'requests' | 'displayname';
+        q?: string;
+        includeIds?: string;
+    };
+    url: '/user';
+};
+export type GetUserResponses = {
+    /**
+     * A JSON array of all users
+     */
+    200: {
+        pageInfo?: PageInfo;
+        results?: Array<User>;
+    };
+};
+export type GetUserResponse = GetUserResponses[keyof GetUserResponses];
+export type PostUserData = {
+    body: {
+        email?: string;
+        username?: string;
+        permissions?: number;
+    };
+    path?: never;
+    query?: never;
+    url: '/user';
+};
+export type PostUserResponses = {
+    /**
+     * The created user
+     */
+    201: User;
+};
+export type PostUserResponse = PostUserResponses[keyof PostUserResponses];
+export type PutUserData = {
+    body: {
+        ids?: Array<number>;
+        permissions?: number;
+    };
+    path?: never;
+    query?: never;
+    url: '/user';
+};
+export type PutUserResponses = {
+    /**
+     * Successfully updated user details
+     */
+    200: Array<User>;
+};
+export type PutUserResponse = PutUserResponses[keyof PutUserResponses];
+export type PostUserImportFromPlexData = {
+    body?: {
+        plexIds?: Array<string>;
+    };
+    path?: never;
+    query?: never;
+    url: '/user/import-from-plex';
+};
+export type PostUserImportFromPlexResponses = {
+    /**
+     * A list of the newly created users
+     */
+    201: Array<User>;
+};
+export type PostUserImportFromPlexResponse = PostUserImportFromPlexResponses[keyof PostUserImportFromPlexResponses];
+export type PostUserImportFromJellyfinData = {
+    body?: {
+        jellyfinUserIds?: Array<string>;
+    };
+    path?: never;
+    query?: never;
+    url: '/user/import-from-jellyfin';
+};
+export type PostUserImportFromJellyfinResponses = {
+    /**
+     * A list of the newly created users
+     */
+    201: Array<User>;
+};
+export type PostUserImportFromJellyfinResponse = PostUserImportFromJellyfinResponses[keyof PostUserImportFromJellyfinResponses];
+export type PostUserRegisterPushSubscriptionData = {
+    body: {
+        endpoint: string;
+        auth: string;
+        p256dh: string;
+        userAgent?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/user/registerPushSubscription';
+};
+export type PostUserRegisterPushSubscriptionResponses = {
+    /**
+     * Successfully registered push subscription
+     */
+    204: void;
+};
+export type PostUserRegisterPushSubscriptionResponse = PostUserRegisterPushSubscriptionResponses[keyof PostUserRegisterPushSubscriptionResponses];
+export type GetUserByUserIdPushSubscriptionsData = {
+    body?: never;
+    path: {
+        userId: number;
+    };
+    query?: never;
+    url: '/user/{userId}/pushSubscriptions';
+};
+export type GetUserByUserIdPushSubscriptionsResponses = {
+    /**
+     * User web push notification settings in JSON
+     */
+    200: {
+        endpoint?: string;
+        p256dh?: string;
+        auth?: string;
+        userAgent?: string;
+    };
+};
+export type GetUserByUserIdPushSubscriptionsResponse = GetUserByUserIdPushSubscriptionsResponses[keyof GetUserByUserIdPushSubscriptionsResponses];
+export type DeleteUserByUserIdPushSubscriptionByEndpointData = {
+    body?: never;
+    path: {
+        userId: number;
+        endpoint: string;
+    };
+    query?: never;
+    url: '/user/{userId}/pushSubscription/{endpoint}';
+};
+export type DeleteUserByUserIdPushSubscriptionByEndpointResponses = {
+    /**
+     * Successfully removed user push subscription
+     */
+    204: void;
+};
+export type DeleteUserByUserIdPushSubscriptionByEndpointResponse = DeleteUserByUserIdPushSubscriptionByEndpointResponses[keyof DeleteUserByUserIdPushSubscriptionByEndpointResponses];
+export type GetUserByUserIdPushSubscriptionByEndpointData = {
+    body?: never;
+    path: {
+        userId: number;
+        endpoint: string;
+    };
+    query?: never;
+    url: '/user/{userId}/pushSubscription/{endpoint}';
+};
+export type GetUserByUserIdPushSubscriptionByEndpointResponses = {
+    /**
+     * User web push notification settings in JSON
+     */
+    200: {
+        endpoint?: string;
+        p256dh?: string;
+        auth?: string;
+        userAgent?: string;
+    };
+};
+export type GetUserByUserIdPushSubscriptionByEndpointResponse = GetUserByUserIdPushSubscriptionByEndpointResponses[keyof GetUserByUserIdPushSubscriptionByEndpointResponses];
+export type DeleteUserByUserIdData = {
+    body?: never;
+    path: {
+        userId: number;
+    };
+    query?: never;
+    url: '/user/{userId}';
+};
+export type DeleteUserByUserIdResponses = {
+    /**
+     * User successfully deleted
+     */
+    200: User;
+};
+export type DeleteUserByUserIdResponse = DeleteUserByUserIdResponses[keyof DeleteUserByUserIdResponses];
+export type GetUserByUserIdData = {
+    body?: never;
+    path: {
+        userId: number;
+    };
+    query?: never;
+    url: '/user/{userId}';
+};
+export type GetUserByUserIdResponses = {
+    /**
+     * Users details in JSON
+     */
+    200: User;
+};
+export type GetUserByUserIdResponse = GetUserByUserIdResponses[keyof GetUserByUserIdResponses];
+export type PutUserByUserIdData = {
+    body: UserWritable;
+    path: {
+        userId: number;
+    };
+    query?: never;
+    url: '/user/{userId}';
+};
+export type PutUserByUserIdResponses = {
+    /**
+     * Successfully updated user details
+     */
+    200: User;
+};
+export type PutUserByUserIdResponse = PutUserByUserIdResponses[keyof PutUserByUserIdResponses];
+export type GetUserByUserIdRequestsData = {
+    body?: never;
+    path: {
+        userId: number;
+    };
+    query?: {
+        take?: number | null;
+        skip?: number | null;
+    };
+    url: '/user/{userId}/requests';
+};
+export type GetUserByUserIdRequestsResponses = {
+    /**
+     * User's requests returned
+     */
+    200: {
+        pageInfo?: PageInfo;
+        results?: Array<MediaRequest>;
+    };
+};
+export type GetUserByUserIdRequestsResponse = GetUserByUserIdRequestsResponses[keyof GetUserByUserIdRequestsResponses];
+export type GetUserByUserIdQuotaData = {
+    body?: never;
+    path: {
+        userId: number;
+    };
+    query?: never;
+    url: '/user/{userId}/quota';
+};
+export type GetUserByUserIdQuotaResponses = {
+    /**
+     * User quota details in JSON
+     */
+    200: {
+        movie?: {
+            days?: number;
+            limit?: number;
+            used?: number;
+            remaining?: number;
+            restricted?: boolean;
+        };
+        tv?: {
+            days?: number;
+            limit?: number;
+            used?: number;
+            remaining?: number;
+            restricted?: boolean;
+        };
+    };
+};
+export type GetUserByUserIdQuotaResponse = GetUserByUserIdQuotaResponses[keyof GetUserByUserIdQuotaResponses];
+export type GetBlocklistData = {
+    body?: never;
+    path?: never;
+    query?: {
+        take?: number | null;
+        skip?: number | null;
+        search?: string | null;
+        filter?: 'all' | 'manual' | 'blocklistedTags';
+    };
+    url: '/blocklist';
+};
+export type GetBlocklistResponses = {
+    /**
+     * Blocklisted items returned
+     */
+    200: {
+        pageInfo?: PageInfo;
+        results?: Array<{
+            user?: User;
+            createdAt?: string;
+            id?: number;
+            mediaType?: string;
+            title?: string;
+            tmdbId?: number;
+        }>;
+    };
+};
+export type GetBlocklistResponse = GetBlocklistResponses[keyof GetBlocklistResponses];
+export type PostBlocklistData = {
+    body: BlocklistWritable;
+    path?: never;
+    query?: never;
+    url: '/blocklist';
+};
+export type PostBlocklistErrors = {
+    /**
+     * Item has already been blocklisted
+     */
+    412: unknown;
+};
+export type PostBlocklistResponses = {
+    /**
+     * Item succesfully blocklisted
+     */
+    201: unknown;
+};
+export type DeleteBlocklistByTmdbIdData = {
+    body?: never;
+    path: {
+        /**
+         * tmdbId ID
+         */
+        tmdbId: string;
+    };
+    query?: never;
+    url: '/blocklist/{tmdbId}';
+};
+export type DeleteBlocklistByTmdbIdResponses = {
+    /**
+     * Succesfully removed media item
+     */
+    204: void;
+};
+export type DeleteBlocklistByTmdbIdResponse = DeleteBlocklistByTmdbIdResponses[keyof DeleteBlocklistByTmdbIdResponses];
+export type GetBlocklistByTmdbIdData = {
+    body?: never;
+    path: {
+        /**
+         * tmdbId ID
+         */
+        tmdbId: string;
+    };
+    query?: never;
+    url: '/blocklist/{tmdbId}';
+};
+export type GetBlocklistByTmdbIdResponses = {
+    /**
+     * Blocklist details in JSON
+     */
+    200: unknown;
+};
+export type GetBlacklistData = {
+    body?: never;
+    path?: never;
+    query?: {
+        take?: number | null;
+        skip?: number | null;
+        search?: string | null;
+        filter?: 'all' | 'manual' | 'blocklistedTags';
+    };
+    url: '/blacklist';
+};
+export type GetBlacklistResponses = {
+    /**
+     * Blocklisted items returned
+     */
+    200: {
+        pageInfo?: PageInfo;
+        results?: Array<{
+            user?: User;
+            createdAt?: string;
+            id?: number;
+            mediaType?: string;
+            title?: string;
+            tmdbId?: number;
+        }>;
+    };
+};
+export type GetBlacklistResponse = GetBlacklistResponses[keyof GetBlacklistResponses];
+export type PostBlacklistData = {
+    body: BlocklistWritable;
+    path?: never;
+    query?: never;
+    url: '/blacklist';
+};
+export type PostBlacklistErrors = {
+    /**
+     * Item has already been blocklisted
+     */
+    412: unknown;
+};
+export type PostBlacklistResponses = {
+    /**
+     * Item succesfully blocklisted
+     */
+    201: unknown;
+};
+export type DeleteBlacklistByTmdbIdData = {
+    body?: never;
+    path: {
+        /**
+         * tmdbId ID
+         */
+        tmdbId: string;
+    };
+    query?: never;
+    url: '/blacklist/{tmdbId}';
+};
+export type DeleteBlacklistByTmdbIdResponses = {
+    /**
+     * Succesfully removed media item
+     */
+    204: void;
+};
+export type DeleteBlacklistByTmdbIdResponse = DeleteBlacklistByTmdbIdResponses[keyof DeleteBlacklistByTmdbIdResponses];
+export type GetBlacklistByTmdbIdData = {
+    body?: never;
+    path: {
+        /**
+         * tmdbId ID
+         */
+        tmdbId: string;
+    };
+    query?: never;
+    url: '/blacklist/{tmdbId}';
+};
+export type GetBlacklistByTmdbIdResponses = {
+    /**
+     * Blocklist details in JSON
+     */
+    200: unknown;
+};
+export type PostWatchlistData = {
+    body: WatchlistWritable;
+    path?: never;
+    query?: never;
+    url: '/watchlist';
+};
+export type PostWatchlistResponses = {
+    /**
+     * Watchlist data returned
+     */
+    200: Watchlist;
+};
+export type PostWatchlistResponse = PostWatchlistResponses[keyof PostWatchlistResponses];
+export type DeleteWatchlistByTmdbIdData = {
+    body?: never;
+    path: {
+        /**
+         * tmdbId ID
+         */
+        tmdbId: string;
+    };
+    query?: never;
+    url: '/watchlist/{tmdbId}';
+};
+export type DeleteWatchlistByTmdbIdResponses = {
+    /**
+     * Succesfully removed watchlist item
+     */
+    204: void;
+};
+export type DeleteWatchlistByTmdbIdResponse = DeleteWatchlistByTmdbIdResponses[keyof DeleteWatchlistByTmdbIdResponses];
+export type GetUserByUserIdWatchlistData = {
+    body?: never;
+    path: {
+        userId: number;
+    };
+    query?: {
+        page?: number;
+    };
+    url: '/user/{userId}/watchlist';
+};
+export type GetUserByUserIdWatchlistResponses = {
+    /**
+     * Watchlist data returned
+     */
+    200: {
+        page?: number;
+        totalPages?: number;
+        totalResults?: number;
+        results?: Array<{
+            tmdbId?: number;
+            ratingKey?: string;
+            type?: string;
+            title?: string;
+        }>;
+    };
+};
+export type GetUserByUserIdWatchlistResponse = GetUserByUserIdWatchlistResponses[keyof GetUserByUserIdWatchlistResponses];
+export type GetUserByUserIdSettingsMainData = {
+    body?: never;
+    path: {
+        userId: number;
+    };
+    query?: never;
+    url: '/user/{userId}/settings/main';
+};
+export type GetUserByUserIdSettingsMainResponses = {
+    /**
+     * User general settings returned
+     */
+    200: UserSettings;
+};
+export type GetUserByUserIdSettingsMainResponse = GetUserByUserIdSettingsMainResponses[keyof GetUserByUserIdSettingsMainResponses];
+export type PostUserByUserIdSettingsMainData = {
+    body: UserSettings;
+    path: {
+        userId: number;
+    };
+    query?: never;
+    url: '/user/{userId}/settings/main';
+};
+export type PostUserByUserIdSettingsMainResponses = {
+    /**
+     * Updated user general settings returned
+     */
+    200: UserSettings;
+};
+export type PostUserByUserIdSettingsMainResponse = PostUserByUserIdSettingsMainResponses[keyof PostUserByUserIdSettingsMainResponses];
+export type GetUserByUserIdSettingsPasswordData = {
+    body?: never;
+    path: {
+        userId: number;
+    };
+    query?: never;
+    url: '/user/{userId}/settings/password';
+};
+export type GetUserByUserIdSettingsPasswordResponses = {
+    /**
+     * User password page information returned
+     */
+    200: {
+        hasPassword?: boolean;
+    };
+};
+export type GetUserByUserIdSettingsPasswordResponse = GetUserByUserIdSettingsPasswordResponses[keyof GetUserByUserIdSettingsPasswordResponses];
+export type PostUserByUserIdSettingsPasswordData = {
+    body: {
+        currentPassword?: string | null;
+        newPassword: string;
+    };
+    path: {
+        userId: number;
+    };
+    query?: never;
+    url: '/user/{userId}/settings/password';
+};
+export type PostUserByUserIdSettingsPasswordResponses = {
+    /**
+     * User password updated
+     */
+    204: void;
+};
+export type PostUserByUserIdSettingsPasswordResponse = PostUserByUserIdSettingsPasswordResponses[keyof PostUserByUserIdSettingsPasswordResponses];
+export type DeleteUserByUserIdSettingsLinkedAccountsPlexData = {
+    body?: never;
+    path: {
+        userId: number;
+    };
+    query?: never;
+    url: '/user/{userId}/settings/linked-accounts/plex';
+};
+export type DeleteUserByUserIdSettingsLinkedAccountsPlexErrors = {
+    /**
+     * Unlink request invalid
+     */
+    400: unknown;
+    /**
+     * User does not exist
+     */
+    404: unknown;
+};
+export type DeleteUserByUserIdSettingsLinkedAccountsPlexResponses = {
+    /**
+     * Unlinking account succeeded
+     */
+    204: void;
+};
+export type DeleteUserByUserIdSettingsLinkedAccountsPlexResponse = DeleteUserByUserIdSettingsLinkedAccountsPlexResponses[keyof DeleteUserByUserIdSettingsLinkedAccountsPlexResponses];
+export type PostUserByUserIdSettingsLinkedAccountsPlexData = {
+    body: {
+        authToken: string;
+    };
+    path: {
+        userId: number;
+    };
+    query?: never;
+    url: '/user/{userId}/settings/linked-accounts/plex';
+};
+export type PostUserByUserIdSettingsLinkedAccountsPlexErrors = {
+    /**
+     * Invalid credentials
+     */
+    403: unknown;
+    /**
+     * Account already linked to a user
+     */
+    422: unknown;
+};
+export type PostUserByUserIdSettingsLinkedAccountsPlexResponses = {
+    /**
+     * Linking account succeeded
+     */
+    204: void;
+};
+export type PostUserByUserIdSettingsLinkedAccountsPlexResponse = PostUserByUserIdSettingsLinkedAccountsPlexResponses[keyof PostUserByUserIdSettingsLinkedAccountsPlexResponses];
+export type DeleteUserByUserIdSettingsLinkedAccountsJellyfinData = {
+    body?: never;
+    path: {
+        userId: number;
+    };
+    query?: never;
+    url: '/user/{userId}/settings/linked-accounts/jellyfin';
+};
+export type DeleteUserByUserIdSettingsLinkedAccountsJellyfinErrors = {
+    /**
+     * Unlink request invalid
+     */
+    400: unknown;
+    /**
+     * User does not exist
+     */
+    404: unknown;
+};
+export type DeleteUserByUserIdSettingsLinkedAccountsJellyfinResponses = {
+    /**
+     * Unlinking account succeeded
+     */
+    204: void;
+};
+export type DeleteUserByUserIdSettingsLinkedAccountsJellyfinResponse = DeleteUserByUserIdSettingsLinkedAccountsJellyfinResponses[keyof DeleteUserByUserIdSettingsLinkedAccountsJellyfinResponses];
+export type PostUserByUserIdSettingsLinkedAccountsJellyfinData = {
+    body: {
+        username?: string;
+        password?: string;
+    };
+    path: {
+        userId: number;
+    };
+    query?: never;
+    url: '/user/{userId}/settings/linked-accounts/jellyfin';
+};
+export type PostUserByUserIdSettingsLinkedAccountsJellyfinErrors = {
+    /**
+     * Invalid credentials
+     */
+    403: unknown;
+    /**
+     * Account already linked to a user
+     */
+    422: unknown;
+};
+export type PostUserByUserIdSettingsLinkedAccountsJellyfinResponses = {
+    /**
+     * Linking account succeeded
+     */
+    204: void;
+};
+export type PostUserByUserIdSettingsLinkedAccountsJellyfinResponse = PostUserByUserIdSettingsLinkedAccountsJellyfinResponses[keyof PostUserByUserIdSettingsLinkedAccountsJellyfinResponses];
+export type GetUserByUserIdSettingsNotificationsData = {
+    body?: never;
+    path: {
+        userId: number;
+    };
+    query?: never;
+    url: '/user/{userId}/settings/notifications';
+};
+export type GetUserByUserIdSettingsNotificationsResponses = {
+    /**
+     * User notification settings returned
+     */
+    200: UserSettingsNotifications;
+};
+export type GetUserByUserIdSettingsNotificationsResponse = GetUserByUserIdSettingsNotificationsResponses[keyof GetUserByUserIdSettingsNotificationsResponses];
+export type PostUserByUserIdSettingsNotificationsData = {
+    body: UserSettingsNotifications;
+    path: {
+        userId: number;
+    };
+    query?: never;
+    url: '/user/{userId}/settings/notifications';
+};
+export type PostUserByUserIdSettingsNotificationsResponses = {
+    /**
+     * Updated user notification settings returned
+     */
+    200: UserSettingsNotifications;
+};
+export type PostUserByUserIdSettingsNotificationsResponse = PostUserByUserIdSettingsNotificationsResponses[keyof PostUserByUserIdSettingsNotificationsResponses];
+export type GetUserByUserIdSettingsPermissionsData = {
+    body?: never;
+    path: {
+        userId: number;
+    };
+    query?: never;
+    url: '/user/{userId}/settings/permissions';
+};
+export type GetUserByUserIdSettingsPermissionsResponses = {
+    /**
+     * User permission settings returned
+     */
+    200: {
+        permissions?: number;
+    };
+};
+export type GetUserByUserIdSettingsPermissionsResponse = GetUserByUserIdSettingsPermissionsResponses[keyof GetUserByUserIdSettingsPermissionsResponses];
+export type PostUserByUserIdSettingsPermissionsData = {
+    body: {
+        permissions: number;
+    };
+    path: {
+        userId: number;
+    };
+    query?: never;
+    url: '/user/{userId}/settings/permissions';
+};
+export type PostUserByUserIdSettingsPermissionsResponses = {
+    /**
+     * Updated user general settings returned
+     */
+    200: {
+        permissions?: number;
+    };
+};
+export type PostUserByUserIdSettingsPermissionsResponse = PostUserByUserIdSettingsPermissionsResponses[keyof PostUserByUserIdSettingsPermissionsResponses];
+export type GetUserByUserIdWatchDataData = {
+    body?: never;
+    path: {
+        userId: number;
+    };
+    query?: never;
+    url: '/user/{userId}/watch_data';
+};
+export type GetUserByUserIdWatchDataResponses = {
+    /**
+     * Users
+     */
+    200: {
+        recentlyWatched?: Array<MediaInfo>;
+        playCount?: number;
+    };
+};
+export type GetUserByUserIdWatchDataResponse = GetUserByUserIdWatchDataResponses[keyof GetUserByUserIdWatchDataResponses];
+export type GetSearchData = {
+    body?: never;
+    path?: never;
+    query: {
+        query: string;
+        page?: number;
+        language?: string;
+    };
+    url: '/search';
+};
+export type GetSearchResponses = {
+    /**
+     * Results
+     */
+    200: {
+        page?: number;
+        totalPages?: number;
+        totalResults?: number;
+        results?: Array<MovieResult | TvResult | PersonResult>;
+    };
+};
+export type GetSearchResponse = GetSearchResponses[keyof GetSearchResponses];
+export type GetSearchKeywordData = {
+    body?: never;
+    path?: never;
+    query: {
+        query: string;
+        page?: number;
+    };
+    url: '/search/keyword';
+};
+export type GetSearchKeywordResponses = {
+    /**
+     * Results
+     */
+    200: {
+        page?: number;
+        totalPages?: number;
+        totalResults?: number;
+        results?: Array<Keyword>;
+    };
+};
+export type GetSearchKeywordResponse = GetSearchKeywordResponses[keyof GetSearchKeywordResponses];
+export type GetSearchCompanyData = {
+    body?: never;
+    path?: never;
+    query: {
+        query: string;
+        page?: number;
+    };
+    url: '/search/company';
+};
+export type GetSearchCompanyResponses = {
+    /**
+     * Results
+     */
+    200: {
+        page?: number;
+        totalPages?: number;
+        totalResults?: number;
+        results?: Array<Company>;
+    };
+};
+export type GetSearchCompanyResponse = GetSearchCompanyResponses[keyof GetSearchCompanyResponses];
+export type GetDiscoverMoviesData = {
+    body?: never;
+    path?: never;
+    query?: {
+        page?: number;
+        language?: string;
+        genre?: string;
+        studio?: number;
+        keywords?: string;
+        /**
+         * Comma-separated list of keyword IDs to exclude from results
+         */
+        excludeKeywords?: string;
+        sortBy?: string;
+        primaryReleaseDateGte?: string;
+        primaryReleaseDateLte?: string;
+        withRuntimeGte?: number;
+        withRuntimeLte?: number;
+        voteAverageGte?: number;
+        voteAverageLte?: number;
+        voteCountGte?: number;
+        voteCountLte?: number;
+        watchRegion?: string;
+        watchProviders?: string;
+        /**
+         * Exact certification to filter by (used when certificationMode is 'exact')
+         */
+        certification?: string;
+        /**
+         * Minimum certification to filter by (used when certificationMode is 'range')
+         */
+        certificationGte?: string;
+        /**
+         * Maximum certification to filter by (used when certificationMode is 'range')
+         */
+        certificationLte?: string;
+        /**
+         * Country code for the certification system (e.g., US, GB, CA)
+         */
+        certificationCountry?: string;
+        /**
+         * Determines whether to use exact certification matching or a certification range (internal use only, not sent to TMDB API)
+         */
+        certificationMode?: 'exact' | 'range';
+    };
+    url: '/discover/movies';
+};
+export type GetDiscoverMoviesResponses = {
+    /**
+     * Results
+     */
+    200: {
+        page?: number;
+        totalPages?: number;
+        totalResults?: number;
+        results?: Array<MovieResult>;
+    };
+};
+export type GetDiscoverMoviesResponse = GetDiscoverMoviesResponses[keyof GetDiscoverMoviesResponses];
+export type GetDiscoverMoviesGenreByGenreIdData = {
+    body?: never;
+    path: {
+        genreId: string;
+    };
+    query?: {
+        page?: number;
+        language?: string;
+    };
+    url: '/discover/movies/genre/{genreId}';
+};
+export type GetDiscoverMoviesGenreByGenreIdResponses = {
+    /**
+     * Results
+     */
+    200: {
+        page?: number;
+        totalPages?: number;
+        totalResults?: number;
+        genre?: Genre;
+        results?: Array<MovieResult>;
+    };
+};
+export type GetDiscoverMoviesGenreByGenreIdResponse = GetDiscoverMoviesGenreByGenreIdResponses[keyof GetDiscoverMoviesGenreByGenreIdResponses];
+export type GetDiscoverMoviesLanguageByLanguageData = {
+    body?: never;
+    path: {
+        language: string;
+    };
+    query?: {
+        page?: number;
+        language?: string;
+    };
+    url: '/discover/movies/language/{language}';
+};
+export type GetDiscoverMoviesLanguageByLanguageResponses = {
+    /**
+     * Results
+     */
+    200: {
+        page?: number;
+        totalPages?: number;
+        totalResults?: number;
+        language?: SpokenLanguage;
+        results?: Array<MovieResult>;
+    };
+};
+export type GetDiscoverMoviesLanguageByLanguageResponse = GetDiscoverMoviesLanguageByLanguageResponses[keyof GetDiscoverMoviesLanguageByLanguageResponses];
+export type GetDiscoverMoviesStudioByStudioIdData = {
+    body?: never;
+    path: {
+        studioId: string;
+    };
+    query?: {
+        page?: number;
+        language?: string;
+    };
+    url: '/discover/movies/studio/{studioId}';
+};
+export type GetDiscoverMoviesStudioByStudioIdResponses = {
+    /**
+     * Results
+     */
+    200: {
+        page?: number;
+        totalPages?: number;
+        totalResults?: number;
+        studio?: ProductionCompany;
+        results?: Array<MovieResult>;
+    };
+};
+export type GetDiscoverMoviesStudioByStudioIdResponse = GetDiscoverMoviesStudioByStudioIdResponses[keyof GetDiscoverMoviesStudioByStudioIdResponses];
+export type GetDiscoverMoviesUpcomingData = {
+    body?: never;
+    path?: never;
+    query?: {
+        page?: number;
+        language?: string;
+    };
+    url: '/discover/movies/upcoming';
+};
+export type GetDiscoverMoviesUpcomingResponses = {
+    /**
+     * Results
+     */
+    200: {
+        page?: number;
+        totalPages?: number;
+        totalResults?: number;
+        results?: Array<MovieResult>;
+    };
+};
+export type GetDiscoverMoviesUpcomingResponse = GetDiscoverMoviesUpcomingResponses[keyof GetDiscoverMoviesUpcomingResponses];
+export type GetDiscoverTvData = {
+    body?: never;
+    path?: never;
+    query?: {
+        page?: number;
+        language?: string;
+        genre?: string;
+        network?: number;
+        keywords?: string;
+        /**
+         * Comma-separated list of keyword IDs to exclude from results
+         */
+        excludeKeywords?: string;
+        sortBy?: string;
+        firstAirDateGte?: string;
+        firstAirDateLte?: string;
+        withRuntimeGte?: number;
+        withRuntimeLte?: number;
+        voteAverageGte?: number;
+        voteAverageLte?: number;
+        voteCountGte?: number;
+        voteCountLte?: number;
+        watchRegion?: string;
+        watchProviders?: string;
+        status?: string;
+        /**
+         * Exact certification to filter by (used when certificationMode is 'exact')
+         */
+        certification?: string;
+        /**
+         * Minimum certification to filter by (used when certificationMode is 'range')
+         */
+        certificationGte?: string;
+        /**
+         * Maximum certification to filter by (used when certificationMode is 'range')
+         */
+        certificationLte?: string;
+        /**
+         * Country code for the certification system (e.g., US, GB, CA)
+         */
+        certificationCountry?: string;
+        /**
+         * Determines whether to use exact certification matching or a certification range (internal use only, not sent to TMDB API)
+         */
+        certificationMode?: 'exact' | 'range';
+    };
+    url: '/discover/tv';
+};
+export type GetDiscoverTvResponses = {
+    /**
+     * Results
+     */
+    200: {
+        page?: number;
+        totalPages?: number;
+        totalResults?: number;
+        results?: Array<TvResult>;
+    };
+};
+export type GetDiscoverTvResponse = GetDiscoverTvResponses[keyof GetDiscoverTvResponses];
+export type GetDiscoverTvLanguageByLanguageData = {
+    body?: never;
+    path: {
+        language: string;
+    };
+    query?: {
+        page?: number;
+        language?: string;
+    };
+    url: '/discover/tv/language/{language}';
+};
+export type GetDiscoverTvLanguageByLanguageResponses = {
+    /**
+     * Results
+     */
+    200: {
+        page?: number;
+        totalPages?: number;
+        totalResults?: number;
+        language?: SpokenLanguage;
+        results?: Array<TvResult>;
+    };
+};
+export type GetDiscoverTvLanguageByLanguageResponse = GetDiscoverTvLanguageByLanguageResponses[keyof GetDiscoverTvLanguageByLanguageResponses];
+export type GetDiscoverTvGenreByGenreIdData = {
+    body?: never;
+    path: {
+        genreId: string;
+    };
+    query?: {
+        page?: number;
+        language?: string;
+    };
+    url: '/discover/tv/genre/{genreId}';
+};
+export type GetDiscoverTvGenreByGenreIdResponses = {
+    /**
+     * Results
+     */
+    200: {
+        page?: number;
+        totalPages?: number;
+        totalResults?: number;
+        genre?: Genre;
+        results?: Array<TvResult>;
+    };
+};
+export type GetDiscoverTvGenreByGenreIdResponse = GetDiscoverTvGenreByGenreIdResponses[keyof GetDiscoverTvGenreByGenreIdResponses];
+export type GetDiscoverTvNetworkByNetworkIdData = {
+    body?: never;
+    path: {
+        networkId: string;
+    };
+    query?: {
+        page?: number;
+        language?: string;
+    };
+    url: '/discover/tv/network/{networkId}';
+};
+export type GetDiscoverTvNetworkByNetworkIdResponses = {
+    /**
+     * Results
+     */
+    200: {
+        page?: number;
+        totalPages?: number;
+        totalResults?: number;
+        network?: Network;
+        results?: Array<TvResult>;
+    };
+};
+export type GetDiscoverTvNetworkByNetworkIdResponse = GetDiscoverTvNetworkByNetworkIdResponses[keyof GetDiscoverTvNetworkByNetworkIdResponses];
+export type GetDiscoverTvUpcomingData = {
+    body?: never;
+    path?: never;
+    query?: {
+        page?: number;
+        language?: string;
+    };
+    url: '/discover/tv/upcoming';
+};
+export type GetDiscoverTvUpcomingResponses = {
+    /**
+     * Results
+     */
+    200: {
+        page?: number;
+        totalPages?: number;
+        totalResults?: number;
+        results?: Array<TvResult>;
+    };
+};
+export type GetDiscoverTvUpcomingResponse = GetDiscoverTvUpcomingResponses[keyof GetDiscoverTvUpcomingResponses];
+export type GetDiscoverTrendingData = {
+    body?: never;
+    path?: never;
+    query?: {
+        page?: number;
+        language?: string;
+    };
+    url: '/discover/trending';
+};
+export type GetDiscoverTrendingResponses = {
+    /**
+     * Results
+     */
+    200: {
+        page?: number;
+        totalPages?: number;
+        totalResults?: number;
+        results?: Array<MovieResult | TvResult | PersonResult>;
+    };
+};
+export type GetDiscoverTrendingResponse = GetDiscoverTrendingResponses[keyof GetDiscoverTrendingResponses];
+export type GetDiscoverKeywordByKeywordIdMoviesData = {
+    body?: never;
+    path: {
+        keywordId: number;
+    };
+    query?: {
+        page?: number;
+        language?: string;
+    };
+    url: '/discover/keyword/{keywordId}/movies';
+};
+export type GetDiscoverKeywordByKeywordIdMoviesResponses = {
+    /**
+     * List of movies
+     */
+    200: {
+        page?: number;
+        totalPages?: number;
+        totalResults?: number;
+        results?: Array<MovieResult>;
+    };
+};
+export type GetDiscoverKeywordByKeywordIdMoviesResponse = GetDiscoverKeywordByKeywordIdMoviesResponses[keyof GetDiscoverKeywordByKeywordIdMoviesResponses];
+export type GetDiscoverGenresliderMovieData = {
+    body?: never;
+    path?: never;
+    query?: {
+        language?: string;
+    };
+    url: '/discover/genreslider/movie';
+};
+export type GetDiscoverGenresliderMovieResponses = {
+    /**
+     * Genre slider data returned
+     */
+    200: Array<{
+        id?: number;
+        backdrops?: Array<string>;
+        name?: string;
+    }>;
+};
+export type GetDiscoverGenresliderMovieResponse = GetDiscoverGenresliderMovieResponses[keyof GetDiscoverGenresliderMovieResponses];
+export type GetDiscoverGenresliderTvData = {
+    body?: never;
+    path?: never;
+    query?: {
+        language?: string;
+    };
+    url: '/discover/genreslider/tv';
+};
+export type GetDiscoverGenresliderTvResponses = {
+    /**
+     * Genre slider data returned
+     */
+    200: Array<{
+        id?: number;
+        backdrops?: Array<string>;
+        name?: string;
+    }>;
+};
+export type GetDiscoverGenresliderTvResponse = GetDiscoverGenresliderTvResponses[keyof GetDiscoverGenresliderTvResponses];
+export type GetDiscoverWatchlistData = {
+    body?: never;
+    path?: never;
+    query?: {
+        page?: number;
+    };
+    url: '/discover/watchlist';
+};
+export type GetDiscoverWatchlistResponses = {
+    /**
+     * Watchlist data returned
+     */
+    200: {
+        page?: number;
+        totalPages?: number;
+        totalResults?: number;
+        results?: Array<{
+            tmdbId?: number;
+            ratingKey?: string;
+            type?: string;
+            title?: string;
+        }>;
+    };
+};
+export type GetDiscoverWatchlistResponse = GetDiscoverWatchlistResponses[keyof GetDiscoverWatchlistResponses];
+export type GetRequestData = {
+    body?: never;
+    path?: never;
+    query?: {
+        take?: number | null;
+        skip?: number | null;
+        filter?: 'all' | 'approved' | 'available' | 'pending' | 'processing' | 'unavailable' | 'failed' | 'deleted' | 'completed';
+        sort?: 'added' | 'modified';
+        sortDirection?: 'asc' | 'desc';
+        requestedBy?: number | null;
+        mediaType?: 'movie' | 'tv' | 'all';
+    };
+    url: '/request';
+};
+export type GetRequestResponses = {
+    /**
+     * Requests returned
+     */
+    200: {
+        pageInfo?: PageInfo;
+        results?: Array<MediaRequest>;
+    };
+};
+export type GetRequestResponse = GetRequestResponses[keyof GetRequestResponses];
+export type PostRequestData = {
+    body: {
+        mediaType: 'movie' | 'tv';
+        mediaId: number;
+        tvdbId?: number;
+        seasons?: Array<number> | 'all';
+        is4k?: boolean;
+        serverId?: number;
+        profileId?: number;
+        rootFolder?: string;
+        languageProfileId?: number;
+        userId?: number | null;
+    };
+    path?: never;
+    query?: never;
+    url: '/request';
+};
+export type PostRequestResponses = {
+    /**
+     * Succesfully created the request
+     */
+    201: MediaRequest;
+};
+export type PostRequestResponse = PostRequestResponses[keyof PostRequestResponses];
+export type GetRequestCountData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/request/count';
+};
+export type GetRequestCountResponses = {
+    /**
+     * Request counts returned
+     */
+    200: {
+        total?: number;
+        movie?: number;
+        tv?: number;
+        pending?: number;
+        approved?: number;
+        declined?: number;
+        processing?: number;
+        available?: number;
+        completed?: number;
+    };
+};
+export type GetRequestCountResponse = GetRequestCountResponses[keyof GetRequestCountResponses];
+export type DeleteRequestByRequestIdData = {
+    body?: never;
+    path: {
+        /**
+         * Request ID
+         */
+        requestId: string;
+    };
+    query?: never;
+    url: '/request/{requestId}';
+};
+export type DeleteRequestByRequestIdResponses = {
+    /**
+     * Succesfully removed request
+     */
+    204: void;
+};
+export type DeleteRequestByRequestIdResponse = DeleteRequestByRequestIdResponses[keyof DeleteRequestByRequestIdResponses];
+export type GetRequestByRequestIdData = {
+    body?: never;
+    path: {
+        /**
+         * Request ID
+         */
+        requestId: string;
+    };
+    query?: never;
+    url: '/request/{requestId}';
+};
+export type GetRequestByRequestIdResponses = {
+    /**
+     * Succesfully returns request
+     */
+    200: MediaRequest;
+};
+export type GetRequestByRequestIdResponse = GetRequestByRequestIdResponses[keyof GetRequestByRequestIdResponses];
+export type PutRequestByRequestIdData = {
+    body: {
+        mediaType: 'movie' | 'tv';
+        seasons?: Array<number>;
+        is4k?: boolean;
+        serverId?: number;
+        profileId?: number;
+        rootFolder?: string;
+        languageProfileId?: number;
+        userId?: number | null;
+    };
+    path: {
+        /**
+         * Request ID
+         */
+        requestId: string;
+    };
+    query?: never;
+    url: '/request/{requestId}';
+};
+export type PutRequestByRequestIdResponses = {
+    /**
+     * Succesfully updated request
+     */
+    200: MediaRequest;
+};
+export type PutRequestByRequestIdResponse = PutRequestByRequestIdResponses[keyof PutRequestByRequestIdResponses];
+export type PostRequestByRequestIdRetryData = {
+    body?: never;
+    path: {
+        /**
+         * Request ID
+         */
+        requestId: string;
+    };
+    query?: never;
+    url: '/request/{requestId}/retry';
+};
+export type PostRequestByRequestIdRetryResponses = {
+    /**
+     * Retry triggered
+     */
+    200: MediaRequest;
+};
+export type PostRequestByRequestIdRetryResponse = PostRequestByRequestIdRetryResponses[keyof PostRequestByRequestIdRetryResponses];
+export type PostRequestByRequestIdByStatusData = {
+    body?: never;
+    path: {
+        /**
+         * Request ID
+         */
+        requestId: string;
+        /**
+         * New status
+         */
+        status: 'approve' | 'decline';
+    };
+    query?: never;
+    url: '/request/{requestId}/{status}';
+};
+export type PostRequestByRequestIdByStatusResponses = {
+    /**
+     * Request status changed
+     */
+    200: MediaRequest;
+};
+export type PostRequestByRequestIdByStatusResponse = PostRequestByRequestIdByStatusResponses[keyof PostRequestByRequestIdByStatusResponses];
+export type GetMovieByMovieIdData = {
+    body?: never;
+    path: {
+        movieId: number;
+    };
+    query?: {
+        language?: string;
+    };
+    url: '/movie/{movieId}';
+};
+export type GetMovieByMovieIdResponses = {
+    /**
+     * Movie details
+     */
+    200: MovieDetails;
+};
+export type GetMovieByMovieIdResponse = GetMovieByMovieIdResponses[keyof GetMovieByMovieIdResponses];
+export type GetMovieByMovieIdRecommendationsData = {
+    body?: never;
+    path: {
+        movieId: number;
+    };
+    query?: {
+        page?: number;
+        language?: string;
+    };
+    url: '/movie/{movieId}/recommendations';
+};
+export type GetMovieByMovieIdRecommendationsResponses = {
+    /**
+     * List of movies
+     */
+    200: {
+        page?: number;
+        totalPages?: number;
+        totalResults?: number;
+        results?: Array<MovieResult>;
+    };
+};
+export type GetMovieByMovieIdRecommendationsResponse = GetMovieByMovieIdRecommendationsResponses[keyof GetMovieByMovieIdRecommendationsResponses];
+export type GetMovieByMovieIdSimilarData = {
+    body?: never;
+    path: {
+        movieId: number;
+    };
+    query?: {
+        page?: number;
+        language?: string;
+    };
+    url: '/movie/{movieId}/similar';
+};
+export type GetMovieByMovieIdSimilarResponses = {
+    /**
+     * List of movies
+     */
+    200: {
+        page?: number;
+        totalPages?: number;
+        totalResults?: number;
+        results?: Array<MovieResult>;
+    };
+};
+export type GetMovieByMovieIdSimilarResponse = GetMovieByMovieIdSimilarResponses[keyof GetMovieByMovieIdSimilarResponses];
+export type GetMovieByMovieIdRatingsData = {
+    body?: never;
+    path: {
+        movieId: number;
+    };
+    query?: never;
+    url: '/movie/{movieId}/ratings';
+};
+export type GetMovieByMovieIdRatingsResponses = {
+    /**
+     * Ratings returned
+     */
+    200: {
+        title?: string;
+        year?: number;
+        url?: string;
+        criticsScore?: number;
+        criticsRating?: 'Rotten' | 'Fresh' | 'Certified Fresh';
+        audienceScore?: number;
+        audienceRating?: 'Spilled' | 'Upright';
+    };
+};
+export type GetMovieByMovieIdRatingsResponse = GetMovieByMovieIdRatingsResponses[keyof GetMovieByMovieIdRatingsResponses];
+export type GetMovieByMovieIdRatingscombinedData = {
+    body?: never;
+    path: {
+        movieId: number;
+    };
+    query?: never;
+    url: '/movie/{movieId}/ratingscombined';
+};
+export type GetMovieByMovieIdRatingscombinedResponses = {
+    /**
+     * Ratings returned
+     */
+    200: {
+        rt?: {
+            title?: string;
+            year?: number;
+            url?: string;
+            criticsScore?: number;
+            criticsRating?: 'Rotten' | 'Fresh' | 'Certified Fresh';
+            audienceScore?: number;
+            audienceRating?: 'Spilled' | 'Upright';
+        };
+        imdb?: {
+            title?: string;
+            url?: string;
+            criticsScore?: number;
+        };
+    };
+};
+export type GetMovieByMovieIdRatingscombinedResponse = GetMovieByMovieIdRatingscombinedResponses[keyof GetMovieByMovieIdRatingscombinedResponses];
+export type GetTvByTvIdData = {
+    body?: never;
+    path: {
+        tvId: number;
+    };
+    query?: {
+        language?: string;
+    };
+    url: '/tv/{tvId}';
+};
+export type GetTvByTvIdResponses = {
+    /**
+     * TV details
+     */
+    200: TvDetails;
+};
+export type GetTvByTvIdResponse = GetTvByTvIdResponses[keyof GetTvByTvIdResponses];
+export type GetTvByTvIdSeasonBySeasonNumberData = {
+    body?: never;
+    path: {
+        tvId: number;
+        seasonNumber: number;
+    };
+    query?: {
+        language?: string;
+    };
+    url: '/tv/{tvId}/season/{seasonNumber}';
+};
+export type GetTvByTvIdSeasonBySeasonNumberResponses = {
+    /**
+     * TV details
+     */
+    200: Season;
+};
+export type GetTvByTvIdSeasonBySeasonNumberResponse = GetTvByTvIdSeasonBySeasonNumberResponses[keyof GetTvByTvIdSeasonBySeasonNumberResponses];
+export type GetTvByTvIdRecommendationsData = {
+    body?: never;
+    path: {
+        tvId: number;
+    };
+    query?: {
+        page?: number;
+        language?: string;
+    };
+    url: '/tv/{tvId}/recommendations';
+};
+export type GetTvByTvIdRecommendationsResponses = {
+    /**
+     * List of TV series
+     */
+    200: {
+        page?: number;
+        totalPages?: number;
+        totalResults?: number;
+        results?: Array<TvResult>;
+    };
+};
+export type GetTvByTvIdRecommendationsResponse = GetTvByTvIdRecommendationsResponses[keyof GetTvByTvIdRecommendationsResponses];
+export type GetTvByTvIdSimilarData = {
+    body?: never;
+    path: {
+        tvId: number;
+    };
+    query?: {
+        page?: number;
+        language?: string;
+    };
+    url: '/tv/{tvId}/similar';
+};
+export type GetTvByTvIdSimilarResponses = {
+    /**
+     * List of TV series
+     */
+    200: {
+        page?: number;
+        totalPages?: number;
+        totalResults?: number;
+        results?: Array<TvResult>;
+    };
+};
+export type GetTvByTvIdSimilarResponse = GetTvByTvIdSimilarResponses[keyof GetTvByTvIdSimilarResponses];
+export type GetTvByTvIdRatingsData = {
+    body?: never;
+    path: {
+        tvId: number;
+    };
+    query?: never;
+    url: '/tv/{tvId}/ratings';
+};
+export type GetTvByTvIdRatingsResponses = {
+    /**
+     * Ratings returned
+     */
+    200: {
+        title?: string;
+        year?: number;
+        url?: string;
+        criticsScore?: number;
+        criticsRating?: 'Rotten' | 'Fresh';
+    };
+};
+export type GetTvByTvIdRatingsResponse = GetTvByTvIdRatingsResponses[keyof GetTvByTvIdRatingsResponses];
+export type GetPersonByPersonIdData = {
+    body?: never;
+    path: {
+        personId: number;
+    };
+    query?: {
+        language?: string;
+    };
+    url: '/person/{personId}';
+};
+export type GetPersonByPersonIdResponses = {
+    /**
+     * Returned person
+     */
+    200: PersonDetails;
+};
+export type GetPersonByPersonIdResponse = GetPersonByPersonIdResponses[keyof GetPersonByPersonIdResponses];
+export type GetPersonByPersonIdCombinedCreditsData = {
+    body?: never;
+    path: {
+        personId: number;
+    };
+    query?: {
+        language?: string;
+    };
+    url: '/person/{personId}/combined_credits';
+};
+export type GetPersonByPersonIdCombinedCreditsResponses = {
+    /**
+     * Returned combined credits
+     */
+    200: {
+        cast?: Array<CreditCast>;
+        crew?: Array<CreditCrew>;
+        id?: number;
+    };
+};
+export type GetPersonByPersonIdCombinedCreditsResponse = GetPersonByPersonIdCombinedCreditsResponses[keyof GetPersonByPersonIdCombinedCreditsResponses];
+export type GetMediaData = {
+    body?: never;
+    path?: never;
+    query?: {
+        take?: number | null;
+        skip?: number | null;
+        filter?: 'all' | 'available' | 'partial' | 'allavailable' | 'processing' | 'pending' | 'deleted';
+        sort?: 'added' | 'modified' | 'mediaAdded';
+    };
+    url: '/media';
+};
+export type GetMediaResponses = {
+    /**
+     * Returned media
+     */
+    200: {
+        pageInfo?: PageInfo;
+        results?: Array<MediaInfo>;
+    };
+};
+export type GetMediaResponse = GetMediaResponses[keyof GetMediaResponses];
+export type DeleteMediaByMediaIdData = {
+    body?: never;
+    path: {
+        /**
+         * Media ID
+         */
+        mediaId: string;
+    };
+    query?: never;
+    url: '/media/{mediaId}';
+};
+export type DeleteMediaByMediaIdResponses = {
+    /**
+     * Succesfully removed media item
+     */
+    204: void;
+};
+export type DeleteMediaByMediaIdResponse = DeleteMediaByMediaIdResponses[keyof DeleteMediaByMediaIdResponses];
+export type DeleteMediaByMediaIdFileData = {
+    body?: never;
+    path: {
+        /**
+         * Media ID
+         */
+        mediaId: string;
+    };
+    query?: {
+        /**
+         * Whether to remove from 4K service instance (true) or regular service instance (false)
+         */
+        is4k?: boolean;
+    };
+    url: '/media/{mediaId}/file';
+};
+export type DeleteMediaByMediaIdFileResponses = {
+    /**
+     * Successfully removed media item
+     */
+    204: void;
+};
+export type DeleteMediaByMediaIdFileResponse = DeleteMediaByMediaIdFileResponses[keyof DeleteMediaByMediaIdFileResponses];
+export type PostMediaByMediaIdByStatusData = {
+    body?: {
+        /**
+         * When true, updates the 4K status field (status4k).
+         * When false or not provided, updates the regular status field (status).
+         * This applies to all status values (available, partial, processing, pending, unknown).
+         *
+         */
+        is4k?: boolean;
+    };
+    path: {
+        /**
+         * Media ID
+         */
+        mediaId: string;
+        /**
+         * New status
+         */
+        status: 'available' | 'partial' | 'processing' | 'pending' | 'unknown' | 'deleted';
+    };
+    query?: never;
+    url: '/media/{mediaId}/{status}';
+};
+export type PostMediaByMediaIdByStatusResponses = {
+    /**
+     * Returned media
+     */
+    200: MediaInfo;
+};
+export type PostMediaByMediaIdByStatusResponse = PostMediaByMediaIdByStatusResponses[keyof PostMediaByMediaIdByStatusResponses];
+export type GetMediaByMediaIdWatchDataData = {
+    body?: never;
+    path: {
+        /**
+         * Media ID
+         */
+        mediaId: string;
+    };
+    query?: never;
+    url: '/media/{mediaId}/watch_data';
+};
+export type GetMediaByMediaIdWatchDataResponses = {
+    /**
+     * Users
+     */
+    200: {
+        data?: {
+            playCount7Days?: number;
+            playCount30Days?: number;
+            playCount?: number;
+            users?: Array<User>;
+        };
+        data4k?: {
+            playCount7Days?: number;
+            playCount30Days?: number;
+            playCount?: number;
+            users?: Array<User>;
+        };
+    };
+};
+export type GetMediaByMediaIdWatchDataResponse = GetMediaByMediaIdWatchDataResponses[keyof GetMediaByMediaIdWatchDataResponses];
+export type GetCollectionByCollectionIdData = {
+    body?: never;
+    path: {
+        collectionId: number;
+    };
+    query?: {
+        language?: string;
+    };
+    url: '/collection/{collectionId}';
+};
+export type GetCollectionByCollectionIdResponses = {
+    /**
+     * Collection details
+     */
+    200: Collection;
+};
+export type GetCollectionByCollectionIdResponse = GetCollectionByCollectionIdResponses[keyof GetCollectionByCollectionIdResponses];
+export type GetServiceRadarrData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/service/radarr';
+};
+export type GetServiceRadarrResponses = {
+    /**
+     * Request successful
+     */
+    200: Array<RadarrSettings>;
+};
+export type GetServiceRadarrResponse = GetServiceRadarrResponses[keyof GetServiceRadarrResponses];
+export type GetServiceRadarrByRadarrIdData = {
+    body?: never;
+    path: {
+        radarrId: number;
+    };
+    query?: never;
+    url: '/service/radarr/{radarrId}';
+};
+export type GetServiceRadarrByRadarrIdResponses = {
+    /**
+     * Request successful
+     */
+    200: {
+        server?: RadarrSettings;
+        profiles?: ServiceProfile;
+    };
+};
+export type GetServiceRadarrByRadarrIdResponse = GetServiceRadarrByRadarrIdResponses[keyof GetServiceRadarrByRadarrIdResponses];
+export type GetServiceSonarrData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/service/sonarr';
+};
+export type GetServiceSonarrResponses = {
+    /**
+     * Request successful
+     */
+    200: Array<SonarrSettings>;
+};
+export type GetServiceSonarrResponse = GetServiceSonarrResponses[keyof GetServiceSonarrResponses];
+export type GetServiceSonarrBySonarrIdData = {
+    body?: never;
+    path: {
+        sonarrId: number;
+    };
+    query?: never;
+    url: '/service/sonarr/{sonarrId}';
+};
+export type GetServiceSonarrBySonarrIdResponses = {
+    /**
+     * Request successful
+     */
+    200: {
+        server?: SonarrSettings;
+        profiles?: ServiceProfile;
+    };
+};
+export type GetServiceSonarrBySonarrIdResponse = GetServiceSonarrBySonarrIdResponses[keyof GetServiceSonarrBySonarrIdResponses];
+export type GetServiceSonarrLookupByTmdbIdData = {
+    body?: never;
+    path: {
+        tmdbId: number;
+    };
+    query?: never;
+    url: '/service/sonarr/lookup/{tmdbId}';
+};
+export type GetServiceSonarrLookupByTmdbIdResponses = {
+    /**
+     * Request successful
+     */
+    200: Array<SonarrSeries>;
+};
+export type GetServiceSonarrLookupByTmdbIdResponse = GetServiceSonarrLookupByTmdbIdResponses[keyof GetServiceSonarrLookupByTmdbIdResponses];
+export type GetRegionsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/regions';
+};
+export type GetRegionsResponses = {
+    /**
+     * Results
+     */
+    200: Array<{
+        iso_3166_1?: string;
+        english_name?: string;
+    }>;
+};
+export type GetRegionsResponse = GetRegionsResponses[keyof GetRegionsResponses];
+export type GetLanguagesData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/languages';
+};
+export type GetLanguagesResponses = {
+    /**
+     * Results
+     */
+    200: Array<{
+        iso_639_1?: string;
+        english_name?: string;
+        name?: string;
+    }>;
+};
+export type GetLanguagesResponse = GetLanguagesResponses[keyof GetLanguagesResponses];
+export type GetStudioByStudioIdData = {
+    body?: never;
+    path: {
+        studioId: number;
+    };
+    query?: never;
+    url: '/studio/{studioId}';
+};
+export type GetStudioByStudioIdResponses = {
+    /**
+     * Movie studio details
+     */
+    200: ProductionCompany;
+};
+export type GetStudioByStudioIdResponse = GetStudioByStudioIdResponses[keyof GetStudioByStudioIdResponses];
+export type GetNetworkByNetworkIdData = {
+    body?: never;
+    path: {
+        networkId: number;
+    };
+    query?: never;
+    url: '/network/{networkId}';
+};
+export type GetNetworkByNetworkIdResponses = {
+    /**
+     * TV network details
+     */
+    200: ProductionCompany;
+};
+export type GetNetworkByNetworkIdResponse = GetNetworkByNetworkIdResponses[keyof GetNetworkByNetworkIdResponses];
+export type GetGenresMovieData = {
+    body?: never;
+    path?: never;
+    query?: {
+        language?: string;
+    };
+    url: '/genres/movie';
+};
+export type GetGenresMovieResponses = {
+    /**
+     * Results
+     */
+    200: Array<{
+        id?: number;
+        name?: string;
+    }>;
+};
+export type GetGenresMovieResponse = GetGenresMovieResponses[keyof GetGenresMovieResponses];
+export type GetGenresTvData = {
+    body?: never;
+    path?: never;
+    query?: {
+        language?: string;
+    };
+    url: '/genres/tv';
+};
+export type GetGenresTvResponses = {
+    /**
+     * Results
+     */
+    200: Array<{
+        id?: number;
+        name?: string;
+    }>;
+};
+export type GetGenresTvResponse = GetGenresTvResponses[keyof GetGenresTvResponses];
+export type GetBackdropsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/backdrops';
+};
+export type GetBackdropsResponses = {
+    /**
+     * Results
+     */
+    200: Array<string>;
+};
+export type GetBackdropsResponse = GetBackdropsResponses[keyof GetBackdropsResponses];
+export type GetIssueData = {
+    body?: never;
+    path?: never;
+    query?: {
+        take?: number | null;
+        skip?: number | null;
+        sort?: 'added' | 'modified';
+        filter?: 'all' | 'open' | 'resolved';
+        requestedBy?: number | null;
+    };
+    url: '/issue';
+};
+export type GetIssueResponses = {
+    /**
+     * Issues returned
+     */
+    200: {
+        pageInfo?: PageInfo;
+        results?: Array<Issue>;
+    };
+};
+export type GetIssueResponse = GetIssueResponses[keyof GetIssueResponses];
+export type PostIssueData = {
+    body: {
+        issueType?: number;
+        message?: string;
+        mediaId?: number;
+    };
+    path?: never;
+    query?: never;
+    url: '/issue';
+};
+export type PostIssueResponses = {
+    /**
+     * Succesfully created the issue
+     */
+    201: Issue;
+};
+export type PostIssueResponse = PostIssueResponses[keyof PostIssueResponses];
+export type GetIssueCountData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/issue/count';
+};
+export type GetIssueCountResponses = {
+    /**
+     * Issue counts returned
+     */
+    200: {
+        total?: number;
+        video?: number;
+        audio?: number;
+        subtitles?: number;
+        others?: number;
+        open?: number;
+        closed?: number;
+    };
+};
+export type GetIssueCountResponse = GetIssueCountResponses[keyof GetIssueCountResponses];
+export type DeleteIssueByIssueIdData = {
+    body?: never;
+    path: {
+        /**
+         * Issue ID
+         */
+        issueId: string;
+    };
+    query?: never;
+    url: '/issue/{issueId}';
+};
+export type DeleteIssueByIssueIdResponses = {
+    /**
+     * Succesfully removed issue
+     */
+    204: void;
+};
+export type DeleteIssueByIssueIdResponse = DeleteIssueByIssueIdResponses[keyof DeleteIssueByIssueIdResponses];
+export type GetIssueByIssueIdData = {
+    body?: never;
+    path: {
+        issueId: number;
+    };
+    query?: never;
+    url: '/issue/{issueId}';
+};
+export type GetIssueByIssueIdResponses = {
+    /**
+     * Issues returned
+     */
+    200: Issue;
+};
+export type GetIssueByIssueIdResponse = GetIssueByIssueIdResponses[keyof GetIssueByIssueIdResponses];
+export type PostIssueByIssueIdCommentData = {
+    body: {
+        message: string;
+    };
+    path: {
+        issueId: number;
+    };
+    query?: never;
+    url: '/issue/{issueId}/comment';
+};
+export type PostIssueByIssueIdCommentResponses = {
+    /**
+     * Issue returned with new comment
+     */
+    200: Issue;
+};
+export type PostIssueByIssueIdCommentResponse = PostIssueByIssueIdCommentResponses[keyof PostIssueByIssueIdCommentResponses];
+export type DeleteIssueCommentByCommentIdData = {
+    body?: never;
+    path: {
+        /**
+         * Issue Comment ID
+         */
+        commentId: string;
+    };
+    query?: never;
+    url: '/issueComment/{commentId}';
+};
+export type DeleteIssueCommentByCommentIdResponses = {
+    /**
+     * Succesfully removed issue comment
+     */
+    204: void;
+};
+export type DeleteIssueCommentByCommentIdResponse = DeleteIssueCommentByCommentIdResponses[keyof DeleteIssueCommentByCommentIdResponses];
+export type GetIssueCommentByCommentIdData = {
+    body?: never;
+    path: {
+        commentId: string;
+    };
+    query?: never;
+    url: '/issueComment/{commentId}';
+};
+export type GetIssueCommentByCommentIdResponses = {
+    /**
+     * Comment returned
+     */
+    200: IssueComment;
+};
+export type GetIssueCommentByCommentIdResponse = GetIssueCommentByCommentIdResponses[keyof GetIssueCommentByCommentIdResponses];
+export type PutIssueCommentByCommentIdData = {
+    body: {
+        message?: string;
+    };
+    path: {
+        commentId: string;
+    };
+    query?: never;
+    url: '/issueComment/{commentId}';
+};
+export type PutIssueCommentByCommentIdResponses = {
+    /**
+     * Comment updated
+     */
+    200: IssueComment;
+};
+export type PutIssueCommentByCommentIdResponse = PutIssueCommentByCommentIdResponses[keyof PutIssueCommentByCommentIdResponses];
+export type PostIssueByIssueIdByStatusData = {
+    body?: never;
+    path: {
+        /**
+         * Issue ID
+         */
+        issueId: string;
+        /**
+         * New status
+         */
+        status: 'open' | 'resolved';
+    };
+    query?: never;
+    url: '/issue/{issueId}/{status}';
+};
+export type PostIssueByIssueIdByStatusResponses = {
+    /**
+     * Issue status changed
+     */
+    200: Issue;
+};
+export type PostIssueByIssueIdByStatusResponse = PostIssueByIssueIdByStatusResponses[keyof PostIssueByIssueIdByStatusResponses];
+export type GetKeywordByKeywordIdData = {
+    body?: never;
+    path: {
+        keywordId: number;
+    };
+    query?: never;
+    url: '/keyword/{keywordId}';
+};
+export type GetKeywordByKeywordIdErrors = {
+    /**
+     * Internal server error
+     */
+    500: {
+        message?: string;
+    };
+};
+export type GetKeywordByKeywordIdError = GetKeywordByKeywordIdErrors[keyof GetKeywordByKeywordIdErrors];
+export type GetKeywordByKeywordIdResponses = {
+    /**
+     * Keyword returned (null if not found)
+     */
+    200: Keyword;
+};
+export type GetKeywordByKeywordIdResponse = GetKeywordByKeywordIdResponses[keyof GetKeywordByKeywordIdResponses];
+export type GetWatchprovidersRegionsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/watchproviders/regions';
+};
+export type GetWatchprovidersRegionsResponses = {
+    /**
+     * Watch provider regions returned
+     */
+    200: Array<WatchProviderRegion>;
+};
+export type GetWatchprovidersRegionsResponse = GetWatchprovidersRegionsResponses[keyof GetWatchprovidersRegionsResponses];
+export type GetWatchprovidersMoviesData = {
+    body?: never;
+    path?: never;
+    query: {
+        watchRegion: string;
+    };
+    url: '/watchproviders/movies';
+};
+export type GetWatchprovidersMoviesResponses = {
+    /**
+     * Watch providers for movies returned
+     */
+    200: Array<WatchProviderDetails>;
+};
+export type GetWatchprovidersMoviesResponse = GetWatchprovidersMoviesResponses[keyof GetWatchprovidersMoviesResponses];
+export type GetWatchprovidersTvData = {
+    body?: never;
+    path?: never;
+    query: {
+        watchRegion: string;
+    };
+    url: '/watchproviders/tv';
+};
+export type GetWatchprovidersTvResponses = {
+    /**
+     * Watch providers for series returned
+     */
+    200: Array<WatchProviderDetails>;
+};
+export type GetWatchprovidersTvResponse = GetWatchprovidersTvResponses[keyof GetWatchprovidersTvResponses];
+export type GetCertificationsMovieData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/certifications/movie';
+};
+export type GetCertificationsMovieErrors = {
+    /**
+     * Unable to retrieve movie certifications
+     */
+    500: {
+        status?: number;
+        message?: string;
+    };
+};
+export type GetCertificationsMovieError = GetCertificationsMovieErrors[keyof GetCertificationsMovieErrors];
+export type GetCertificationsMovieResponses = {
+    /**
+     * Movie certifications returned
+     */
+    200: CertificationResponse;
+};
+export type GetCertificationsMovieResponse = GetCertificationsMovieResponses[keyof GetCertificationsMovieResponses];
+export type GetCertificationsTvData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/certifications/tv';
+};
+export type GetCertificationsTvErrors = {
+    /**
+     * Unable to retrieve TV certifications
+     */
+    500: {
+        status?: number;
+        message?: string;
+    };
+};
+export type GetCertificationsTvError = GetCertificationsTvErrors[keyof GetCertificationsTvErrors];
+export type GetCertificationsTvResponses = {
+    /**
+     * TV certifications returned
+     */
+    200: CertificationResponse;
+};
+export type GetCertificationsTvResponse = GetCertificationsTvResponses[keyof GetCertificationsTvResponses];
+export type GetOverrideRuleData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/overrideRule';
+};
+export type GetOverrideRuleResponses = {
+    /**
+     * Override rules returned
+     */
+    200: Array<OverrideRule>;
+};
+export type GetOverrideRuleResponse = GetOverrideRuleResponses[keyof GetOverrideRuleResponses];
+export type PostOverrideRuleData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/overrideRule';
+};
+export type PostOverrideRuleResponses = {
+    /**
+     * Values were successfully created
+     */
+    200: Array<OverrideRule>;
+};
+export type PostOverrideRuleResponse = PostOverrideRuleResponses[keyof PostOverrideRuleResponses];
+export type DeleteOverrideRuleByRuleIdData = {
+    body?: never;
+    path: {
+        ruleId: number;
+    };
+    query?: never;
+    url: '/overrideRule/{ruleId}';
+};
+export type DeleteOverrideRuleByRuleIdResponses = {
+    /**
+     * Override rule successfully deleted
+     */
+    200: OverrideRule;
+};
+export type DeleteOverrideRuleByRuleIdResponse = DeleteOverrideRuleByRuleIdResponses[keyof DeleteOverrideRuleByRuleIdResponses];
+export type PutOverrideRuleByRuleIdData = {
+    body?: never;
+    path: {
+        ruleId: number;
+    };
+    query?: never;
+    url: '/overrideRule/{ruleId}';
+};
+export type PutOverrideRuleByRuleIdResponses = {
+    /**
+     * Values were successfully updated
+     */
+    200: Array<OverrideRule>;
+};
+export type PutOverrideRuleByRuleIdResponse = PutOverrideRuleByRuleIdResponses[keyof PutOverrideRuleByRuleIdResponses];
+//# sourceMappingURL=types.gen.d.ts.map