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

type components = {
    schemas: {
        ApiInfoResource: {
            current?: string | null;
            deprecated?: string[] | null;
        };
        ApplicationBulkResource: {
            applyTags?: components["schemas"]["ApplyTags"];
            ids?: number[] | null;
            syncLevel?: components["schemas"]["ApplicationSyncLevel"];
            tags?: number[] | null;
        };
        ApplicationResource: {
            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"];
            name?: string | null;
            presets?: components["schemas"]["ApplicationResource"][] | null;
            syncLevel?: components["schemas"]["ApplicationSyncLevel"];
            tags?: number[] | null;
            testCommand?: string | null;
        };
        /** @enum {string} */
        ApplicationSyncLevel: "disabled" | "addOnly" | "fullSync";
        /** @enum {string} */
        ApplyTags: "add" | "remove" | "replace";
        AppProfileResource: {
            enableAutomaticSearch?: boolean;
            enableInteractiveSearch?: boolean;
            enableRss?: boolean;
            /** Format: int32 */
            id?: number;
            /** Format: int32 */
            minimumSeeders?: number;
            name?: string | null;
        };
        /** @enum {string} */
        AuthenticationRequiredType: "enabled" | "disabledForLocalAddresses";
        /** @enum {string} */
        AuthenticationType: "none" | "basic" | "forms" | "external";
        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";
        /** @enum {string} */
        BookSearchParam: "q" | "title" | "author" | "publisher" | "genre" | "year";
        /** @enum {string} */
        CertificateValidationType: "enabled" | "disabledForLocalAddresses" | "disabled";
        Command: {
            clientUserAgent?: string | null;
            readonly completionMessage?: string | null;
            readonly isExclusive?: 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;
            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} */
        CommandStatus: "queued" | "started" | "completed" | "failed" | "aborted" | "cancelled" | "orphaned";
        /** @enum {string} */
        CommandTrigger: "unspecified" | "manual" | "scheduled";
        CustomFilterResource: {
            filters?: {
                [key: string]: unknown;
            }[] | null;
            /** Format: int32 */
            id?: number;
            label?: string | null;
            type?: string | null;
        };
        /** @enum {string} */
        DatabaseType: "sqLite" | "postgreSQL";
        DevelopmentConfigResource: {
            consoleLogLevel?: string | null;
            filterSentryEvents?: boolean;
            /** Format: int32 */
            id?: number;
            logIndexerResponse?: boolean;
            /** Format: int32 */
            logRotate?: number;
            logSql?: boolean;
        };
        DownloadClientBulkResource: {
            applyTags?: components["schemas"]["ApplyTags"];
            enable?: boolean | null;
            ids?: number[] | null;
            /** Format: int32 */
            priority?: number | null;
            tags?: number[] | null;
        };
        DownloadClientCategory: {
            categories?: number[] | null;
            clientCategory?: string | null;
        };
        DownloadClientConfigResource: {
            /** Format: int32 */
            id?: number;
        };
        DownloadClientResource: {
            categories?: components["schemas"]["DownloadClientCategory"][] | null;
            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"];
            supportsCategories?: boolean;
            tags?: number[] | null;
        };
        /** @enum {string} */
        DownloadProtocol: "unknown" | "usenet" | "torrent";
        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} */
        HealthCheckResult: "ok" | "notice" | "warning" | "error";
        HealthResource: {
            /** Format: int32 */
            id?: number;
            message?: string | null;
            source?: string | null;
            type?: components["schemas"]["HealthCheckResult"];
            wikiUrl?: string | null;
        };
        /** @enum {string} */
        HistoryEventType: "unknown" | "releaseGrabbed" | "indexerQuery" | "indexerRss" | "indexerAuth" | "indexerInfo";
        HistoryResource: {
            data?: {
                [key: string]: string | null;
            } | null;
            /** Format: date-time */
            date?: string;
            downloadId?: string | null;
            eventType?: components["schemas"]["HistoryEventType"];
            /** Format: int32 */
            id?: number;
            /** Format: int32 */
            indexerId?: number;
            successful?: boolean;
        };
        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 */
            historyCleanupDays?: number;
            /** 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;
        };
        HostStatistics: {
            host?: string | null;
            /** Format: int32 */
            numberOfGrabs?: number;
            /** Format: int32 */
            numberOfQueries?: number;
        };
        IActionResult: Record<string, never>;
        IndexerBulkResource: {
            applyTags?: components["schemas"]["ApplyTags"];
            /** Format: int32 */
            appProfileId?: number | null;
            enable?: boolean | null;
            ids?: number[] | null;
            /** Format: int32 */
            minimumSeeders?: number | null;
            /** Format: int32 */
            packSeedTime?: number | null;
            preferMagnetUrl?: boolean | null;
            /** Format: int32 */
            priority?: number | null;
            /** Format: double */
            seedRatio?: number | null;
            /** Format: int32 */
            seedTime?: number | null;
            tags?: number[] | null;
        };
        IndexerCapabilityResource: {
            bookSearchParams?: components["schemas"]["BookSearchParam"][] | null;
            categories?: components["schemas"]["IndexerCategory"][] | null;
            /** Format: int32 */
            id?: number;
            /** Format: int32 */
            limitsDefault?: number | null;
            /** Format: int32 */
            limitsMax?: number | null;
            movieSearchParams?: components["schemas"]["MovieSearchParam"][] | null;
            musicSearchParams?: components["schemas"]["MusicSearchParam"][] | null;
            searchParams?: components["schemas"]["SearchParam"][] | null;
            supportsRawSearch?: boolean;
            tvSearchParams?: components["schemas"]["TvSearchParam"][] | null;
        };
        IndexerCategory: {
            description?: string | null;
            /** Format: int32 */
            id?: number;
            name?: string | null;
            readonly subCategories?: components["schemas"]["IndexerCategory"][] | null;
        };
        /** @enum {string} */
        IndexerPrivacy: "public" | "semiPrivate" | "private";
        IndexerProxyResource: {
            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;
            onHealthIssue?: boolean;
            presets?: components["schemas"]["IndexerProxyResource"][] | null;
            supportsOnHealthIssue?: boolean;
            tags?: number[] | null;
            testCommand?: string | null;
        };
        IndexerResource: {
            /** Format: date-time */
            added?: string;
            /** Format: int32 */
            appProfileId?: number;
            capabilities?: components["schemas"]["IndexerCapabilityResource"];
            configContract?: string | null;
            definitionName?: string | null;
            description?: string | null;
            /** Format: int32 */
            downloadClientId?: number;
            enable?: boolean;
            encoding?: string | null;
            fields?: components["schemas"]["Field"][] | null;
            /** Format: int32 */
            id?: number;
            implementation?: string | null;
            implementationName?: string | null;
            indexerUrls?: string[] | null;
            infoLink?: string | null;
            language?: string | null;
            legacyUrls?: string[] | null;
            message?: components["schemas"]["ProviderMessage"];
            name?: string | null;
            presets?: components["schemas"]["IndexerResource"][] | null;
            /** Format: int32 */
            priority?: number;
            privacy?: components["schemas"]["IndexerPrivacy"];
            protocol?: components["schemas"]["DownloadProtocol"];
            redirect?: boolean;
            sortName?: string | null;
            status?: components["schemas"]["IndexerStatusResource"];
            supportsPagination?: boolean;
            supportsRedirect?: boolean;
            supportsRss?: boolean;
            supportsSearch?: boolean;
            tags?: number[] | null;
        };
        IndexerStatistics: {
            /** Format: int32 */
            averageGrabResponseTime?: number;
            /** Format: int32 */
            averageResponseTime?: number;
            /** Format: int32 */
            indexerId?: number;
            indexerName?: string | null;
            /** Format: int32 */
            numberOfAuthQueries?: number;
            /** Format: int32 */
            numberOfFailedAuthQueries?: number;
            /** Format: int32 */
            numberOfFailedGrabs?: number;
            /** Format: int32 */
            numberOfFailedQueries?: number;
            /** Format: int32 */
            numberOfFailedRssQueries?: number;
            /** Format: int32 */
            numberOfGrabs?: number;
            /** Format: int32 */
            numberOfQueries?: number;
            /** Format: int32 */
            numberOfRssQueries?: number;
        };
        IndexerStatsResource: {
            hosts?: components["schemas"]["HostStatistics"][] | null;
            /** Format: int32 */
            id?: number;
            indexers?: components["schemas"]["IndexerStatistics"][] | null;
            userAgents?: components["schemas"]["UserAgentStatistics"][] | null;
        };
        IndexerStatusResource: {
            /** Format: date-time */
            disabledTill?: string | null;
            /** Format: int32 */
            id?: number;
            /** Format: int32 */
            indexerId?: number;
            /** Format: date-time */
            initialFailure?: string | null;
            /** Format: date-time */
            mostRecentFailure?: string | null;
        };
        LocalizationOption: {
            name?: string | null;
            value?: 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;
        };
        /** @enum {string} */
        MovieSearchParam: "q" | "imdbId" | "tmdbId" | "imdbTitle" | "imdbYear" | "traktId" | "genre" | "doubanId" | "year";
        /** @enum {string} */
        MusicSearchParam: "q" | "album" | "artist" | "label" | "year" | "genre" | "track";
        NotificationResource: {
            configContract?: string | null;
            fields?: components["schemas"]["Field"][] | null;
            /** Format: int32 */
            id?: number;
            implementation?: string | null;
            implementationName?: string | null;
            includeHealthWarnings?: boolean;
            includeManualGrabs?: boolean;
            infoLink?: string | null;
            link?: string | null;
            message?: components["schemas"]["ProviderMessage"];
            name?: string | null;
            onApplicationUpdate?: boolean;
            onGrab?: boolean;
            onHealthIssue?: boolean;
            onHealthRestored?: boolean;
            presets?: components["schemas"]["NotificationResource"][] | null;
            supportsOnApplicationUpdate?: boolean;
            supportsOnGrab?: boolean;
            supportsOnHealthIssue?: boolean;
            supportsOnHealthRestored?: boolean;
            tags?: number[] | null;
            testCommand?: string | null;
        };
        PingResource: {
            status?: string | null;
        };
        /** @enum {string} */
        PrivacyLevel: "normal" | "password" | "apiKey" | "userName";
        ProviderMessage: {
            message?: string | null;
            type?: components["schemas"]["ProviderMessageType"];
        };
        /** @enum {string} */
        ProviderMessageType: "info" | "warning" | "error";
        /** @enum {string} */
        ProxyType: "http" | "socks4" | "socks5";
        ReleaseResource: {
            /** Format: int32 */
            age?: number;
            /** Format: double */
            ageHours?: number;
            /** Format: double */
            ageMinutes?: number;
            categories?: components["schemas"]["IndexerCategory"][] | null;
            commentUrl?: string | null;
            /** Format: int32 */
            downloadClientId?: number | null;
            downloadUrl?: string | null;
            readonly fileName?: string | null;
            /** Format: int32 */
            files?: number | null;
            /** Format: int32 */
            grabs?: number | null;
            guid?: string | null;
            /** Format: int32 */
            id?: number;
            /** Format: int32 */
            imdbId?: number;
            indexer?: string | null;
            indexerFlags?: string[] | null;
            /** Format: int32 */
            indexerId?: number;
            infoHash?: string | null;
            infoUrl?: string | null;
            /** Format: int32 */
            leechers?: number | null;
            magnetUrl?: string | null;
            posterUrl?: string | null;
            protocol?: components["schemas"]["DownloadProtocol"];
            /** Format: date-time */
            publishDate?: string;
            releaseHash?: string | null;
            /** Format: int32 */
            seeders?: number | null;
            /** Format: int64 */
            size?: number;
            sortTitle?: string | null;
            subGroup?: string | null;
            title?: string | null;
            /** Format: int32 */
            tmdbId?: number;
            /** Format: int32 */
            tvdbId?: number;
            /** Format: int32 */
            tvMazeId?: number;
        };
        /** @enum {string} */
        RuntimeMode: "console" | "service" | "tray";
        /** @enum {string} */
        SearchParam: "q";
        SelectOption: {
            hint?: string | null;
            name?: string | null;
            /** Format: int32 */
            order?: number;
            /** Format: int32 */
            parentValue?: number | null;
            /** Format: int32 */
            value?: number;
        };
        /** @enum {string} */
        SortDirection: "default" | "ascending" | "descending";
        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: {
            applicationIds?: number[] | null;
            /** Format: int32 */
            id?: number;
            indexerIds?: number[] | null;
            indexerProxyIds?: number[] | null;
            label?: string | null;
            notificationIds?: 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} */
        TvSearchParam: "q" | "season" | "ep" | "imdbId" | "tvdbId" | "rId" | "tvMazeId" | "traktId" | "tmdbId" | "doubanId" | "genre" | "year";
        UiConfigResource: {
            calendarWeekColumnHeader?: string | null;
            enableColorImpairedMode?: boolean;
            /** Format: int32 */
            firstDayOfWeek?: number;
            /** Format: int32 */
            id?: number;
            longDateFormat?: string | null;
            shortDateFormat?: string | null;
            showRelativeDates?: boolean;
            theme?: string | null;
            timeFormat?: string | null;
            uiLanguage?: 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;
        };
        UserAgentStatistics: {
            /** Format: int32 */
            numberOfGrabs?: number;
            /** Format: int32 */
            numberOfQueries?: number;
            userAgent?: string | null;
        };
    };
    responses: never;
    parameters: never;
    requestBodies: never;
    headers: never;
    pathItems: never;
};

