import { b as ClientMethods, a as PaginationOptions, P as PaginatedResponse, B as BaseClient, C as ClientConfig } from '../client-Me0HpgXr.cjs';

type components = {
    schemas: {
        /** @enum {string} */
        AddMovieMethod: "manual" | "list" | "collection";
        AddMovieOptions: {
            addMethod?: components["schemas"]["AddMovieMethod"];
            ignoreEpisodesWithFiles?: boolean;
            ignoreEpisodesWithoutFiles?: boolean;
            monitor?: components["schemas"]["MonitorTypes"];
            searchForMovie?: boolean;
        };
        AlternativeTitleResource: {
            cleanTitle?: string | null;
            /** Format: int32 */
            id?: number;
            /** Format: int32 */
            movieMetadataId?: number;
            sourceType?: components["schemas"]["SourceType"];
            title?: string | null;
        };
        ApiInfoResource: {
            current?: string | null;
            deprecated?: string[] | null;
        };
        /** @enum {string} */
        ApplyTags: "add" | "remove" | "replace";
        /** @enum {string} */
        AuthenticationRequiredType: "enabled" | "disabledForLocalAddresses";
        /** @enum {string} */
        AuthenticationType: "none" | "basic" | "forms" | "external";
        AutoTaggingResource: {
            /** Format: int32 */
            id?: number;
            name?: string | null;
            removeTagsAutomatically?: boolean;
            specifications?: components["schemas"]["AutoTaggingSpecificationSchema"][] | null;
            tags?: number[] | null;
        };
        AutoTaggingSpecificationSchema: {
            fields?: components["schemas"]["Field"][] | null;
            /** Format: int32 */
            id?: number;
            implementation?: string | null;
            implementationName?: string | null;
            name?: string | null;
            negate?: boolean;
            required?: boolean;
        };
        BackupResource: {
            /** Format: int32 */
            id?: number;
            name?: string | null;
            path?: string | null;
            /** Format: int64 */
            size?: number;
            /** Format: date-time */
            time?: string;
            type?: components["schemas"]["BackupType"];
        };
        /** @enum {string} */
        BackupType: "scheduled" | "manual" | "update";
        BlocklistBulkResource: {
            ids?: number[] | null;
        };
        BlocklistResource: {
            customFormats?: components["schemas"]["CustomFormatResource"][] | null;
            /** Format: date-time */
            date?: string;
            /** Format: int32 */
            id?: number;
            indexer?: string | null;
            languages?: components["schemas"]["Language"][] | null;
            message?: string | null;
            movie?: components["schemas"]["MovieResource"];
            /** Format: int32 */
            movieId?: number;
            protocol?: components["schemas"]["DownloadProtocol"];
            quality?: components["schemas"]["QualityModel"];
            sourceTitle?: string | null;
        };
        BlocklistResourcePagingResource: {
            /** Format: int32 */
            page?: number;
            /** Format: int32 */
            pageSize?: number;
            records?: components["schemas"]["BlocklistResource"][] | null;
            sortDirection?: components["schemas"]["SortDirection"];
            sortKey?: string | null;
            /** Format: int32 */
            totalRecords?: number;
        };
        /** @enum {string} */
        CalendarReleaseType: "cinemaRelease" | "digitalRelease" | "physicalRelease";
        /** @enum {string} */
        CertificateValidationType: "enabled" | "disabledForLocalAddresses" | "disabled";
        CollectionMovieResource: {
            cleanTitle?: string | null;
            folder?: string | null;
            genres?: string[] | null;
            images?: components["schemas"]["MediaCover"][] | null;
            imdbId?: string | null;
            isExcluded?: boolean;
            isExisting?: boolean;
            overview?: string | null;
            ratings?: components["schemas"]["Ratings"];
            /** Format: int32 */
            runtime?: number;
            sortTitle?: string | null;
            status?: components["schemas"]["MovieStatusType"];
            title?: string | null;
            /** Format: int32 */
            tmdbId?: number;
            /** Format: int32 */
            year?: number;
        };
        CollectionResource: {
            /** Format: int32 */
            id?: number;
            images?: components["schemas"]["MediaCover"][] | null;
            minimumAvailability?: components["schemas"]["MovieStatusType"];
            /** Format: int32 */
            missingMovies?: number;
            monitored?: boolean;
            movies?: components["schemas"]["CollectionMovieResource"][] | null;
            overview?: string | null;
            /** Format: int32 */
            qualityProfileId?: number;
            rootFolderPath?: string | null;
            searchOnAdd?: boolean;
            sortTitle?: string | null;
            tags?: number[] | null;
            title?: string | null;
            /** Format: int32 */
            tmdbId?: number;
        };
        CollectionUpdateResource: {
            collectionIds?: number[] | null;
            minimumAvailability?: components["schemas"]["MovieStatusType"];
            monitored?: boolean | null;
            monitorMovies?: boolean | null;
            /** Format: int32 */
            qualityProfileId?: number | null;
            rootFolderPath?: string | null;
            searchOnAdd?: boolean | null;
        };
        /** @enum {string} */
        ColonReplacementFormat: "delete" | "dash" | "spaceDash" | "spaceDashSpace" | "smart";
        Command: {
            clientUserAgent?: string | null;
            readonly completionMessage?: string | null;
            readonly isExclusive?: boolean;
            readonly isLongRunning?: boolean;
            readonly isTypeExclusive?: boolean;
            /** Format: date-time */
            lastExecutionTime?: string | null;
            /** Format: date-time */
            lastStartTime?: string | null;
            readonly name?: string | null;
            readonly requiresDiskAccess?: boolean;
            sendUpdatesToClient?: boolean;
            suppressMessages?: boolean;
            trigger?: components["schemas"]["CommandTrigger"];
            readonly updateScheduledTask?: boolean;
        };
        /** @enum {string} */
        CommandPriority: "normal" | "high" | "low";
        CommandResource: {
            body?: components["schemas"]["Command"];
            clientUserAgent?: string | null;
            commandName?: string | null;
            /** Format: date-span */
            duration?: string | null;
            /** Format: date-time */
            ended?: string | null;
            exception?: string | null;
            /** Format: int32 */
            id?: number;
            /** Format: date-time */
            lastExecutionTime?: string | null;
            message?: string | null;
            name?: string | null;
            priority?: components["schemas"]["CommandPriority"];
            /** Format: date-time */
            queued?: string;
            result?: components["schemas"]["CommandResult"];
            sendUpdatesToClient?: boolean;
            /** Format: date-time */
            started?: string | null;
            /** Format: date-time */
            stateChangeTime?: string | null;
            status?: components["schemas"]["CommandStatus"];
            trigger?: components["schemas"]["CommandTrigger"];
            updateScheduledTask?: boolean;
        };
        /** @enum {string} */
        CommandResult: "unknown" | "successful" | "unsuccessful";
        /** @enum {string} */
        CommandStatus: "queued" | "started" | "completed" | "failed" | "aborted" | "cancelled" | "orphaned";
        /** @enum {string} */
        CommandTrigger: "unspecified" | "manual" | "scheduled";
        CreditResource: {
            character?: string | null;
            creditTmdbId?: string | null;
            department?: string | null;
            /** Format: int32 */
            id?: number;
            images?: components["schemas"]["MediaCover"][] | null;
            job?: string | null;
            /** Format: int32 */
            movieMetadataId?: number;
            /** Format: int32 */
            order?: number;
            personName?: string | null;
            /** Format: int32 */
            personTmdbId?: number;
            type?: components["schemas"]["CreditType"];
        };
        /** @enum {string} */
        CreditType: "cast" | "crew";
        CustomFilterResource: {
            filters?: {
                [key: string]: unknown;
            }[] | null;
            /** Format: int32 */
            id?: number;
            label?: string | null;
            type?: string | null;
        };
        CustomFormatBulkResource: {
            ids?: number[] | null;
            includeCustomFormatWhenRenaming?: boolean | null;
        };
        CustomFormatResource: {
            /** Format: int32 */
            id?: number;
            includeCustomFormatWhenRenaming?: boolean | null;
            name?: string | null;
            specifications?: components["schemas"]["CustomFormatSpecificationSchema"][] | null;
        };
        CustomFormatSpecificationSchema: {
            fields?: components["schemas"]["Field"][] | null;
            /** Format: int32 */
            id?: number;
            implementation?: string | null;
            implementationName?: string | null;
            infoLink?: string | null;
            name?: string | null;
            negate?: boolean;
            presets?: components["schemas"]["CustomFormatSpecificationSchema"][] | null;
            required?: boolean;
        };
        /** @enum {string} */
        DatabaseType: "sqLite" | "postgreSQL";
        DelayProfileResource: {
            bypassIfAboveCustomFormatScore?: boolean;
            bypassIfHighestQuality?: boolean;
            enableTorrent?: boolean;
            enableUsenet?: boolean;
            /** Format: int32 */
            id?: number;
            /** Format: int32 */
            minimumCustomFormatScore?: number;
            /** Format: int32 */
            order?: number;
            preferredProtocol?: components["schemas"]["DownloadProtocol"];
            tags?: number[] | null;
            /** Format: int32 */
            torrentDelay?: number;
            /** Format: int32 */
            usenetDelay?: number;
        };
        DiskSpaceResource: {
            /** Format: int64 */
            freeSpace?: number;
            /** Format: int32 */
            id?: number;
            label?: string | null;
            path?: string | null;
            /** Format: int64 */
            totalSpace?: number;
        };
        DownloadClientBulkResource: {
            applyTags?: components["schemas"]["ApplyTags"];
            enable?: boolean | null;
            ids?: number[] | null;
            /** Format: int32 */
            priority?: number | null;
            removeCompletedDownloads?: boolean | null;
            removeFailedDownloads?: boolean | null;
            tags?: number[] | null;
        };
        DownloadClientConfigResource: {
            autoRedownloadFailed?: boolean;
            autoRedownloadFailedFromInteractiveSearch?: boolean;
            /** Format: int32 */
            checkForFinishedDownloadInterval?: number;
            downloadClientWorkingFolders?: string | null;
            enableCompletedDownloadHandling?: boolean;
            /** Format: int32 */
            id?: number;
        };
        DownloadClientResource: {
            configContract?: string | null;
            enable?: boolean;
            fields?: components["schemas"]["Field"][] | null;
            /** Format: int32 */
            id?: number;
            implementation?: string | null;
            implementationName?: string | null;
            infoLink?: string | null;
            message?: components["schemas"]["ProviderMessage"];
            name?: string | null;
            presets?: components["schemas"]["DownloadClientResource"][] | null;
            /** Format: int32 */
            priority?: number;
            protocol?: components["schemas"]["DownloadProtocol"];
            removeCompletedDownloads?: boolean;
            removeFailedDownloads?: boolean;
            tags?: number[] | null;
        };
        /** @enum {string} */
        DownloadProtocol: "unknown" | "usenet" | "torrent";
        ExtraFileResource: {
            extension?: string | null;
            /** Format: int32 */
            id?: number;
            languageTags?: string[] | null;
            /** Format: int32 */
            movieFileId?: number | null;
            /** Format: int32 */
            movieId?: number;
            relativePath?: string | null;
            title?: string | null;
            type?: components["schemas"]["ExtraFileType"];
        };
        /** @enum {string} */
        ExtraFileType: "subtitle" | "metadata" | "other";
        Field: {
            advanced?: boolean;
            helpLink?: string | null;
            helpText?: string | null;
            helpTextWarning?: string | null;
            hidden?: string | null;
            isFloat?: boolean;
            label?: string | null;
            name?: string | null;
            /** Format: int32 */
            order?: number;
            placeholder?: string | null;
            privacy?: components["schemas"]["PrivacyLevel"];
            section?: string | null;
            selectOptions?: components["schemas"]["SelectOption"][] | null;
            selectOptionsProviderAction?: string | null;
            type?: string | null;
            unit?: string | null;
            value?: unknown;
        };
        /** @enum {string} */
        FileDateType: "none" | "cinemas" | "release";
        /** @enum {string} */
        HealthCheckResult: "ok" | "notice" | "warning" | "error";
        HealthResource: {
            /** Format: int32 */
            id?: number;
            message?: string | null;
            source?: string | null;
            type?: components["schemas"]["HealthCheckResult"];
            wikiUrl?: string | null;
        };
        HistoryResource: {
            customFormats?: components["schemas"]["CustomFormatResource"][] | null;
            /** Format: int32 */
            customFormatScore?: number;
            data?: {
                [key: string]: string | null;
            } | null;
            /** Format: date-time */
            date?: string;
            downloadId?: string | null;
            eventType?: components["schemas"]["MovieHistoryEventType"];
            /** Format: int32 */
            id?: number;
            languages?: components["schemas"]["Language"][] | null;
            movie?: components["schemas"]["MovieResource"];
            /** Format: int32 */
            movieId?: number;
            quality?: components["schemas"]["QualityModel"];
            qualityCutoffNotMet?: boolean;
            sourceTitle?: string | null;
        };
        HistoryResourcePagingResource: {
            /** Format: int32 */
            page?: number;
            /** Format: int32 */
            pageSize?: number;
            records?: components["schemas"]["HistoryResource"][] | null;
            sortDirection?: components["schemas"]["SortDirection"];
            sortKey?: string | null;
            /** Format: int32 */
            totalRecords?: number;
        };
        HostConfigResource: {
            analyticsEnabled?: boolean;
            apiKey?: string | null;
            applicationUrl?: string | null;
            authenticationMethod?: components["schemas"]["AuthenticationType"];
            authenticationRequired?: components["schemas"]["AuthenticationRequiredType"];
            backupFolder?: string | null;
            /** Format: int32 */
            backupInterval?: number;
            /** Format: int32 */
            backupRetention?: number;
            bindAddress?: string | null;
            branch?: string | null;
            certificateValidation?: components["schemas"]["CertificateValidationType"];
            consoleLogLevel?: string | null;
            enableSsl?: boolean;
            /** Format: int32 */
            id?: number;
            instanceName?: string | null;
            launchBrowser?: boolean;
            logLevel?: string | null;
            /** Format: int32 */
            logSizeLimit?: number;
            password?: string | null;
            passwordConfirmation?: string | null;
            /** Format: int32 */
            port?: number;
            proxyBypassFilter?: string | null;
            proxyBypassLocalAddresses?: boolean;
            proxyEnabled?: boolean;
            proxyHostname?: string | null;
            proxyPassword?: string | null;
            /** Format: int32 */
            proxyPort?: number;
            proxyType?: components["schemas"]["ProxyType"];
            proxyUsername?: string | null;
            sslCertPassword?: string | null;
            sslCertPath?: string | null;
            /** Format: int32 */
            sslPort?: number;
            trustCgnatIpAddresses?: boolean;
            updateAutomatically?: boolean;
            updateMechanism?: components["schemas"]["UpdateMechanism"];
            updateScriptPath?: string | null;
            urlBase?: string | null;
            username?: string | null;
        };
        ImportListBulkResource: {
            applyTags?: components["schemas"]["ApplyTags"];
            enableAuto?: boolean | null;
            enabled?: boolean | null;
            ids?: number[] | null;
            minimumAvailability?: components["schemas"]["MovieStatusType"];
            /** Format: int32 */
            qualityProfileId?: number | null;
            rootFolderPath?: string | null;
            tags?: number[] | null;
        };
        ImportListConfigResource: {
            /** Format: int32 */
            id?: number;
            listSyncLevel?: string | null;
        };
        ImportListExclusionBulkResource: {
            ids?: number[] | null;
        };
        ImportListExclusionResource: {
            configContract?: string | null;
            fields?: components["schemas"]["Field"][] | null;
            /** Format: int32 */
            id?: number;
            implementation?: string | null;
            implementationName?: string | null;
            infoLink?: string | null;
            message?: components["schemas"]["ProviderMessage"];
            movieTitle?: string | null;
            /** Format: int32 */
            movieYear?: number;
            name?: string | null;
            presets?: components["schemas"]["ImportListExclusionResource"][] | null;
            tags?: number[] | null;
            /** Format: int32 */
            tmdbId?: number;
        };
        ImportListExclusionResourcePagingResource: {
            /** Format: int32 */
            page?: number;
            /** Format: int32 */
            pageSize?: number;
            records?: components["schemas"]["ImportListExclusionResource"][] | null;
            sortDirection?: components["schemas"]["SortDirection"];
            sortKey?: string | null;
            /** Format: int32 */
            totalRecords?: number;
        };
        ImportListResource: {
            configContract?: string | null;
            enableAuto?: boolean;
            enabled?: boolean;
            fields?: components["schemas"]["Field"][] | null;
            /** Format: int32 */
            id?: number;
            implementation?: string | null;
            implementationName?: string | null;
            infoLink?: string | null;
            /** Format: int32 */
            listOrder?: number;
            listType?: components["schemas"]["ImportListType"];
            message?: components["schemas"]["ProviderMessage"];
            minimumAvailability?: components["schemas"]["MovieStatusType"];
            /** Format: date-span */
            minRefreshInterval?: string;
            monitor?: components["schemas"]["MonitorTypes"];
            name?: string | null;
            presets?: components["schemas"]["ImportListResource"][] | null;
            /** Format: int32 */
            qualityProfileId?: number;
            rootFolderPath?: string | null;
            searchOnAdd?: boolean;
            tags?: number[] | null;
        };
        /** @enum {string} */
        ImportListType: "program" | "tmdb" | "trakt" | "plex" | "simkl" | "other" | "advanced";
        ImportRejectionResource: {
            reason?: string | null;
            type?: components["schemas"]["RejectionType"];
        };
        IndexerBulkResource: {
            applyTags?: components["schemas"]["ApplyTags"];
            enableAutomaticSearch?: boolean | null;
            enableInteractiveSearch?: boolean | null;
            enableRss?: boolean | null;
            ids?: number[] | null;
            /** Format: int32 */
            priority?: number | null;
            tags?: number[] | null;
        };
        IndexerConfigResource: {
            allowHardcodedSubs?: boolean;
            /** Format: int32 */
            availabilityDelay?: number;
            /** Format: int32 */
            id?: number;
            /** Format: int32 */
            maximumSize?: number;
            /** Format: int32 */
            minimumAge?: number;
            preferIndexerFlags?: boolean;
            /** Format: int32 */
            retention?: number;
            /** Format: int32 */
            rssSyncInterval?: number;
            whitelistedHardcodedSubs?: string | null;
        };
        IndexerFlagResource: {
            /** Format: int32 */
            id?: number;
            name?: string | null;
            readonly nameLower?: string | null;
        };
        IndexerResource: {
            configContract?: string | null;
            /** Format: int32 */
            downloadClientId?: number;
            enableAutomaticSearch?: boolean;
            enableInteractiveSearch?: boolean;
            enableRss?: boolean;
            fields?: components["schemas"]["Field"][] | null;
            /** Format: int32 */
            id?: number;
            implementation?: string | null;
            implementationName?: string | null;
            infoLink?: string | null;
            message?: components["schemas"]["ProviderMessage"];
            name?: string | null;
            presets?: components["schemas"]["IndexerResource"][] | null;
            /** Format: int32 */
            priority?: number;
            protocol?: components["schemas"]["DownloadProtocol"];
            supportsRss?: boolean;
            supportsSearch?: boolean;
            tags?: number[] | null;
        };
        Language: {
            /** Format: int32 */
            id?: number;
            name?: string | null;
        };
        LanguageResource: {
            /** Format: int32 */
            id?: number;
            name?: string | null;
            readonly nameLower?: string | null;
        };
        LocalizationLanguageResource: {
            identifier?: string | null;
        };
        LogFileResource: {
            contentsUrl?: string | null;
            downloadUrl?: string | null;
            filename?: string | null;
            /** Format: int32 */
            id?: number;
            /** Format: date-time */
            lastWriteTime?: string;
        };
        LogResource: {
            exception?: string | null;
            exceptionType?: string | null;
            /** Format: int32 */
            id?: number;
            level?: string | null;
            logger?: string | null;
            message?: string | null;
            method?: string | null;
            /** Format: date-time */
            time?: string;
        };
        LogResourcePagingResource: {
            /** Format: int32 */
            page?: number;
            /** Format: int32 */
            pageSize?: number;
            records?: components["schemas"]["LogResource"][] | null;
            sortDirection?: components["schemas"]["SortDirection"];
            sortKey?: string | null;
            /** Format: int32 */
            totalRecords?: number;
        };
        ManualImportReprocessResource: {
            customFormats?: components["schemas"]["CustomFormatResource"][] | null;
            /** Format: int32 */
            customFormatScore?: number;
            downloadId?: string | null;
            /** Format: int32 */
            id?: number;
            /** Format: int32 */
            indexerFlags?: number;
            languages?: components["schemas"]["Language"][] | null;
            movie?: components["schemas"]["MovieResource"];
            /** Format: int32 */
            movieId?: number;
            path?: string | null;
            quality?: components["schemas"]["QualityModel"];
            rejections?: components["schemas"]["ImportRejectionResource"][] | null;
            releaseGroup?: string | null;
        };
        ManualImportResource: {
            customFormats?: components["schemas"]["CustomFormatResource"][] | null;
            /** Format: int32 */
            customFormatScore?: number;
            downloadId?: string | null;
            folderName?: string | null;
            /** Format: int32 */
            id?: number;
            /** Format: int32 */
            indexerFlags?: number;
            languages?: components["schemas"]["Language"][] | null;
            movie?: components["schemas"]["MovieResource"];
            /** Format: int32 */
            movieFileId?: number | null;
            name?: string | null;
            path?: string | null;
            quality?: components["schemas"]["QualityModel"];
            /** Format: int32 */
            qualityWeight?: number;
            rejections?: components["schemas"]["ImportRejectionResource"][] | null;
            relativePath?: string | null;
            releaseGroup?: string | null;
            /** Format: int64 */
            size?: number;
        };
        MediaCover: {
            coverType?: components["schemas"]["MediaCoverTypes"];
            remoteUrl?: string | null;
            url?: string | null;
        };
        /** @enum {string} */
        MediaCoverTypes: "unknown" | "poster" | "banner" | "fanart" | "screenshot" | "headshot" | "clearlogo";
        MediaInfoResource: {
            /** Format: int64 */
            audioBitrate?: number;
            /** Format: double */
            audioChannels?: number;
            audioCodec?: string | null;
            audioLanguages?: string | null;
            /** Format: int32 */
            audioStreamCount?: number;
            /** Format: int32 */
            id?: number;
            resolution?: string | null;
            runTime?: string | null;
            scanType?: string | null;
            subtitles?: string | null;
            /** Format: int32 */
            videoBitDepth?: number;
            /** Format: int64 */
            videoBitrate?: number;
            videoCodec?: string | null;
            videoDynamicRange?: string | null;
            videoDynamicRangeType?: string | null;
            /** Format: double */
            videoFps?: number;
        };
        MediaManagementConfigResource: {
            autoRenameFolders?: boolean;
            autoUnmonitorPreviouslyDownloadedMovies?: boolean;
            chmodFolder?: string | null;
            chownGroup?: string | null;
            copyUsingHardlinks?: boolean;
            createEmptyMovieFolders?: boolean;
            deleteEmptyFolders?: boolean;
            downloadPropersAndRepacks?: components["schemas"]["ProperDownloadTypes"];
            enableMediaInfo?: boolean;
            extraFileExtensions?: string | null;
            fileDate?: components["schemas"]["FileDateType"];
            /** Format: int32 */
            id?: number;
            importExtraFiles?: boolean;
            /** Format: int32 */
            minimumFreeSpaceWhenImporting?: number;
            pathsDefaultStatic?: boolean;
            recycleBin?: string | null;
            /** Format: int32 */
            recycleBinCleanupDays?: number;
            rescanAfterRefresh?: components["schemas"]["RescanAfterRefreshType"];
            scriptImportPath?: string | null;
            setPermissionsLinux?: boolean;
            skipFreeSpaceCheckWhenImporting?: boolean;
            useScriptImport?: boolean;
        };
        MetadataConfigResource: {
            certificationCountry?: components["schemas"]["TMDbCountryCode"];
            /** Format: int32 */
            id?: number;
        };
        MetadataResource: {
            configContract?: string | null;
            enable?: boolean;
            fields?: components["schemas"]["Field"][] | null;
            /** Format: int32 */
            id?: number;
            implementation?: string | null;
            implementationName?: string | null;
            infoLink?: string | null;
            message?: components["schemas"]["ProviderMessage"];
            name?: string | null;
            presets?: components["schemas"]["MetadataResource"][] | null;
            tags?: number[] | null;
        };
        /** @enum {string} */
        Modifier: "none" | "regional" | "screener" | "rawhd" | "brdisk" | "remux";
        /** @enum {string} */
        MonitorTypes: "movieOnly" | "movieAndCollection" | "none";
        MovieCollectionResource: {
            title?: string | null;
            /** Format: int32 */
            tmdbId?: number;
        };
        MovieEditorResource: {
            addImportExclusion?: boolean;
            applyTags?: components["schemas"]["ApplyTags"];
            deleteFiles?: boolean;
            minimumAvailability?: components["schemas"]["MovieStatusType"];
            monitored?: boolean | null;
            moveFiles?: boolean;
            movieIds?: number[] | null;
            /** Format: int32 */
            qualityProfileId?: number | null;
            rootFolderPath?: string | null;
            tags?: number[] | null;
        };
        MovieFileListResource: {
            edition?: string | null;
            /** Format: int32 */
            indexerFlags?: number | null;
            languages?: components["schemas"]["Language"][] | null;
            movieFileIds?: number[] | null;
            quality?: components["schemas"]["QualityModel"];
            releaseGroup?: string | null;
            sceneName?: string | null;
        };
        MovieFileResource: {
            customFormats?: components["schemas"]["CustomFormatResource"][] | null;
            /** Format: int32 */
            customFormatScore?: number | null;
            /** Format: date-time */
            dateAdded?: string;
            edition?: string | null;
            /** Format: int32 */
            id?: number;
            /** Format: int32 */
            indexerFlags?: number | null;
            languages?: components["schemas"]["Language"][] | null;
            mediaInfo?: components["schemas"]["MediaInfoResource"];
            /** Format: int32 */
            movieId?: number;
            originalFilePath?: string | null;
            path?: string | null;
            quality?: components["schemas"]["QualityModel"];
            qualityCutoffNotMet?: boolean;
            relativePath?: string | null;
            releaseGroup?: string | null;
            sceneName?: string | null;
            /** Format: int64 */
            size?: number;
        };
        /** @enum {string} */
        MovieHistoryEventType: "unknown" | "grabbed" | "downloadFolderImported" | "downloadFailed" | "movieFileDeleted" | "movieFolderImported" | "movieFileRenamed" | "downloadIgnored";
        MovieResource: {
            /** Format: date-time */
            added?: string;
            addOptions?: components["schemas"]["AddMovieOptions"];
            alternateTitles?: components["schemas"]["AlternativeTitleResource"][] | null;
            certification?: string | null;
            cleanTitle?: string | null;
            collection?: components["schemas"]["MovieCollectionResource"];
            /** Format: date-time */
            digitalRelease?: string | null;
            folder?: string | null;
            folderName?: string | null;
            genres?: string[] | null;
            hasFile?: boolean | null;
            /** Format: int32 */
            id?: number;
            images?: components["schemas"]["MediaCover"][] | null;
            imdbId?: string | null;
            /** Format: date-time */
            inCinemas?: string | null;
            isAvailable?: boolean;
            keywords?: string[] | null;
            /** Format: date-time */
            lastSearchTime?: string | null;
            minimumAvailability?: components["schemas"]["MovieStatusType"];
            monitored?: boolean;
            movieFile?: components["schemas"]["MovieFileResource"];
            /** Format: int32 */
            movieFileId?: number;
            originalLanguage?: components["schemas"]["Language"];
            originalTitle?: string | null;
            overview?: string | null;
            path?: string | null;
            /** Format: date-time */
            physicalRelease?: string | null;
            physicalReleaseNote?: string | null;
            /** Format: float */
            popularity?: number;
            /** Format: int32 */
            qualityProfileId?: number;
            ratings?: components["schemas"]["Ratings"];
            /** Format: date-time */
            releaseDate?: string | null;
            remotePoster?: string | null;
            rootFolderPath?: string | null;
            /** Format: int32 */
            runtime?: number;
            /** Format: int32 */
            secondaryYear?: number | null;
            /** Format: int32 */
            secondaryYearSourceId?: number;
            /** Format: int64 */
            sizeOnDisk?: number | null;
            sortTitle?: string | null;
            statistics?: components["schemas"]["MovieStatisticsResource"];
            status?: components["schemas"]["MovieStatusType"];
            studio?: string | null;
            tags?: number[] | null;
            title?: string | null;
            titleSlug?: string | null;
            /** Format: int32 */
            tmdbId?: number;
            website?: string | null;
            /** Format: int32 */
            year?: number;
            youTubeTrailerId?: string | null;
        };
        MovieResourcePagingResource: {
            /** Format: int32 */
            page?: number;
            /** Format: int32 */
            pageSize?: number;
            records?: components["schemas"]["MovieResource"][] | null;
            sortDirection?: components["schemas"]["SortDirection"];
            sortKey?: string | null;
            /** Format: int32 */
            totalRecords?: number;
        };
        /** @enum {string} */
        MovieRuntimeFormatType: "hoursMinutes" | "minutes";
        MovieStatisticsResource: {
            /** Format: int32 */
            movieFileCount?: number;
            releaseGroups?: string[] | null;
            /** Format: int64 */
            sizeOnDisk?: number;
        };
        /** @enum {string} */
        MovieStatusType: "tba" | "announced" | "inCinemas" | "released" | "deleted";
        NamingConfigResource: {
            colonReplacementFormat?: components["schemas"]["ColonReplacementFormat"];
            /** Format: int32 */
            id?: number;
            movieFolderFormat?: string | null;
            renameMovies?: boolean;
            replaceIllegalCharacters?: boolean;
            standardMovieFormat?: string | null;
        };
        NotificationResource: {
            configContract?: string | null;
            fields?: components["schemas"]["Field"][] | null;
            /** Format: int32 */
            id?: number;
            implementation?: string | null;
            implementationName?: string | null;
            includeHealthWarnings?: boolean;
            infoLink?: string | null;
            link?: string | null;
            message?: components["schemas"]["ProviderMessage"];
            name?: string | null;
            onApplicationUpdate?: boolean;
            onDownload?: boolean;
            onGrab?: boolean;
            onHealthIssue?: boolean;
            onHealthRestored?: boolean;
            onManualInteractionRequired?: boolean;
            onMovieAdded?: boolean;
            onMovieDelete?: boolean;
            onMovieFileDelete?: boolean;
            onMovieFileDeleteForUpgrade?: boolean;
            onRename?: boolean;
            onUpgrade?: boolean;
            presets?: components["schemas"]["NotificationResource"][] | null;
            supportsOnApplicationUpdate?: boolean;
            supportsOnDownload?: boolean;
            supportsOnGrab?: boolean;
            supportsOnHealthIssue?: boolean;
            supportsOnHealthRestored?: boolean;
            supportsOnManualInteractionRequired?: boolean;
            supportsOnMovieAdded?: boolean;
            supportsOnMovieDelete?: boolean;
            supportsOnMovieFileDelete?: boolean;
            supportsOnMovieFileDeleteForUpgrade?: boolean;
            supportsOnRename?: boolean;
            supportsOnUpgrade?: boolean;
            tags?: number[] | null;
            testCommand?: string | null;
        };
        ParsedMovieInfo: {
            edition?: string | null;
            hardcodedSubs?: string | null;
            imdbId?: string | null;
            languages?: components["schemas"]["Language"][] | null;
            readonly movieTitle?: string | null;
            movieTitles?: string[] | null;
            originalTitle?: string | null;
            readonly primaryMovieTitle?: string | null;
            quality?: components["schemas"]["QualityModel"];
            releaseGroup?: string | null;
            releaseHash?: string | null;
            releaseTitle?: string | null;
            simpleReleaseTitle?: string | null;
            /** Format: int32 */
            tmdbId?: number;
            /** Format: int32 */
            year?: number;
        };
        ParseResource: {
            customFormats?: components["schemas"]["CustomFormatResource"][] | null;
            /** Format: int32 */
            customFormatScore?: number;
            /** Format: int32 */
            id?: number;
            languages?: components["schemas"]["Language"][] | null;
            movie?: components["schemas"]["MovieResource"];
            parsedMovieInfo?: components["schemas"]["ParsedMovieInfo"];
            title?: string | null;
        };
        PingResource: {
            status?: string | null;
        };
        /** @enum {string} */
        PrivacyLevel: "normal" | "password" | "apiKey" | "userName";
        ProfileFormatItemResource: {
            /** Format: int32 */
            format?: number;
            /** Format: int32 */
            id?: number;
            name?: string | null;
            /** Format: int32 */
            score?: number;
        };
        /** @enum {string} */
        ProperDownloadTypes: "preferAndUpgrade" | "doNotUpgrade" | "doNotPrefer";
        ProviderMessage: {
            message?: string | null;
            type?: components["schemas"]["ProviderMessageType"];
        };
        /** @enum {string} */
        ProviderMessageType: "info" | "warning" | "error";
        /** @enum {string} */
        ProxyType: "http" | "socks4" | "socks5";
        Quality: {
            /** Format: int32 */
            id?: number;
            modifier?: components["schemas"]["Modifier"];
            name?: string | null;
            /** Format: int32 */
            resolution?: number;
            source?: components["schemas"]["QualitySource"];
        };
        QualityDefinitionLimitsResource: {
            /** Format: int32 */
            max?: number;
            /** Format: int32 */
            min?: number;
        };
        QualityDefinitionResource: {
            /** Format: int32 */
            id?: number;
            /** Format: double */
            maxSize?: number | null;
            /** Format: double */
            minSize?: number | null;
            /** Format: double */
            preferredSize?: number | null;
            quality?: components["schemas"]["Quality"];
            title?: string | null;
            /** Format: int32 */
            weight?: number;
        };
        QualityModel: {
            quality?: components["schemas"]["Quality"];
            revision?: components["schemas"]["Revision"];
        };
        QualityProfileQualityItemResource: {
            allowed?: boolean;
            /** Format: int32 */
            id?: number;
            items?: components["schemas"]["QualityProfileQualityItemResource"][] | null;
            name?: string | null;
            quality?: components["schemas"]["Quality"];
        };
        QualityProfileResource: {
            /** Format: int32 */
            cutoff?: number;
            /** Format: int32 */
            cutoffFormatScore?: number;
            formatItems?: components["schemas"]["ProfileFormatItemResource"][] | null;
            /** Format: int32 */
            id?: number;
            items?: components["schemas"]["QualityProfileQualityItemResource"][] | null;
            language?: components["schemas"]["Language"];
            /** Format: int32 */
            minFormatScore?: number;
            /** Format: int32 */
            minUpgradeFormatScore?: number;
            name?: string | null;
            upgradeAllowed?: boolean;
        };
        /** @enum {string} */
        QualitySource: "unknown" | "cam" | "telesync" | "telecine" | "workprint" | "dvd" | "tv" | "webdl" | "webrip" | "bluray";
        QueueBulkResource: {
            ids?: number[] | null;
        };
        QueueResource: {
            /** Format: date-time */
            added?: string | null;
            customFormats?: components["schemas"]["CustomFormatResource"][] | null;
            /** Format: int32 */
            customFormatScore?: number;
            downloadClient?: string | null;
            downloadClientHasPostImportCategory?: boolean;
            downloadId?: string | null;
            errorMessage?: string | null;
            /** Format: date-time */
            estimatedCompletionTime?: string | null;
            /** Format: int32 */
            id?: number;
            indexer?: string | null;
            languages?: components["schemas"]["Language"][] | null;
            movie?: components["schemas"]["MovieResource"];
            /** Format: int32 */
            movieId?: number | null;
            outputPath?: string | null;
            protocol?: components["schemas"]["DownloadProtocol"];
            quality?: components["schemas"]["QualityModel"];
            /** Format: double */
            size?: number;
            /**
             * Format: double
             * @deprecated
             */
            sizeleft?: number;
            status?: components["schemas"]["QueueStatus"];
            statusMessages?: components["schemas"]["TrackedDownloadStatusMessage"][] | null;
            /**
             * Format: date-span
             * @deprecated
             */
            timeleft?: string | null;
            title?: string | null;
            trackedDownloadState?: components["schemas"]["TrackedDownloadState"];
            trackedDownloadStatus?: components["schemas"]["TrackedDownloadStatus"];
        };
        QueueResourcePagingResource: {
            /** Format: int32 */
            page?: number;
            /** Format: int32 */
            pageSize?: number;
            records?: components["schemas"]["QueueResource"][] | null;
            sortDirection?: components["schemas"]["SortDirection"];
            sortKey?: string | null;
            /** Format: int32 */
            totalRecords?: number;
        };
        /** @enum {string} */
        QueueStatus: "unknown" | "queued" | "paused" | "downloading" | "completed" | "failed" | "warning" | "delay" | "downloadClientUnavailable" | "fallback";
        QueueStatusResource: {
            /** Format: int32 */
            count?: number;
            errors?: boolean;
            /** Format: int32 */
            id?: number;
            /** Format: int32 */
            totalCount?: number;
            /** Format: int32 */
            unknownCount?: number;
            unknownErrors?: boolean;
            unknownWarnings?: boolean;
            warnings?: boolean;
        };
        RatingChild: {
            type?: components["schemas"]["RatingType"];
            /** Format: double */
            value?: number;
            /** Format: int32 */
            votes?: number;
        };
        Ratings: {
            imdb?: components["schemas"]["RatingChild"];
            metacritic?: components["schemas"]["RatingChild"];
            rottenTomatoes?: components["schemas"]["RatingChild"];
            tmdb?: components["schemas"]["RatingChild"];
            trakt?: components["schemas"]["RatingChild"];
        };
        /** @enum {string} */
        RatingType: "user" | "critic";
        /** @enum {string} */
        RejectionType: "permanent" | "temporary";
        ReleaseProfileResource: {
            enabled?: boolean;
            /** Format: int32 */
            id?: number;
            ignored?: unknown;
            /** Format: int32 */
            indexerId?: number;
            name?: string | null;
            required?: unknown;
            tags?: number[] | null;
        };
        ReleaseResource: {
            /** Format: int32 */
            age?: number;
            /** Format: double */
            ageHours?: number;
            /** Format: double */
            ageMinutes?: number;
            approved?: boolean;
            commentUrl?: string | null;
            customFormats?: components["schemas"]["CustomFormatResource"][] | null;
            /** Format: int32 */
            customFormatScore?: number;
            downloadAllowed?: boolean;
            downloadClient?: string | null;
            /** Format: int32 */
            downloadClientId?: number | null;
            downloadUrl?: string | null;
            edition?: string | null;
            guid?: string | null;
            /** Format: int32 */
            id?: number;
            /** Format: int32 */
            imdbId?: number;
            indexer?: string | null;
            indexerFlags?: unknown;
            /** Format: int32 */
            indexerId?: number;
            infoHash?: string | null;
            infoUrl?: string | null;
            languages?: components["schemas"]["Language"][] | null;
            /** Format: int32 */
            leechers?: number | null;
            magnetUrl?: string | null;
            /** Format: int32 */
            mappedMovieId?: number | null;
            /** Format: int32 */
            movieId?: number | null;
            movieRequested?: boolean;
            movieTitles?: string[] | null;
            protocol?: components["schemas"]["DownloadProtocol"];
            /** Format: date-time */
            publishDate?: string;
            quality?: components["schemas"]["QualityModel"];
            /** Format: int32 */
            qualityWeight?: number;
            rejected?: boolean;
            rejections?: string[] | null;
            releaseGroup?: string | null;
            releaseHash?: string | null;
            /** Format: int32 */
            releaseWeight?: number;
            sceneSource?: boolean;
            /** Format: int32 */
            seeders?: number | null;
            shouldOverride?: boolean | null;
            /** Format: int64 */
            size?: number;
            subGroup?: string | null;
            temporarilyRejected?: boolean;
            title?: string | null;
            /** Format: int32 */
            tmdbId?: number;
        };
        RemotePathMappingResource: {
            host?: string | null;
            /** Format: int32 */
            id?: number;
            localPath?: string | null;
            remotePath?: string | null;
        };
        RenameMovieResource: {
            existingPath?: string | null;
            /** Format: int32 */
            id?: number;
            /** Format: int32 */
            movieFileId?: number;
            /** Format: int32 */
            movieId?: number;
            newPath?: string | null;
        };
        /** @enum {string} */
        RescanAfterRefreshType: "always" | "afterManual" | "never";
        Revision: {
            isRepack?: boolean;
            /** Format: int32 */
            real?: number;
            /** Format: int32 */
            version?: number;
        };
        RootFolderResource: {
            accessible?: boolean;
            /** Format: int64 */
            freeSpace?: number | null;
            /** Format: int32 */
            id?: number;
            path?: string | null;
            unmappedFolders?: components["schemas"]["UnmappedFolder"][] | null;
        };
        /** @enum {string} */
        RuntimeMode: "console" | "service" | "tray";
        SelectOption: {
            dividerAfter?: boolean;
            hint?: string | null;
            name?: string | null;
            /** Format: int32 */
            order?: number;
            /** Format: int32 */
            value?: number;
        };
        /** @enum {string} */
        SortDirection: "default" | "ascending" | "descending";
        /** @enum {string} */
        SourceType: "tmdb" | "mappings" | "user" | "indexer";
        SystemResource: {
            appData?: string | null;
            appName?: string | null;
            authentication?: components["schemas"]["AuthenticationType"];
            branch?: string | null;
            /** Format: date-time */
            buildTime?: string;
            databaseType?: components["schemas"]["DatabaseType"];
            databaseVersion?: string | null;
            instanceName?: string | null;
            isAdmin?: boolean;
            isDebug?: boolean;
            isDocker?: boolean;
            isLinux?: boolean;
            isNetCore?: boolean;
            isOsx?: boolean;
            isProduction?: boolean;
            isUserInteractive?: boolean;
            isWindows?: boolean;
            /** Format: int32 */
            migrationVersion?: number;
            mode?: components["schemas"]["RuntimeMode"];
            osName?: string | null;
            osVersion?: string | null;
            packageAuthor?: string | null;
            packageUpdateMechanism?: components["schemas"]["UpdateMechanism"];
            packageUpdateMechanismMessage?: string | null;
            packageVersion?: string | null;
            runtimeName?: string | null;
            runtimeVersion?: string | null;
            /** Format: date-time */
            startTime?: string;
            startupPath?: string | null;
            urlBase?: string | null;
            version?: string | null;
        };
        TagDetailsResource: {
            autoTagIds?: number[] | null;
            delayProfileIds?: number[] | null;
            downloadClientIds?: number[] | null;
            /** Format: int32 */
            id?: number;
            importListIds?: number[] | null;
            indexerIds?: number[] | null;
            label?: string | null;
            movieIds?: number[] | null;
            notificationIds?: number[] | null;
            releaseProfileIds?: number[] | null;
        };
        TagResource: {
            /** Format: int32 */
            id?: number;
            label?: string | null;
        };
        TaskResource: {
            /** Format: int32 */
            id?: number;
            /** Format: int32 */
            interval?: number;
            /** Format: date-span */
            readonly lastDuration?: string;
            /** Format: date-time */
            lastExecution?: string;
            /** Format: date-time */
            lastStartTime?: string;
            name?: string | null;
            /** Format: date-time */
            nextExecution?: string;
            taskName?: string | null;
        };
        /** @enum {string} */
        TMDbCountryCode: "au" | "br" | "ca" | "fr" | "de" | "gb" | "in" | "ie" | "it" | "nz" | "ro" | "es" | "us";
        /** @enum {string} */
        TrackedDownloadState: "downloading" | "importBlocked" | "importPending" | "importing" | "imported" | "failedPending" | "failed" | "ignored";
        /** @enum {string} */
        TrackedDownloadStatus: "ok" | "warning" | "error";
        TrackedDownloadStatusMessage: {
            messages?: string[] | null;
            title?: string | null;
        };
        UiConfigResource: {
            calendarWeekColumnHeader?: string | null;
            enableColorImpairedMode?: boolean;
            /** Format: int32 */
            firstDayOfWeek?: number;
            /** Format: int32 */
            id?: number;
            longDateFormat?: string | null;
            /** Format: int32 */
            movieInfoLanguage?: number;
            movieRuntimeFormat?: components["schemas"]["MovieRuntimeFormatType"];
            shortDateFormat?: string | null;
            showRelativeDates?: boolean;
            theme?: string | null;
            timeFormat?: string | null;
            /** Format: int32 */
            uiLanguage?: number;
        };
        UnmappedFolder: {
            name?: string | null;
            path?: string | null;
            relativePath?: string | null;
        };
        UpdateChanges: {
            fixed?: string[] | null;
            new?: string[] | null;
        };
        /** @enum {string} */
        UpdateMechanism: "builtIn" | "script" | "external" | "apt" | "docker";
        UpdateResource: {
            branch?: string | null;
            changes?: components["schemas"]["UpdateChanges"];
            fileName?: string | null;
            hash?: string | null;
            /** Format: int32 */
            id?: number;
            installable?: boolean;
            installed?: boolean;
            /** Format: date-time */
            installedOn?: string | null;
            latest?: boolean;
            /** Format: date-time */
            releaseDate?: string;
            url?: string | null;
            version?: string | null;
        };
    };
    responses: never;
    parameters: never;
    requestBodies: never;
    headers: never;
    pathItems: never;
};

