@thelord/mcp-arr 1.0.0

package/dist/arr-client.d.ts

@@ -0,0 +1,784 @@
+/**
+ * *arr Suite API Client
+ *
+ * All *arr applications (Sonarr, Radarr, Lidarr, Readarr, Prowlarr) use
+ * the same REST API pattern with X-Api-Key header authentication.
+ */
+export type ArrService = 'sonarr' | 'radarr' | 'lidarr' | 'readarr' | 'prowlarr';
+export interface ArrConfig {
+    url: string;
+    apiKey: string;
+}
+export interface SystemStatus {
+    appName: string;
+    version: string;
+    buildTime: string;
+    isDebug: boolean;
+    isProduction: boolean;
+    isAdmin: boolean;
+    isUserInteractive: boolean;
+    startupPath: string;
+    appData: string;
+    osName: string;
+    isDocker: boolean;
+    isLinux: boolean;
+    isOsx: boolean;
+    isWindows: boolean;
+}
+export interface QueueItem {
+    id: number;
+    title: string;
+    status: string;
+    trackedDownloadStatus: string;
+    trackedDownloadState: string;
+    statusMessages: Array<{
+        title: string;
+        messages: string[];
+    }>;
+    downloadId: string;
+    protocol: string;
+    downloadClient: string;
+    outputPath: string;
+    sizeleft: number;
+    size: number;
+    timeleft: string;
+    estimatedCompletionTime: string;
+}
+export interface Series {
+    id: number;
+    title: string;
+    sortTitle: string;
+    status: string;
+    overview: string;
+    network: string;
+    airTime: string;
+    images: Array<{
+        coverType: string;
+        url: string;
+    }>;
+    seasons: Array<{
+        seasonNumber: number;
+        monitored: boolean;
+    }>;
+    year: number;
+    path: string;
+    qualityProfileId: number;
+    seasonFolder: boolean;
+    monitored: boolean;
+    runtime: number;
+    tvdbId: number;
+    tvRageId: number;
+    tvMazeId: number;
+    firstAired: string;
+    seriesType: string;
+    cleanTitle: string;
+    imdbId: string;
+    titleSlug: string;
+    genres: string[];
+    tags: number[];
+    added: string;
+    ratings: {
+        votes: number;
+        value: number;
+    };
+    statistics: {
+        seasonCount: number;
+        episodeFileCount: number;
+        episodeCount: number;
+        totalEpisodeCount: number;
+        sizeOnDisk: number;
+        percentOfEpisodes: number;
+    };
+}
+export interface Episode {
+    id: number;
+    seriesId: number;
+    tvdbId: number;
+    episodeFileId: number;
+    seasonNumber: number;
+    episodeNumber: number;
+    title: string;
+    airDate: string;
+    airDateUtc: string;
+    overview: string;
+    hasFile: boolean;
+    monitored: boolean;
+    absoluteEpisodeNumber: number;
+    unverifiedSceneNumbering: boolean;
+    episodeFile?: {
+        id: number;
+        relativePath: string;
+        path: string;
+        size: number;
+        dateAdded: string;
+        quality: {
+            quality: {
+                id: number;
+                name: string;
+            };
+        };
+    };
+}
+export interface Book {
+    id: number;
+    title: string;
+    authorId: number;
+    foreignBookId: string;
+    titleSlug: string;
+    overview: string;
+    releaseDate: string;
+    pageCount: number;
+    monitored: boolean;
+    grabbed: boolean;
+    ratings: {
+        votes: number;
+        value: number;
+    };
+    editions: Array<{
+        id: number;
+        bookId: number;
+        foreignEditionId: string;
+        title: string;
+        pageCount: number;
+        isEbook: boolean;
+        monitored: boolean;
+    }>;
+    statistics?: {
+        bookFileCount: number;
+        bookCount: number;
+        totalBookCount: number;
+        sizeOnDisk: number;
+        percentOfBooks: number;
+    };
+}
+export interface Movie {
+    id: number;
+    title: string;
+    sortTitle: string;
+    sizeOnDisk: number;
+    status: string;
+    overview: string;
+    inCinemas: string;
+    physicalRelease: string;
+    digitalRelease: string;
+    images: Array<{
+        coverType: string;
+        url: string;
+    }>;
+    website: string;
+    year: number;
+    hasFile: boolean;
+    youTubeTrailerId: string;
+    studio: string;
+    path: string;
+    qualityProfileId: number;
+    monitored: boolean;
+    minimumAvailability: string;
+    isAvailable: boolean;
+    folderName: string;
+    runtime: number;
+    cleanTitle: string;
+    imdbId: string;
+    tmdbId: number;
+    titleSlug: string;
+    genres: string[];
+    tags: number[];
+    added: string;
+    ratings: {
+        votes: number;
+        value: number;
+    };
+    movieFile?: {
+        id: number;
+        relativePath: string;
+        path: string;
+        size: number;
+        dateAdded: string;
+        quality: {
+            quality: {
+                id: number;
+                name: string;
+            };
+        };
+    };
+}
+export interface Album {
+    id: number;
+    title: string;
+    disambiguation: string;
+    overview: string;
+    artistId: number;
+    foreignAlbumId: string;
+    monitored: boolean;
+    anyReleaseOk: boolean;
+    profileId: number;
+    duration: number;
+    albumType: string;
+    genres: string[];
+    images: Array<{
+        coverType: string;
+        url: string;
+    }>;
+    links: Array<{
+        url: string;
+        name: string;
+    }>;
+    statistics?: {
+        trackFileCount: number;
+        trackCount: number;
+        totalTrackCount: number;
+        sizeOnDisk: number;
+        percentOfTracks: number;
+    };
+    releaseDate: string;
+    releases: Array<{
+        id: number;
+        albumId: number;
+        foreignReleaseId: string;
+        title: string;
+        status: string;
+        duration: number;
+        trackCount: number;
+        monitored: boolean;
+    }>;
+    grabbed: boolean;
+}
+export interface Artist {
+    id: number;
+    artistName: string;
+    sortName: string;
+    status: string;
+    overview: string;
+    artistType: string;
+    disambiguation: string;
+    links: Array<{
+        url: string;
+        name: string;
+    }>;
+    images: Array<{
+        coverType: string;
+        url: string;
+    }>;
+    path: string;
+    qualityProfileId: number;
+    metadataProfileId: number;
+    monitored: boolean;
+    monitorNewItems: string;
+    genres: string[];
+    cleanName: string;
+    foreignArtistId: string;
+    tags: number[];
+    added: string;
+    ratings: {
+        votes: number;
+        value: number;
+    };
+    statistics: {
+        albumCount: number;
+        trackFileCount: number;
+        trackCount: number;
+        totalTrackCount: number;
+        sizeOnDisk: number;
+        percentOfTracks: number;
+    };
+}
+export interface Author {
+    id: number;
+    authorName: string;
+    sortName: string;
+    status: string;
+    overview: string;
+    links: Array<{
+        url: string;
+        name: string;
+    }>;
+    images: Array<{
+        coverType: string;
+        url: string;
+    }>;
+    path: string;
+    qualityProfileId: number;
+    metadataProfileId: number;
+    monitored: boolean;
+    monitorNewItems: string;
+    genres: string[];
+    cleanName: string;
+    foreignAuthorId: string;
+    tags: number[];
+    added: string;
+    ratings: {
+        votes: number;
+        value: number;
+        popularity: number;
+    };
+    statistics: {
+        bookFileCount: number;
+        bookCount: number;
+        totalBookCount: number;
+        sizeOnDisk: number;
+        percentOfBooks: number;
+    };
+}
+export interface Indexer {
+    id: number;
+    name: string;
+    enableRss: boolean;
+    enableAutomaticSearch: boolean;
+    enableInteractiveSearch: boolean;
+    protocol: string;
+    priority: number;
+    added: string;
+}
+export interface QualityProfile {
+    id: number;
+    name: string;
+    upgradeAllowed: boolean;
+    cutoff: number;
+    items: Array<{
+        id?: number;
+        name?: string;
+        quality?: {
+            id: number;
+            name: string;
+            source: string;
+            resolution: number;
+        };
+        items?: Array<{
+            quality: {
+                id: number;
+                name: string;
+            };
+        }>;
+        allowed: boolean;
+    }>;
+    minFormatScore: number;
+    cutoffFormatScore: number;
+    formatItems: Array<{
+        format: number;
+        name: string;
+        score: number;
+    }>;
+}
+export interface QualityDefinition {
+    id: number;
+    quality: {
+        id: number;
+        name: string;
+        source: string;
+        resolution: number;
+    };
+    title: string;
+    weight: number;
+    minSize: number;
+    maxSize: number;
+    preferredSize: number;
+}
+export interface DownloadClient {
+    id: number;
+    name: string;
+    implementation: string;
+    implementationName: string;
+    configContract: string;
+    enable: boolean;
+    protocol: string;
+    priority: number;
+    removeCompletedDownloads: boolean;
+    removeFailedDownloads: boolean;
+    fields: Array<{
+        name: string;
+        value: unknown;
+    }>;
+    tags: number[];
+}
+export interface NamingConfig {
+    renameEpisodes?: boolean;
+    replaceIllegalCharacters: boolean;
+    colonReplacementFormat?: string;
+    standardEpisodeFormat?: string;
+    dailyEpisodeFormat?: string;
+    animeEpisodeFormat?: string;
+    seriesFolderFormat?: string;
+    seasonFolderFormat?: string;
+    specialsFolderFormat?: string;
+    multiEpisodeStyle?: number;
+    renameMovies?: boolean;
+    movieFolderFormat?: string;
+    standardMovieFormat?: string;
+    renameTracks?: boolean;
+    artistFolderFormat?: string;
+    albumFolderFormat?: string;
+    trackFormat?: string;
+    renameBooks?: boolean;
+    authorFolderFormat?: string;
+    bookFolderFormat?: string;
+    standardBookFormat?: string;
+}
+export interface MediaManagementConfig {
+    autoUnmonitorPreviouslyDownloadedEpisodes?: boolean;
+    autoUnmonitorPreviouslyDownloadedMovies?: boolean;
+    recycleBin: string;
+    recycleBinCleanupDays: number;
+    downloadPropersAndRepacks: string;
+    createEmptySeriesFolders?: boolean;
+    createEmptyMovieFolders?: boolean;
+    deleteEmptyFolders: boolean;
+    fileDate: string;
+    rescanAfterRefresh: string;
+    setPermissionsLinux: boolean;
+    chmodFolder: string;
+    chownGroup: string;
+    episodeTitleRequired?: string;
+    skipFreeSpaceCheckWhenImporting: boolean;
+    minimumFreeSpaceWhenImporting: number;
+    copyUsingHardlinks: boolean;
+    importExtraFiles: boolean;
+    extraFileExtensions: string;
+    enableMediaInfo: boolean;
+}
+export interface HealthCheck {
+    source: string;
+    type: string;
+    message: string;
+    wikiUrl: string;
+}
+export interface Tag {
+    id: number;
+    label: string;
+}
+export interface RootFolder {
+    id: number;
+    path: string;
+    accessible: boolean;
+    freeSpace: number;
+    unmappedFolders?: Array<{
+        name: string;
+        path: string;
+    }>;
+}
+export interface MetadataProfile {
+    id: number;
+    name: string;
+    minPopularity?: number;
+    skipMissingDate: boolean;
+    skipMissingIsbn: boolean;
+    skipPartsAndSets: boolean;
+    skipSeriesSecondary: boolean;
+    allowedLanguages?: string;
+    minPages?: number;
+}
+export interface SearchResult {
+    title: string;
+    sortTitle: string;
+    status: string;
+    overview: string;
+    year: number;
+    images: Array<{
+        coverType: string;
+        url: string;
+    }>;
+    remotePoster?: string;
+    tvdbId?: number;
+    tmdbId?: number;
+    imdbId?: string;
+    foreignArtistId?: string;
+    foreignAuthorId?: string;
+}
+export declare class ArrClient {
+    private config;
+    private serviceName;
+    protected apiVersion: string;
+    constructor(serviceName: ArrService, config: ArrConfig);
+    /**
+     * Make an API request
+     */
+    protected request<T>(endpoint: string, options?: RequestInit): Promise<T>;
+    /**
+     * Get system status
+     */
+    getStatus(): Promise<SystemStatus>;
+    /**
+     * Get download queue
+     */
+    getQueue(): Promise<{
+        records: QueueItem[];
+        totalRecords: number;
+    }>;
+    /**
+     * Get calendar items (upcoming releases)
+     */
+    getCalendar(start?: string, end?: string): Promise<unknown[]>;
+    /**
+     * Get all root folders
+     */
+    getRootFolders(): Promise<Array<{
+        id: number;
+        path: string;
+        freeSpace: number;
+    }>>;
+    /**
+     * Test connection
+     */
+    testConnection(): Promise<boolean>;
+    /**
+     * Get quality profiles
+     */
+    getQualityProfiles(): Promise<QualityProfile[]>;
+    /**
+     * Get quality definitions (size limits)
+     */
+    getQualityDefinitions(): Promise<QualityDefinition[]>;
+    /**
+     * Get download clients
+     */
+    getDownloadClients(): Promise<DownloadClient[]>;
+    /**
+     * Get naming configuration
+     */
+    getNamingConfig(): Promise<NamingConfig>;
+    /**
+     * Get media management configuration
+     */
+    getMediaManagement(): Promise<MediaManagementConfig>;
+    /**
+     * Get health check issues
+     */
+    getHealth(): Promise<HealthCheck[]>;
+    /**
+     * Get all tags
+     */
+    getTags(): Promise<Tag[]>;
+    /**
+     * Get detailed root folders
+     */
+    getRootFoldersDetailed(): Promise<RootFolder[]>;
+    /**
+     * Get indexers (per-app configuration, not Prowlarr)
+     */
+    getIndexers(): Promise<Indexer[]>;
+}
+export declare class SonarrClient extends ArrClient {
+    constructor(config: ArrConfig);
+    /**
+     * Get all series
+     */
+    getSeries(): Promise<Series[]>;
+    /**
+     * Get a specific series
+     */
+    getSeriesById(id: number): Promise<Series>;
+    /**
+     * Search for series
+     */
+    searchSeries(term: string): Promise<SearchResult[]>;
+    /**
+     * Add a series
+     */
+    addSeries(series: Partial<Series> & {
+        tvdbId: number;
+        rootFolderPath: string;
+        qualityProfileId: number;
+    }): Promise<Series>;
+    /**
+     * Trigger a search for missing episodes
+     */
+    searchMissing(seriesId: number): Promise<{
+        id: number;
+    }>;
+    /**
+     * Get episodes for a series, optionally filtered by season
+     */
+    getEpisodes(seriesId: number, seasonNumber?: number): Promise<Episode[]>;
+    /**
+     * Search for a specific episode
+     */
+    searchEpisode(episodeIds: number[]): Promise<{
+        id: number;
+    }>;
+}
+export declare class RadarrClient extends ArrClient {
+    constructor(config: ArrConfig);
+    /**
+     * Get all movies
+     */
+    getMovies(): Promise<Movie[]>;
+    /**
+     * Get a specific movie
+     */
+    getMovieById(id: number): Promise<Movie>;
+    /**
+     * Search for movies
+     */
+    searchMovies(term: string): Promise<SearchResult[]>;
+    /**
+     * Add a movie
+     */
+    addMovie(movie: Partial<Movie> & {
+        tmdbId: number;
+        rootFolderPath: string;
+        qualityProfileId: number;
+    }): Promise<Movie>;
+    /**
+     * Trigger a search for a movie
+     */
+    searchMovie(movieId: number): Promise<{
+        id: number;
+    }>;
+}
+export declare class LidarrClient extends ArrClient {
+    constructor(config: ArrConfig);
+    /**
+     * Get all artists
+     */
+    getArtists(): Promise<Artist[]>;
+    /**
+     * Get a specific artist
+     */
+    getArtistById(id: number): Promise<Artist>;
+    /**
+     * Search for artists
+     */
+    searchArtists(term: string): Promise<SearchResult[]>;
+    /**
+     * Add an artist
+     */
+    addArtist(artist: Partial<Artist> & {
+        foreignArtistId: string;
+        rootFolderPath: string;
+        qualityProfileId: number;
+        metadataProfileId: number;
+    }): Promise<Artist>;
+    /**
+     * Get all albums, optionally filtered by artist
+     */
+    getAlbums(artistId?: number): Promise<Album[]>;
+    /**
+     * Get a specific album
+     */
+    getAlbumById(id: number): Promise<Album>;
+    /**
+     * Search for missing albums for an artist
+     */
+    searchMissingAlbums(artistId: number): Promise<{
+        id: number;
+    }>;
+    /**
+     * Search for a specific album
+     */
+    searchAlbum(albumId: number): Promise<{
+        id: number;
+    }>;
+    /**
+     * Get calendar (upcoming album releases)
+     */
+    getCalendar(start?: string, end?: string): Promise<Album[]>;
+    /**
+     * Get metadata profiles
+     */
+    getMetadataProfiles(): Promise<MetadataProfile[]>;
+}
+export declare class ReadarrClient extends ArrClient {
+    constructor(config: ArrConfig);
+    /**
+     * Get all authors
+     */
+    getAuthors(): Promise<Author[]>;
+    /**
+     * Get a specific author
+     */
+    getAuthorById(id: number): Promise<Author>;
+    /**
+     * Search for authors
+     */
+    searchAuthors(term: string): Promise<SearchResult[]>;
+    /**
+     * Add an author
+     */
+    addAuthor(author: Partial<Author> & {
+        foreignAuthorId: string;
+        rootFolderPath: string;
+        qualityProfileId: number;
+        metadataProfileId: number;
+    }): Promise<Author>;
+    /**
+     * Get books for an author
+     */
+    getBooks(authorId?: number): Promise<Book[]>;
+    /**
+     * Get a specific book
+     */
+    getBookById(id: number): Promise<Book>;
+    /**
+     * Search for missing books for an author
+     */
+    searchMissingBooks(authorId: number): Promise<{
+        id: number;
+    }>;
+    /**
+     * Search for a specific book
+     */
+    searchBook(bookIds: number[]): Promise<{
+        id: number;
+    }>;
+    /**
+     * Get calendar (upcoming book releases)
+     */
+    getCalendar(start?: string, end?: string): Promise<Book[]>;
+    /**
+     * Get metadata profiles
+     */
+    getMetadataProfiles(): Promise<MetadataProfile[]>;
+}
+export interface IndexerStats {
+    id: number;
+    indexerId: number;
+    indexerName: string;
+    averageResponseTime: number;
+    numberOfQueries: number;
+    numberOfGrabs: number;
+    numberOfRssQueries: number;
+    numberOfAuthQueries: number;
+    numberOfFailedQueries: number;
+    numberOfFailedGrabs: number;
+    numberOfFailedRssQueries: number;
+    numberOfFailedAuthQueries: number;
+}
+export declare class ProwlarrClient extends ArrClient {
+    constructor(config: ArrConfig);
+    /**
+     * Get all indexers
+     */
+    getIndexers(): Promise<Indexer[]>;
+    /**
+     * Test all indexers
+     */
+    testAllIndexers(): Promise<Array<{
+        id: number;
+        isValid: boolean;
+        validationFailures: Array<{
+            propertyName: string;
+            errorMessage: string;
+        }>;
+    }>>;
+    /**
+     * Test a specific indexer
+     */
+    testIndexer(indexerId: number): Promise<{
+        id: number;
+        isValid: boolean;
+        validationFailures: Array<{
+            propertyName: string;
+            errorMessage: string;
+        }>;
+    }>;
+    /**
+     * Get indexer statistics
+     */
+    getIndexerStats(): Promise<{
+        indexers: IndexerStats[];
+    }>;
+    /**
+     * Search across all indexers
+     */
+    search(query: string, categories?: number[]): Promise<unknown[]>;
+}
+//# sourceMappingURL=arr-client.d.ts.map