type Indexer = components['schemas']['IndexerResource'];
type IndexerBulk = components['schemas']['IndexerBulkResource'];
type IndexerCapability = components['schemas']['IndexerCapabilityResource'];
type IndexerProxy = components['schemas']['IndexerProxyResource'];
type IndexerStats = components['schemas']['IndexerStatsResource'];
type IndexerStatus = components['schemas']['IndexerStatusResource'];
type IndexerCategory = components['schemas']['IndexerCategory'];
type Application = components['schemas']['ApplicationResource'];
type ApplicationBulk = components['schemas']['ApplicationBulkResource'];
type AppProfile = components['schemas']['AppProfileResource'];
type Release = components['schemas']['ReleaseResource'];
type Command = components['schemas']['Command'];
type CommandResource = components['schemas']['CommandResource'];
type CommandStatus = components['schemas']['CommandStatus'];
type CommandPriority = components['schemas']['CommandPriority'];
type CommandTrigger = components['schemas']['CommandTrigger'];
type History = components['schemas']['HistoryResource'];
type DownloadClient = components['schemas']['DownloadClientResource'];
type DownloadClientBulk = components['schemas']['DownloadClientBulkResource'];
type DownloadClientConfig = components['schemas']['DownloadClientConfigResource'];
type DownloadProtocol = components['schemas']['DownloadProtocol'];
type Notification = components['schemas']['NotificationResource'];
type Tag = components['schemas']['TagResource'];
type TagDetails = components['schemas']['TagDetailsResource'];
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 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 DevelopmentConfig = components['schemas']['DevelopmentConfigResource'];
type CustomFilter = components['schemas']['CustomFilterResource'];
type LocalizationOption = components['schemas']['LocalizationOption'];
type ApiInfo = components['schemas']['ApiInfoResource'];
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 PrivacyLevel = components['schemas']['PrivacyLevel'];
type HistoryEventType = components['schemas']['HistoryEventType'];
type HistoryPagingResource = components['schemas']['HistoryResourcePagingResource'];
type LogPagingResource = components['schemas']['LogResourcePagingResource'];

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>;
}
interface GetIndexerStatsOptions {
    startDate?: Date | string;
    endDate?: Date | string;
    indexers?: number[];
    protocols?: number[];
    tags?: number[];
    [key: string]: unknown;
}
declare class IndexerStatsResource {
    private client;
    constructor(client: ClientMethods);
    get(options?: GetIndexerStatsOptions): Promise<IndexerStats>;
}
declare class IndexerStatusResource {
    private client;
    constructor(client: ClientMethods);
    getAll(): Promise<IndexerStatus[]>;
    getById(id: number): Promise<IndexerStatus>;
}