type Movie = components['schemas']['MovieResource'];
type MovieFile = components['schemas']['MovieFileResource'];
type MovieEditor = components['schemas']['MovieEditorResource'];
type MovieStatistics = components['schemas']['MovieStatisticsResource'];
type AddMovieOptions = components['schemas']['AddMovieOptions'];
type AlternativeTitle = components['schemas']['AlternativeTitleResource'];
type MovieStatusType = components['schemas']['MovieStatusType'];
type Collection = components['schemas']['CollectionResource'];
type CollectionMovie = components['schemas']['CollectionMovieResource'];
type CollectionUpdate = components['schemas']['CollectionUpdateResource'];
type QualityProfile = components['schemas']['QualityProfileResource'];
type QualityProfileQualityItem = components['schemas']['QualityProfileQualityItemResource'];
type QualityDefinition = components['schemas']['QualityDefinitionResource'];
type QualityDefinitionLimits = components['schemas']['QualityDefinitionLimitsResource'];
type Quality = components['schemas']['Quality'];
type QualityModel = components['schemas']['QualityModel'];
type CustomFormat = components['schemas']['CustomFormatResource'];
type CustomFormatBulk = components['schemas']['CustomFormatBulkResource'];
type CustomFormatSpecificationSchema = components['schemas']['CustomFormatSpecificationSchema'];
type ProfileFormatItem = components['schemas']['ProfileFormatItemResource'];
type Language = components['schemas']['Language'];
type LanguageResource = components['schemas']['LanguageResource'];
type Release = components['schemas']['ReleaseResource'];
type ReleaseType = components['schemas']['CalendarReleaseType'];
type Command = components['schemas']['Command'];
type CommandResource = components['schemas']['CommandResource'];
type CommandStatus = components['schemas']['CommandStatus'];
type CommandResult = components['schemas']['CommandResult'];
type CommandPriority = components['schemas']['CommandPriority'];
type CommandTrigger = components['schemas']['CommandTrigger'];
type Queue = components['schemas']['QueueResource'];
type QueueBulk = components['schemas']['QueueBulkResource'];
type QueueStatus = components['schemas']['QueueStatusResource'];
type History = components['schemas']['HistoryResource'];
type MovieHistoryEventType = components['schemas']['MovieHistoryEventType'];
type DownloadClient = components['schemas']['DownloadClientResource'];
type DownloadClientBulk = components['schemas']['DownloadClientBulkResource'];
type DownloadClientConfig = components['schemas']['DownloadClientConfigResource'];
type DownloadProtocol = components['schemas']['DownloadProtocol'];
type Indexer = components['schemas']['IndexerResource'];
type IndexerBulk = components['schemas']['IndexerBulkResource'];
type IndexerConfig = components['schemas']['IndexerConfigResource'];
type IndexerFlag = components['schemas']['IndexerFlagResource'];
type ImportList = components['schemas']['ImportListResource'];
type ImportListBulk = components['schemas']['ImportListBulkResource'];
type ImportListConfig = components['schemas']['ImportListConfigResource'];
type ImportExclusion = components['schemas']['ImportListExclusionResource'];
type ImportExclusionBulk = components['schemas']['ImportListExclusionBulkResource'];
type Notification = components['schemas']['NotificationResource'];
type Metadata = components['schemas']['MetadataResource'];
type Tag = components['schemas']['TagResource'];
type TagDetails = components['schemas']['TagDetailsResource'];
type RootFolder = components['schemas']['RootFolderResource'];
type RemotePathMapping = components['schemas']['RemotePathMappingResource'];
type Blocklist = components['schemas']['BlocklistResource'];
type BlocklistBulk = components['schemas']['BlocklistBulkResource'];
type ManualImport = components['schemas']['ManualImportResource'];
type ManualImportReprocess = components['schemas']['ManualImportReprocessResource'];
type Parse = components['schemas']['ParseResource'];
type Backup = components['schemas']['BackupResource'];
type BackupType = components['schemas']['BackupType'];
type SystemResource = components['schemas']['SystemResource'];
type Health = components['schemas']['HealthResource'];
type HealthCheckResult = components['schemas']['HealthCheckResult'];
type DiskSpace = components['schemas']['DiskSpaceResource'];
type Task = components['schemas']['TaskResource'];
type Log = components['schemas']['LogResource'];
type LogFile = components['schemas']['LogFileResource'];
type Update = components['schemas']['UpdateResource'];
type HostConfig = components['schemas']['HostConfigResource'];
type UiConfig = components['schemas']['UiConfigResource'];
type NamingConfig = components['schemas']['NamingConfigResource'];
type MediaManagementConfig = components['schemas']['MediaManagementConfigResource'];
type DelayProfile = components['schemas']['DelayProfileResource'];
type AutoTagging = components['schemas']['AutoTaggingResource'];
type AutoTaggingSpecificationSchema = components['schemas']['AutoTaggingSpecificationSchema'];
type CustomFilter = components['schemas']['CustomFilterResource'];
type LocalizationLanguage = components['schemas']['LocalizationLanguageResource'];
type MediaCover = components['schemas']['MediaCover'];
type MediaCoverTypes = components['schemas']['MediaCoverTypes'];
type MediaInfo = components['schemas']['MediaInfoResource'];
type Ratings = components['schemas']['Ratings'];
type RenameMovie = components['schemas']['RenameMovieResource'];
type MovieFileList = components['schemas']['MovieFileListResource'];
type Credit = components['schemas']['CreditResource'];
type ExtraFile = components['schemas']['ExtraFileResource'];
type ApplyTags = components['schemas']['ApplyTags'];
type SortDirection = components['schemas']['SortDirection'];
type Field = components['schemas']['Field'];
type SelectOption = components['schemas']['SelectOption'];
type ProviderMessage = components['schemas']['ProviderMessage'];
type BlocklistPagingResource = components['schemas']['BlocklistResourcePagingResource'];
type HistoryPagingResource = components['schemas']['HistoryResourcePagingResource'];
type QueuePagingResource = components['schemas']['QueueResourcePagingResource'];
type LogPagingResource = components['schemas']['LogResourcePagingResource'];
type ImportExclusionPagingResource = components['schemas']['ImportListExclusionResourcePagingResource'];