interface SearchOptions {
    query?: string;
    type?: 'search' | 'tvsearch' | 'movie' | 'music' | 'book';
    indexerIds?: number[];
    categories?: number[];
    limit?: number;
    offset?: number;
    [key: string]: unknown;
}
declare class SearchResource {
    private client;
    constructor(client: ClientMethods);
    query(options: SearchOptions): Promise<Release[]>;
    getById(guid: string): Promise<Release>;
    grab(release: {
        guid: string;
        indexerId: number;
    }): Promise<Release>;
    bulkGrab(releases: {
        guid: string;
        indexerId: number;
    }[]): Promise<Release[]>;
}

declare class ApplicationResource {
    private client;
    constructor(client: ClientMethods);
    getAll(): Promise<Application[]>;
    getById(id: number): Promise<Application>;
    create(application: Omit<Application, 'id'>): Promise<Application>;
    update(id: number, application: Partial<Application> & {
        id: number;
    }, forceSave?: boolean): Promise<Application>;
    delete(id: number): Promise<void>;
    bulkUpdate(applications: ApplicationBulk): Promise<Application[]>;
    bulkDelete(ids: number[]): Promise<void>;
    getSchema(): Promise<Application[]>;
    test(application: Partial<Application>): Promise<void>;
    testAll(): Promise<void>;
    sync(): Promise<void>;
}

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

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

type ProwlarrCommand = {
    name: 'ApplicationCheckUpdate';
} | {
    name: 'ApplicationIndexerSync';
    forceSync?: boolean;
} | {
    name: 'Backup';
} | {
    name: 'ClearLog';
} | {
    name: 'IndexerStatus';
} | {
    name: 'RssSync';
} | {
    name: 'RefreshIndexers';
};
declare class CommandResource_ {
    private client;
    constructor(client: ClientMethods);
    getAll(): Promise<CommandResource[]>;
    getById(id: number): Promise<CommandResource>;
    execute(command: ProwlarrCommand): Promise<CommandResource>;
    cancel(id: number): Promise<void>;
    refreshIndexers(): Promise<CommandResource>;
    rssSync(): Promise<CommandResource>;
    backup(): Promise<CommandResource>;
    applicationIndexerSync(forceSync?: boolean): Promise<CommandResource>;
}

type EventTypeInput = HistoryEventType | number;
type EventTypeFilter = EventTypeInput | EventTypeInput[];
interface GetHistoryOptions extends PaginationOptions {
    eventType?: EventTypeFilter;
    indexerId?: number;
    indexerIds?: number[];
    downloadId?: string;
    successful?: boolean;
}
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[]>;
    getByIndexer(indexerId: number, options?: {
        limit?: number;
    }): Promise<History[]>;
    getSince(date: Date | string, options?: {
        eventType?: EventTypeInput;
    }): Promise<History[]>;
}

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 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 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 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 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[]>;
}

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 DevelopmentConfigResource {
    private client;
    constructor(client: ClientMethods);
    get(): Promise<DevelopmentConfig>;
    update(config: Partial<DevelopmentConfig> & {
        id: number;
    }): Promise<DevelopmentConfig>;
}

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 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;
    }>;
}