interface GetMovieOptions {
    tmdbId?: number;
    excludeLocalCovers?: boolean;
    [key: string]: unknown;
}
interface DeleteMovieOptions {
    deleteFiles?: boolean;
    addImportExclusion?: boolean;
    [key: string]: unknown;
}
declare class MovieResource {
    private client;
    constructor(client: ClientMethods);
    getAll(options?: GetMovieOptions): Promise<Movie[]>;
    getById(id: number): Promise<Movie>;
    create(movie: Omit<Movie, 'id'>): Promise<Movie>;
    update(id: number, movie: Partial<Movie> & {
        id: number;
    }, moveFiles?: boolean): Promise<Movie>;
    delete(id: number, options?: DeleteMovieOptions): Promise<void>;
    lookup(term: string): Promise<Movie[]>;
    lookupByTmdbId(tmdbId: number): Promise<Movie[]>;
    lookupByImdbId(imdbId: string): Promise<Movie[]>;
    bulkEdit(resource: MovieEditor): Promise<Movie[]>;
    bulkDelete(movieIds: number[], options?: DeleteMovieOptions): Promise<void>;
    import(movies: Movie[]): Promise<Movie[]>;
}

declare class MovieFileResource {
    private client;
    constructor(client: ClientMethods);
    getAll(options?: {
        movieId?: number;
        movieFileIds?: number[];
    }): Promise<MovieFile[]>;
    getById(id: number): Promise<MovieFile>;
    getByMovie(movieId: number): Promise<MovieFile[]>;
    update(id: number, file: Partial<MovieFile> & {
        id: number;
    }): Promise<MovieFile>;
    bulkUpdate(files: MovieFileList): Promise<MovieFile[]>;
    delete(id: number): Promise<void>;
    bulkDelete(movieFileIds: number[]): Promise<void>;
}