declare class LocalizationResource {
    private client;
    constructor(client: ClientMethods);
    /**
     * Get localization dictionary
     */
    get(): Promise<Record<string, string>>;
    /**
     * Get available localization language options
     */
    getOptions(): Promise<LocalizationOption[]>;
}

/**
 * Search options for Newznab/Torznab queries
 */
interface NewznabSearchOptions {
    /** Search query string */
    q?: string;
    /** Categories to search (comma-separated or array) */
    cat?: string | number[];
    /** Extended attributes flag */
    extended?: 0 | 1;
    /** Maximum results to return */
    limit?: number;
    /** Offset for pagination */
    offset?: number;
    /** API key (optional, uses configured key if not provided) */
    apikey?: string;
    [key: string]: unknown;
}
/**
 * TV search specific options
 */
interface NewznabTvSearchOptions extends NewznabSearchOptions {
    /** TVDB ID */
    tvdbid?: number;
    /** TVRage ID */
    rid?: number;
    /** TVMAZE ID */
    tvmazeid?: number;
    /** IMDB ID (for TV shows) */
    imdbid?: string;
    /** TMDb ID */
    tmdbid?: number;
    /** Season number */
    season?: number | string;
    /** Episode number */
    ep?: number | string;
}
/**
 * Movie search specific options
 */
interface NewznabMovieSearchOptions extends NewznabSearchOptions {
    /** IMDB ID (e.g., "tt1234567" or just "1234567") */
    imdbid?: string;
    /** TMDb ID */
    tmdbid?: number;
}
/**
 * Music search specific options
 */
interface NewznabMusicSearchOptions extends NewznabSearchOptions {
    /** Album name */
    album?: string;
    /** Artist name */
    artist?: string;
    /** Music label */
    label?: string;
    /** Release year */
    year?: number;
}
/**
 * Book search specific options
 */
interface NewznabBookSearchOptions extends NewznabSearchOptions {
    /** Book title */
    title?: string;
    /** Author name */
    author?: string;
}
/**
 * Resource for accessing Newznab/Torznab API endpoints
 *
 * These endpoints provide standardized indexer access using the Newznab protocol,
 * which returns XML responses. Torznab is the torrent-specific extension of Newznab.
 *
 * @example
 * ```typescript
 * const prowlarr = new ProwlarrClient({ baseUrl: 'http://localhost:9696', apiKey: 'your-api-key' })
 *
 * // Get indexer capabilities
 * const caps = await prowlarr.newznab.getCaps(1)
 *
 * // Search for releases
 * const results = await prowlarr.newznab.search(1, { q: 'ubuntu' })
 *
 * // TV search with TVDB ID
 * const tvResults = await prowlarr.newznab.tvSearch(1, { tvdbid: 12345, season: 1, ep: 1 })
 *
 * // Download a release
 * const nzb = await prowlarr.newznab.download(1, 'release-guid')
 * ```
 */