interface CalendarOptions {
    start?: Date | string;
    end?: Date | string;
    unmonitored?: boolean;
    tags?: number[];
}
interface CalendarFeedOptions {
    pastDays?: number;
    futureDays?: number;
    tags?: string;
    unmonitored?: boolean;
    [key: string]: unknown;
}
declare class CalendarResource {
    private client;
    constructor(client: ClientMethods);
    get(options?: CalendarOptions): Promise<Movie[]>;
    getById(id: number): Promise<Movie>;
    /**
     * Get calendar as iCalendar feed (.ics format)
     * Note: Returns raw iCalendar text, not JSON
     */
    getICalFeed(options?: CalendarFeedOptions): Promise<string>;
}

/**
 * File entry for the ManualImport command
 */
interface RadarrManualImportFile {
    path: string;
    folderName?: string;
    downloadId?: string;
    quality?: QualityModel;
    languages?: Language[];
    releaseGroup?: string;
    indexerFlags?: number;
    movieId?: number;
    movieFileId?: number;
}
type RadarrCommand = {
    name: 'ApplicationCheckUpdate';
} | {
    name: 'Backup';
} | {
    name: 'CleanUpRecycleBin';
} | {
    name: 'ClearBlocklist';
} | {
    name: 'ClearLog';
} | {
    name: 'Cutoff';
    filterKey?: string;
    filterValue?: string;
} | {
    name: 'DownloadedMoviesScan';
    path?: string;
    downloadClientId?: string;
    importMode?: 'Auto' | 'Move' | 'Copy';
} | {
    name: 'MissingMoviesSearch';
    filterKey?: string;
    filterValue?: string;
} | {
    name: 'MoviesSearch';
    movieIds: number[];
} | {
    name: 'RefreshCollections';
} | {
    name: 'RefreshMonitoredDownloads';
} | {
    name: 'RefreshMovie';
    movieIds?: number[];
} | {
    name: 'RenameFiles';
    movieId: number;
    files: number[];
} | {
    name: 'RenameMovie';
    movieIds: number[];
} | {
    name: 'Rescan';
    movieId?: number;
} | {
    name: 'RssSync';
} | {
    name: 'ManualImport';
    files: RadarrManualImportFile[];
    importMode?: 'Move' | 'Copy';
};
declare class CommandResource_ {
    private client;
    constructor(client: ClientMethods);
    getAll(): Promise<CommandResource[]>;
    getById(id: number): Promise<CommandResource>;
    execute(command: RadarrCommand): Promise<CommandResource>;
    cancel(id: number): Promise<void>;
    refreshMovie(movieIds?: number[]): Promise<CommandResource>;
    rescan(movieId?: number): Promise<CommandResource>;
    rssSync(): Promise<CommandResource>;
    moviesSearch(movieIds: number[]): Promise<CommandResource>;
    missingMoviesSearch(options?: {
        filterKey?: string;
        filterValue?: string;
    }): Promise<CommandResource>;
    backup(): Promise<CommandResource>;
    clearBlocklist(): Promise<CommandResource>;
    renameMovie(movieIds: number[]): Promise<CommandResource>;
    renameFiles(movieId: number, files: number[]): Promise<CommandResource>;
    downloadedMoviesScan(options?: {
        path?: string;
        downloadClientId?: string;
        importMode?: 'Auto' | 'Move' | 'Copy';
    }): Promise<CommandResource>;
    refreshCollections(): Promise<CommandResource>;
    manualImport(files: RadarrManualImportFile[], importMode?: 'Move' | 'Copy'): Promise<CommandResource>;
}