declare class NewznabResource {
    private client;
    constructor(client: ClientMethods);
    /**
     * Get indexer capabilities (Newznab caps function)
     * Returns XML describing what the indexer supports including categories,
     * search capabilities, and server info.
     *
     * @param indexerId The indexer ID
     * @returns XML string containing indexer capabilities
     */
    getCaps(indexerId: number): Promise<string>;
    /**
     * Perform a general search using Newznab protocol
     *
     * @param indexerId The indexer ID
     * @param options Search options
     * @returns XML string containing search results
     */
    search(indexerId: number, options?: NewznabSearchOptions): Promise<string>;
    /**
     * Perform a TV search using Newznab protocol
     * Supports searching by TVDB ID, TVRage ID, IMDB ID, or query string
     *
     * @param indexerId The indexer ID
     * @param options TV search options including IDs and season/episode
     * @returns XML string containing search results
     */
    tvSearch(indexerId: number, options?: NewznabTvSearchOptions): Promise<string>;
    /**
     * Perform a movie search using Newznab protocol
     * Supports searching by IMDB ID, TMDb ID, or query string
     *
     * @param indexerId The indexer ID
     * @param options Movie search options
     * @returns XML string containing search results
     */
    movieSearch(indexerId: number, options?: NewznabMovieSearchOptions): Promise<string>;
    /**
     * Perform a music search using Newznab protocol
     *
     * @param indexerId The indexer ID
     * @param options Music search options
     * @returns XML string containing search results
     */
    musicSearch(indexerId: number, options?: NewznabMusicSearchOptions): Promise<string>;
    /**
     * Perform a book search using Newznab protocol
     *
     * @param indexerId The indexer ID
     * @param options Book search options
     * @returns XML string containing search results
     */
    bookSearch(indexerId: number, options?: NewznabBookSearchOptions): Promise<string>;
    /**
     * Download a release (NZB file for Usenet, torrent file for Torznab)
     *
     * @param indexerId The indexer ID
     * @param guid The release GUID or link identifier
     * @returns ArrayBuffer containing the downloaded file
     */
    download(indexerId: number, guid: string): Promise<ArrayBuffer>;
    /**
     * Get raw RSS/Atom feed for an indexer
     *
     * @param indexerId The indexer ID
     * @param options Optional feed options (limit, cat, etc.)
     * @returns XML string containing the feed
     */
    getFeed(indexerId: number, options?: NewznabSearchOptions): Promise<string>;
    /**
     * Format options for API call, converting arrays to comma-separated strings
     */
    private formatOptions;
}

declare class ProwlarrClient extends BaseClient {
    readonly indexer: IndexerResource;
    readonly indexerStats: IndexerStatsResource;
    readonly indexerStatus: IndexerStatusResource;
    readonly search: SearchResource;
    readonly application: ApplicationResource;
    readonly appProfile: AppProfileResource;
    readonly indexerProxy: IndexerProxyResource;
    readonly command: CommandResource_;
    readonly history: HistoryResource;
    readonly downloadClient: DownloadClientResource;
    readonly downloadClientConfig: DownloadClientConfigResource;
    readonly notification: NotificationResource;
    readonly tag: TagResource;
    readonly tagDetails: TagDetailsResource;
    readonly system: SystemInfoResource;
    readonly health: HealthResource;
    readonly task: TaskResource;
    readonly backup: BackupResource;
    readonly log: LogResource;
    readonly logFile: LogFileResource;
    readonly update: UpdateResource;
    readonly hostConfig: HostConfigResource;
    readonly uiConfig: UiConfigResource;
    readonly developmentConfig: DevelopmentConfigResource;
    readonly customFilter: CustomFilterResource;
    readonly filesystem: FileSystemResource;
    readonly localization: LocalizationResource;
    readonly newznab: NewznabResource;
    constructor(config: ClientConfig);
}

export { type ApiInfo, type AppProfile, type Application, type ApplicationBulk, type ApplyTags, type Backup, type BackupType, ClientConfig, type Command, type CommandPriority, type CommandResource, type CommandStatus, type CommandTrigger, type CustomFilter, type DevelopmentConfig, type DownloadClient, type DownloadClientBulk, type DownloadClientConfig, type DownloadProtocol, type Field, type FileSystemEntry, type GetFileSystemOptions, type GetHistoryOptions, type GetIndexerStatsOptions, type Health, type HealthCheckResult, type History, type HistoryEventType, type HistoryPagingResource, type HostConfig, type Indexer, type IndexerBulk, type IndexerCapability, type IndexerCategory, type IndexerProxy, type IndexerStats, type IndexerStatus, type LocalizationOption, type Log, type LogFile, type LogPagingResource, type NewznabBookSearchOptions, type NewznabMovieSearchOptions, type NewznabMusicSearchOptions, NewznabResource, type NewznabSearchOptions, type NewznabTvSearchOptions, type Notification, type PrivacyLevel, type ProviderMessage, ProwlarrClient, type ProwlarrCommand, type Release, type SearchOptions, type SelectOption, type SortDirection, type SystemResource, type Tag, type TagDetails, type Task, type UiConfig, type Update };