interface GetQueueOptions extends PaginationOptions {
    includeUnknownMovieItems?: boolean;
    includeMovie?: boolean;
    movieIds?: number[];
    protocol?: 'unknown' | 'usenet' | 'torrent';
    languages?: number[];
    quality?: number[];
    status?: ('unknown' | 'queued' | 'paused' | 'downloading' | 'completed' | 'failed' | 'warning' | 'delay' | 'downloadClientUnavailable' | 'fallback')[];
}
interface GetQueueDetailsOptions {
    movieId?: number;
    includeMovie?: boolean;
    [key: string]: unknown;
}
interface DeleteQueueOptions {
    removeFromClient?: boolean;
    blocklist?: boolean;
    skipRedownload?: boolean;
    changeCategory?: boolean;
    [key: string]: unknown;
}
declare class QueueResource {
    private client;
    constructor(client: ClientMethods);
    get(options?: GetQueueOptions): Promise<PaginatedResponse<Queue>>;
    getById(id: number): Promise<Queue>;
    getAll(options?: Omit<GetQueueOptions, 'page'>): AsyncGenerator<Queue, void, undefined>;
    getAllArray(options?: Omit<GetQueueOptions, 'page'>): Promise<Queue[]>;
    delete(id: number, options?: DeleteQueueOptions): Promise<void>;
    bulkDelete(ids: number[], options?: DeleteQueueOptions): Promise<void>;
    getStatus(): Promise<QueueStatus>;
    getDetails(options?: GetQueueDetailsOptions): Promise<Queue[]>;
    grab(id: number): Promise<void>;
    bulkGrab(ids: number[]): Promise<void>;
}

type EventTypeInput = MovieHistoryEventType | number;
type EventTypeFilter = EventTypeInput | EventTypeInput[];
interface GetHistoryOptions extends PaginationOptions {
    includeMovie?: boolean;
    eventType?: EventTypeFilter;
    movieId?: number;
    downloadId?: string;
    movieIds?: number[];
    languages?: number[];
    quality?: number;
}
declare class HistoryResource {
    private client;
    constructor(client: ClientMethods);
    get(options?: GetHistoryOptions): Promise<PaginatedResponse<History>>;
    getAll(options?: Omit<GetHistoryOptions, 'page'>): AsyncGenerator<History, void, undefined>;
    getAllArray(options?: Omit<GetHistoryOptions, 'page'>): Promise<History[]>;
    getMovie(movieId: number, options?: {
        includeMovie?: boolean;
    }): Promise<History[]>;
    getSince(date: Date | string, options?: {
        eventType?: EventTypeInput;
        includeMovie?: boolean;
    }): Promise<History[]>;
    markAsFailed(id: number): Promise<void>;
    markAsFailedByHistoryId(historyId: number): Promise<void>;
}

declare class QualityProfileResource {
    private client;
    constructor(client: ClientMethods);
    getAll(): Promise<QualityProfile[]>;
    getById(id: number): Promise<QualityProfile>;
    create(profile: Omit<QualityProfile, 'id'>): Promise<QualityProfile>;
    update(id: number, profile: Partial<QualityProfile> & {
        id: number;
    }): Promise<QualityProfile>;
    delete(id: number): Promise<void>;
    getSchema(): Promise<QualityProfile>;
}
declare class QualityDefinitionResource {
    private client;
    constructor(client: ClientMethods);
    getAll(): Promise<QualityDefinition[]>;
    getById(id: number): Promise<QualityDefinition>;
    update(id: number, definition: Partial<QualityDefinition> & {
        id: number;
    }): Promise<QualityDefinition>;
    updateAll(definitions: QualityDefinition[]): Promise<QualityDefinition[]>;
    getLimits(): Promise<QualityDefinitionLimits>;
}

declare class CustomFormatResource {
    private client;
    constructor(client: ClientMethods);
    getAll(): Promise<CustomFormat[]>;
    getById(id: number): Promise<CustomFormat>;
    create(format: Omit<CustomFormat, 'id'>): Promise<CustomFormat>;
    update(id: number, format: Partial<CustomFormat> & {
        id: number;
    }): Promise<CustomFormat>;
    delete(id: number): Promise<void>;
    bulkDelete(ids: number[]): Promise<void>;
    bulkUpdate(formats: CustomFormatBulk): Promise<CustomFormat[]>;
    getSchema(): Promise<CustomFormat[]>;
}

declare class DownloadClientResource {
    private client;
    constructor(client: ClientMethods);
    getAll(): Promise<DownloadClient[]>;
    getById(id: number): Promise<DownloadClient>;
    create(client: Omit<DownloadClient, 'id'>): Promise<DownloadClient>;
    update(id: number, client: Partial<DownloadClient> & {
        id: number;
    }, forceSave?: boolean): Promise<DownloadClient>;
    delete(id: number): Promise<void>;
    bulkUpdate(clients: DownloadClientBulk): Promise<DownloadClient[]>;
    bulkDelete(ids: number[]): Promise<void>;
    getSchema(): Promise<DownloadClient[]>;
    test(client: Partial<DownloadClient>): Promise<void>;
    testAll(): Promise<void>;
}
declare class DownloadClientConfigResource {
    private client;
    constructor(client: ClientMethods);
    get(): Promise<DownloadClientConfig>;
    update(config: Partial<DownloadClientConfig> & {
        id: number;
    }): Promise<DownloadClientConfig>;
}

declare class IndexerResource {
    private client;
    constructor(client: ClientMethods);
    getAll(): Promise<Indexer[]>;
    getById(id: number): Promise<Indexer>;
    create(indexer: Omit<Indexer, 'id'>): Promise<Indexer>;
    update(id: number, indexer: Partial<Indexer> & {
        id: number;
    }, forceSave?: boolean): Promise<Indexer>;
    delete(id: number): Promise<void>;
    bulkUpdate(indexers: IndexerBulk): Promise<Indexer[]>;
    bulkDelete(ids: number[]): Promise<void>;
    getSchema(): Promise<Indexer[]>;
    test(indexer: Partial<Indexer>): Promise<void>;
    testAll(): Promise<void>;
}
declare class IndexerConfigResource {
    private client;
    constructor(client: ClientMethods);
    get(): Promise<IndexerConfig>;
    update(config: Partial<IndexerConfig> & {
        id: number;
    }): Promise<IndexerConfig>;
}
declare class IndexerFlagResource {
    private client;
    constructor(client: ClientMethods);
    getAll(): Promise<IndexerFlag[]>;
}

declare class TagResource {
    private client;
    constructor(client: ClientMethods);
    getAll(): Promise<Tag[]>;
    getById(id: number): Promise<Tag>;
    create(tag: Omit<Tag, 'id'>): Promise<Tag>;
    update(id: number, tag: Partial<Tag> & {
        id: number;
    }): Promise<Tag>;
    delete(id: number): Promise<void>;
}
declare class TagDetailsResource {
    private client;
    constructor(client: ClientMethods);
    getAll(): Promise<TagDetails[]>;
    getById(id: number): Promise<TagDetails>;
}

declare class RootFolderResource {
    private client;
    constructor(client: ClientMethods);
    getAll(): Promise<RootFolder[]>;
    getById(id: number): Promise<RootFolder>;
    create(folder: Omit<RootFolder, 'id'>): Promise<RootFolder>;
    delete(id: number): Promise<void>;
}

declare class SystemInfoResource {
    private client;
    constructor(client: ClientMethods);
    get(): Promise<SystemResource>;
    getRoutes(): Promise<unknown[]>;
    getDuplicateRoutes(): Promise<unknown[]>;
    restart(): Promise<void>;
    shutdown(): Promise<void>;
    /**
     * Simple health check - returns "Pong"
     */
    ping(): Promise<string>;
}
declare class HealthResource {
    private client;
    constructor(client: ClientMethods);
    getAll(): Promise<Health[]>;
}
declare class DiskSpaceResource {
    private client;
    constructor(client: ClientMethods);
    getAll(): Promise<DiskSpace[]>;
}
declare class TaskResource {
    private client;
    constructor(client: ClientMethods);
    getAll(): Promise<Task[]>;
    getById(id: number): Promise<Task>;
}
declare class BackupResource {
    private client;
    constructor(client: ClientMethods);
    getAll(): Promise<Backup[]>;
    delete(id: number): Promise<void>;
    restore(id: number): Promise<void>;
    restoreUpload(formData: FormData): Promise<void>;
}
declare class LogResource {
    private client;
    constructor(client: ClientMethods);
    get(options?: PaginationOptions): Promise<PaginatedResponse<Log>>;
    getAll(options?: Omit<PaginationOptions, 'page'>): AsyncGenerator<Log, void, undefined>;
    getAllArray(options?: Omit<PaginationOptions, 'page'>): Promise<Log[]>;
}
declare class LogFileResource {
    private client;
    constructor(client: ClientMethods);
    getAll(): Promise<LogFile[]>;
    getUpdate(): Promise<LogFile[]>;
    /**
     * Download a specific log file's contents
     */
    download(filename: string): Promise<string>;
    /**
     * Download a specific update log file's contents
     */
    downloadUpdate(filename: string): Promise<string>;
}
declare class UpdateResource {
    private client;
    constructor(client: ClientMethods);
    getAll(): Promise<Update[]>;
}

interface SearchReleasesOptions {
    movieId?: number;
    [key: string]: unknown;
}
declare class ReleaseResource {
    private client;
    constructor(client: ClientMethods);
    get(options?: SearchReleasesOptions): Promise<Release[]>;
    getById(id: number): Promise<Release>;
    download(release: {
        guid: string;
        indexerId: number;
    }): Promise<Release>;
    push(release: Release): Promise<Release[]>;
}

declare class ImportListResource {
    private client;
    constructor(client: ClientMethods);
    getAll(): Promise<ImportList[]>;
    getById(id: number): Promise<ImportList>;
    create(list: Omit<ImportList, 'id'>): Promise<ImportList>;
    update(id: number, list: Partial<ImportList> & {
        id: number;
    }, forceSave?: boolean): Promise<ImportList>;
    delete(id: number): Promise<void>;
    bulkUpdate(lists: ImportListBulk): Promise<ImportList[]>;
    bulkDelete(ids: number[]): Promise<void>;
    getSchema(): Promise<ImportList[]>;
    test(list: Partial<ImportList>): Promise<void>;
    testAll(): Promise<void>;
}
declare class ImportListConfigResource {
    private client;
    constructor(client: ClientMethods);
    get(): Promise<ImportListConfig>;
    update(config: Partial<ImportListConfig> & {
        id: number;
    }): Promise<ImportListConfig>;
}
declare class ImportExclusionResource {
    private client;
    constructor(client: ClientMethods);
    get(options?: PaginationOptions): Promise<PaginatedResponse<ImportExclusion>>;
    getAll(): Promise<ImportExclusion[]>;
    getById(id: number): Promise<ImportExclusion>;
    create(exclusion: Omit<ImportExclusion, 'id'>): Promise<ImportExclusion>;
    update(id: number, exclusion: Partial<ImportExclusion> & {
        id: number;
    }): Promise<ImportExclusion>;
    delete(id: number): Promise<void>;
    bulkCreate(exclusions: ImportExclusion[]): Promise<ImportExclusion[]>;
    bulkDelete(exclusions: ImportExclusionBulk): Promise<void>;
}

declare class NotificationResource {
    private client;
    constructor(client: ClientMethods);
    getAll(): Promise<Notification[]>;
    getById(id: number): Promise<Notification>;
    create(notification: Omit<Notification, 'id'>): Promise<Notification>;
    update(id: number, notification: Partial<Notification> & {
        id: number;
    }, forceSave?: boolean): Promise<Notification>;
    delete(id: number): Promise<void>;
    getSchema(): Promise<Notification[]>;
    test(notification: Partial<Notification>): Promise<void>;
    testAll(): Promise<void>;
}

declare class MetadataResource {
    private client;
    constructor(client: ClientMethods);
    getAll(): Promise<Metadata[]>;
    getById(id: number): Promise<Metadata>;
    create(metadata: Omit<Metadata, 'id'>): Promise<Metadata>;
    update(id: number, metadata: Partial<Metadata> & {
        id: number;
    }, forceSave?: boolean): Promise<Metadata>;
    delete(id: number): Promise<void>;
    getSchema(): Promise<Metadata[]>;
    test(metadata: Partial<Metadata>): Promise<void>;
    testAll(): Promise<void>;
}

interface GetBlocklistOptions extends PaginationOptions {
    movieIds?: number[];
}
declare class BlocklistResource {
    private client;
    constructor(client: ClientMethods);
    get(options?: GetBlocklistOptions): Promise<PaginatedResponse<Blocklist>>;
    getAll(options?: Omit<GetBlocklistOptions, 'page'>): AsyncGenerator<Blocklist, void, undefined>;
    getAllArray(options?: Omit<GetBlocklistOptions, 'page'>): Promise<Blocklist[]>;
    getMovie(movieId: number): Promise<Blocklist[]>;
    delete(id: number): Promise<void>;
    bulkDelete(ids: number[]): Promise<void>;
}

interface GetManualImportOptions {
    folder?: string;
    downloadId?: string;
    movieId?: number;
    filterExistingFiles?: boolean;
    [key: string]: unknown;
}
declare class ManualImportResource {
    private client;
    constructor(client: ClientMethods);
    get(options?: GetManualImportOptions): Promise<ManualImport[]>;
    process(imports: ManualImportReprocess[]): Promise<void>;
}

declare class ParseResource {
    private client;
    constructor(client: ClientMethods);
    get(title: string): Promise<Parse>;
}

declare class HostConfigResource {
    private client;
    constructor(client: ClientMethods);
    get(): Promise<HostConfig>;
    update(config: Partial<HostConfig> & {
        id: number;
    }): Promise<HostConfig>;
}
declare class UiConfigResource {
    private client;
    constructor(client: ClientMethods);
    get(): Promise<UiConfig>;
    update(config: Partial<UiConfig> & {
        id: number;
    }): Promise<UiConfig>;
}
declare class NamingConfigResource {
    private client;
    constructor(client: ClientMethods);
    get(): Promise<NamingConfig>;
    update(config: Partial<NamingConfig> & {
        id: number;
    }): Promise<NamingConfig>;
    getExamples(options?: {
        id?: number;
        renameMovies?: boolean;
        replaceIllegalCharacters?: boolean;
        colonReplacementFormat?: number;
        standardMovieFormat?: string;
        movieFolderFormat?: string;
    }): Promise<unknown>;
}
declare class MediaManagementConfigResource {
    private client;
    constructor(client: ClientMethods);
    get(): Promise<MediaManagementConfig>;
    update(config: Partial<MediaManagementConfig> & {
        id: number;
    }): Promise<MediaManagementConfig>;
}

declare class DelayProfileResource {
    private client;
    constructor(client: ClientMethods);
    getAll(): Promise<DelayProfile[]>;
    getById(id: number): Promise<DelayProfile>;
    create(profile: Omit<DelayProfile, 'id'>): Promise<DelayProfile>;
    update(id: number, profile: Partial<DelayProfile> & {
        id: number;
    }): Promise<DelayProfile>;
    delete(id: number): Promise<void>;
    reorder(id: number, afterId?: number): Promise<DelayProfile[]>;
}

declare class RemotePathMappingResource {
    private client;
    constructor(client: ClientMethods);
    getAll(): Promise<RemotePathMapping[]>;
    getById(id: number): Promise<RemotePathMapping>;
    create(mapping: Omit<RemotePathMapping, 'id'>): Promise<RemotePathMapping>;
    update(id: number, mapping: Partial<RemotePathMapping> & {
        id: number;
    }): Promise<RemotePathMapping>;
    delete(id: number): Promise<void>;
}

declare class AutoTaggingResource {
    private client;
    constructor(client: ClientMethods);
    getAll(): Promise<AutoTagging[]>;
    getById(id: number): Promise<AutoTagging>;
    create(autoTagging: Omit<AutoTagging, 'id'>): Promise<AutoTagging>;
    update(id: number, autoTagging: Partial<AutoTagging> & {
        id: number;
    }): Promise<AutoTagging>;
    delete(id: number): Promise<void>;
    getSchema(): Promise<AutoTagging>;
}

declare class CollectionResource {
    private client;
    constructor(client: ClientMethods);
    getAll(options?: {
        tmdbId?: number;
    }): Promise<Collection[]>;
    getById(id: number): Promise<Collection>;
    update(id: number, collection: Partial<Collection> & {
        id: number;
    }): Promise<Collection>;
    bulkUpdate(update: CollectionUpdate): Promise<Collection[]>;
}

declare class CreditResource {
    private client;
    constructor(client: ClientMethods);
    getByMovie(movieId: number, options?: {
        movieMetadataId?: number;
    }): Promise<Credit[]>;
    getById(id: number): Promise<Credit>;
}

declare class ExtraFileResource {
    private client;
    constructor(client: ClientMethods);
    getByMovie(movieId: number): Promise<ExtraFile[]>;
}

declare class RenameResource {
    private client;
    constructor(client: ClientMethods);
    get(movieId: number): Promise<RenameMovie[]>;
}

declare class LanguageResourceApi {
    private client;
    constructor(client: ClientMethods);
    getAll(): Promise<LanguageResource[]>;
    getById(id: number): Promise<LanguageResource>;
}

declare class LocalizationResource {
    private client;
    constructor(client: ClientMethods);
    get(): Promise<string>;
    getLanguages(): Promise<LocalizationLanguage[]>;
}

declare class CustomFilterResource {
    private client;
    constructor(client: ClientMethods);
    getAll(): Promise<CustomFilter[]>;
    getById(id: number): Promise<CustomFilter>;
    create(filter: Omit<CustomFilter, 'id'>): Promise<CustomFilter>;
    update(id: number, filter: Partial<CustomFilter> & {
        id: number;
    }): Promise<CustomFilter>;
    delete(id: number): Promise<void>;
}

interface GetWantedOptions extends PaginationOptions {
    includeImages?: boolean;
    monitored?: boolean;
}
declare class WantedResource {
    private client;
    constructor(client: ClientMethods);
    /**
     * Get movies that don't meet quality cutoff
     */
    cutoff(options?: GetWantedOptions): Promise<PaginatedResponse<Movie>>;
    /**
     * Get all movies not meeting quality cutoff (async generator)
     */
    cutoffAll(options?: Omit<GetWantedOptions, 'page'>): AsyncGenerator<Movie, void, undefined>;
    /**
     * Get all movies not meeting quality cutoff as array
     */
    cutoffAllArray(options?: Omit<GetWantedOptions, 'page'>): Promise<Movie[]>;
    /**
     * Get missing movies
     */
    missing(options?: GetWantedOptions): Promise<PaginatedResponse<Movie>>;
    /**
     * Get all missing movies (async generator)
     */
    missingAll(options?: Omit<GetWantedOptions, 'page'>): AsyncGenerator<Movie, void, undefined>;
    /**
     * Get all missing movies as array
     */
    missingAllArray(options?: Omit<GetWantedOptions, 'page'>): Promise<Movie[]>;
}

interface FileSystemEntry {
    type: 'file' | 'folder' | 'drive';
    name: string;
    path: string;
    size?: number;
    lastModified?: string;
}
interface GetFileSystemOptions {
    path: string;
    includeFiles?: boolean;
    allowFoldersWithoutTrailingSlashes?: boolean;
    [key: string]: unknown;
}
declare class FileSystemResource {
    private client;
    constructor(client: ClientMethods);
    /**
     * Browse the filesystem at the given path
     */
    get(options: GetFileSystemOptions): Promise<FileSystemEntry[]>;
    /**
     * Get the type of a path (file, folder, etc.)
     */
    getType(path: string): Promise<{
        type: string;
    }>;
    /**
     * Get media files in a directory
     */
    getMediaFiles(path: string): Promise<FileSystemEntry[]>;
}

declare class MediaCoverResource {
    private client;
    constructor(client: ClientMethods);
    /**
     * Get a media cover image as binary data
     * @param movieId The movie ID
     * @param filename The cover filename (e.g., "poster.jpg", "fanart.jpg")
     * @returns ArrayBuffer containing the image data
     */
    get(movieId: number, filename: string): Promise<ArrayBuffer>;
    /**
     * Get a poster image for a movie
     */
    getPoster(movieId: number): Promise<ArrayBuffer>;
    /**
     * Get a fanart image for a movie
     */
    getFanart(movieId: number): Promise<ArrayBuffer>;
    /**
     * Get a cover image by type
     * @param movieId The movie ID
     * @param coverType The type of cover to retrieve
     */
    getByType(movieId: number, coverType: MediaCoverTypes): Promise<ArrayBuffer>;
}

declare class RadarrClient extends BaseClient {
    readonly movie: MovieResource;
    readonly movieFile: MovieFileResource;
    readonly calendar: CalendarResource;
    readonly command: CommandResource_;
    readonly queue: QueueResource;
    readonly history: HistoryResource;
    readonly qualityProfile: QualityProfileResource;
    readonly qualityDefinition: QualityDefinitionResource;
    readonly customFormat: CustomFormatResource;
    readonly downloadClient: DownloadClientResource;
    readonly downloadClientConfig: DownloadClientConfigResource;
    readonly indexer: IndexerResource;
    readonly indexerConfig: IndexerConfigResource;
    readonly indexerFlag: IndexerFlagResource;
    readonly tag: TagResource;
    readonly tagDetails: TagDetailsResource;
    readonly rootFolder: RootFolderResource;
    readonly system: SystemInfoResource;
    readonly health: HealthResource;
    readonly diskSpace: DiskSpaceResource;
    readonly task: TaskResource;
    readonly backup: BackupResource;
    readonly log: LogResource;
    readonly logFile: LogFileResource;
    readonly update: UpdateResource;
    readonly release: ReleaseResource;
    readonly importList: ImportListResource;
    readonly importListConfig: ImportListConfigResource;
    readonly importExclusion: ImportExclusionResource;
    readonly notification: NotificationResource;
    readonly metadata: MetadataResource;
    readonly blocklist: BlocklistResource;
    readonly manualImport: ManualImportResource;
    readonly parse: ParseResource;
    readonly hostConfig: HostConfigResource;
    readonly uiConfig: UiConfigResource;
    readonly namingConfig: NamingConfigResource;
    readonly mediaManagementConfig: MediaManagementConfigResource;
    readonly delayProfile: DelayProfileResource;
    readonly remotePathMapping: RemotePathMappingResource;
    readonly autoTagging: AutoTaggingResource;
    readonly collection: CollectionResource;
    readonly credit: CreditResource;
    readonly extraFile: ExtraFileResource;
    readonly rename: RenameResource;
    readonly language: LanguageResourceApi;
    readonly localization: LocalizationResource;
    readonly customFilter: CustomFilterResource;
    readonly wanted: WantedResource;
    readonly filesystem: FileSystemResource;
    readonly mediaCover: MediaCoverResource;
    constructor(config: ClientConfig);
}

export { type AddMovieOptions, type AlternativeTitle, type ApplyTags, type AutoTagging, type AutoTaggingSpecificationSchema, type Backup, type BackupType, type Blocklist, type BlocklistBulk, type BlocklistPagingResource, type CalendarFeedOptions, type CalendarOptions, ClientConfig, type Collection, type CollectionMovie, type CollectionUpdate, type Command, type CommandPriority, type CommandResource, type CommandResult, type CommandStatus, type CommandTrigger, type Credit, type CustomFilter, type CustomFormat, type CustomFormatBulk, type CustomFormatSpecificationSchema, type DelayProfile, type DeleteMovieOptions, type DeleteQueueOptions, type DiskSpace, type DownloadClient, type DownloadClientBulk, type DownloadClientConfig, type DownloadProtocol, type ExtraFile, type Field, type FileSystemEntry, type GetBlocklistOptions, type GetFileSystemOptions, type GetHistoryOptions, type GetManualImportOptions, type GetMovieOptions, type GetQueueDetailsOptions, type GetQueueOptions, type GetWantedOptions, type Health, type HealthCheckResult, type History, type HistoryPagingResource, type HostConfig, type ImportExclusion, type ImportExclusionBulk, type ImportExclusionPagingResource, type ImportList, type ImportListBulk, type ImportListConfig, type Indexer, type IndexerBulk, type IndexerConfig, type IndexerFlag, type Language, type LanguageResource, type LocalizationLanguage, type Log, type LogFile, type LogPagingResource, type ManualImport, type ManualImportReprocess, type MediaCover, type MediaCoverTypes, type MediaInfo, type MediaManagementConfig, type Metadata, type Movie, type MovieEditor, type MovieFile, type MovieFileList, type MovieHistoryEventType, type MovieStatistics, type MovieStatusType, type NamingConfig, type Notification, type Parse, type ProfileFormatItem, type ProviderMessage, type Quality, type QualityDefinition, type QualityDefinitionLimits, type QualityModel, type QualityProfile, type QualityProfileQualityItem, type Queue, type QueueBulk, type QueuePagingResource, type QueueStatus, RadarrClient, type RadarrCommand, type RadarrManualImportFile, type Ratings, type Release, type ReleaseType, type RemotePathMapping, type RenameMovie, type RootFolder, type SearchReleasesOptions, type SelectOption, type SortDirection, type SystemResource, type Tag, type TagDetails, type Task, type UiConfig, type Update };