@nice2dev/ui-tools 1.0.10

package/dist/download-torrent.d.ts

@@ -0,0 +1,1062 @@
+/**
+ * @file download-torrent.ts
+ * @module @nice2dev/ui-tools
+ * @description PRO-31 — Download & Torrent Suite
+ *
+ * Types for download management, BitTorrent clients, streaming,
+ * automation, platform integrations, and media management.
+ */
+/** Download status */
+export type DownloadStatus = 'queued' | 'downloading' | 'paused' | 'completed' | 'failed' | 'cancelled' | 'seeding' | 'checking' | 'allocating' | 'stalled';
+/** Download priority */
+export type DownloadPriority = 'low' | 'normal' | 'high' | 'critical';
+/** Transfer speed */
+export interface TransferSpeed {
+    bytesPerSecond: number;
+    displayValue: string;
+    displayUnit: 'B/s' | 'KB/s' | 'MB/s' | 'GB/s';
+}
+/** Transfer stats */
+export interface TransferStats {
+    downloaded: number;
+    uploaded: number;
+    remaining: number;
+    total: number;
+    progress: number;
+    downloadSpeed: TransferSpeed;
+    uploadSpeed: TransferSpeed;
+    eta?: number;
+    averageSpeed?: TransferSpeed;
+    peakSpeed?: TransferSpeed;
+}
+/** Bandwidth limit */
+export interface BandwidthLimit {
+    download?: number;
+    upload?: number;
+    unit: 'B/s' | 'KB/s' | 'MB/s';
+    enabled: boolean;
+}
+/** Download manager config */
+export interface DownloadManagerConfig {
+    defaultDownloadPath: string;
+    maxConcurrentDownloads: number;
+    bandwidthLimit?: BandwidthLimit;
+    retryAttempts: number;
+    retryDelay: number;
+    autoStart?: boolean;
+    resumeOnStartup?: boolean;
+    categories?: DownloadCategory[];
+    fileTypeFilters?: FileTypeFilter[];
+}
+/** Download category */
+export interface DownloadCategory {
+    id: string;
+    name: string;
+    path: string;
+    fileTypes?: string[];
+    icon?: string;
+    color?: string;
+}
+/** File type filter */
+export interface FileTypeFilter {
+    name: string;
+    extensions: string[];
+    category?: string;
+    mimeTypes?: string[];
+}
+/** Download item */
+export interface DownloadItem {
+    id: string;
+    url: string;
+    filename: string;
+    path: string;
+    status: DownloadStatus;
+    priority: DownloadPriority;
+    size?: number;
+    downloadedBytes: number;
+    progress: number;
+    speed: TransferSpeed;
+    eta?: number;
+    addedDate: Date;
+    startedDate?: Date;
+    completedDate?: Date;
+    errorMessage?: string;
+    retryCount: number;
+    category?: string;
+    source?: DownloadSource;
+    checksum?: FileChecksum;
+    metadata?: DownloadMetadata;
+}
+/** Download source */
+export interface DownloadSource {
+    type: DownloadSourceType;
+    protocol: DownloadProtocol;
+    host: string;
+    referrer?: string;
+    cookies?: string;
+    userAgent?: string;
+    auth?: DownloadAuth;
+}
+/** Download source type */
+export type DownloadSourceType = 'direct' | 'torrent' | 'magnet' | 'metalink' | 'nzb' | 'file_host' | 'debrid' | 'cloud';
+/** Download protocol */
+export type DownloadProtocol = 'http' | 'https' | 'ftp' | 'sftp' | 'bittorrent' | 'nzbget' | 'webdav';
+/** Download auth */
+export interface DownloadAuth {
+    type: 'basic' | 'bearer' | 'api_key' | 'oauth';
+    username?: string;
+    password?: string;
+    token?: string;
+    apiKey?: string;
+}
+/** File checksum */
+export interface FileChecksum {
+    algorithm: 'md5' | 'sha1' | 'sha256' | 'crc32';
+    value: string;
+    verified?: boolean;
+}
+/** Download metadata */
+export interface DownloadMetadata {
+    title?: string;
+    description?: string;
+    tags?: string[];
+    customFields?: Record<string, string>;
+}
+/** Download schedule */
+export interface DownloadSchedule {
+    startTime?: Date;
+    stopTime?: Date;
+    daysOfWeek?: number[];
+    priority?: DownloadPriority;
+    bandwidthLimit?: BandwidthLimit;
+}
+/** Download queue */
+export interface DownloadQueue {
+    items: DownloadItem[];
+    totalSize: number;
+    totalProgress: number;
+    activeDownloads: number;
+    queuedDownloads: number;
+    completedDownloads: number;
+}
+/** URL parse result */
+export interface URLParseResult {
+    url: string;
+    protocol: DownloadProtocol;
+    host: string;
+    filename: string;
+    extension?: string;
+    fileType?: string;
+    size?: number;
+    resumable?: boolean;
+    requiresAuth?: boolean;
+    isMagnet?: boolean;
+    isMetalink?: boolean;
+    magnetInfo?: MagnetLinkInfo;
+}
+/** Magnet link info */
+export interface MagnetLinkInfo {
+    infoHash: string;
+    displayName?: string;
+    trackers?: string[];
+    exactLength?: number;
+    keywords?: string[];
+}
+/** Torrent client config */
+export interface TorrentClientConfig {
+    downloadPath: string;
+    tempPath?: string;
+    maxActiveTorrents: number;
+    maxActiveSeedsperTorrent: number;
+    maxConnectionsPerTorrent: number;
+    maxGlobalConnections: number;
+    bandwidthLimit: BandwidthLimit;
+    dhtEnabled: boolean;
+    pexEnabled: boolean;
+    lpdEnabled: boolean;
+    upnpEnabled: boolean;
+    natPmpEnabled: boolean;
+    encryptionMode: EncryptionMode;
+    ipv6Enabled: boolean;
+    listeningPort: number;
+    proxySettings?: ProxySettings;
+}
+/** Encryption mode */
+export type EncryptionMode = 'disabled' | 'enabled' | 'forced';
+/** Proxy settings */
+export interface ProxySettings {
+    type: ProxyType;
+    host: string;
+    port: number;
+    username?: string;
+    password?: string;
+    proxyPeerConnections?: boolean;
+    proxyTrackers?: boolean;
+}
+/** Proxy type */
+export type ProxyType = 'http' | 'socks4' | 'socks5' | 'i2p' | 'tor';
+/** Torrent */
+export interface Torrent {
+    id: string;
+    infoHash: string;
+    name: string;
+    status: TorrentStatus;
+    progress: number;
+    size: number;
+    downloadedBytes: number;
+    uploadedBytes: number;
+    downloadSpeed: TransferSpeed;
+    uploadSpeed: TransferSpeed;
+    eta?: number;
+    ratio: number;
+    seeds: number;
+    peers: number;
+    addedDate: Date;
+    completedDate?: Date;
+    savePath: string;
+    files: TorrentFile[];
+    trackers: TorrentTracker[];
+    pieces: PieceStatus[];
+    comment?: string;
+    creator?: string;
+    creationDate?: Date;
+    isPrivate: boolean;
+    webSeeds?: string[];
+    errorMessage?: string;
+    label?: string;
+    priority: DownloadPriority;
+}
+/** Torrent status */
+export type TorrentStatus = 'downloading' | 'seeding' | 'paused' | 'checking' | 'queued' | 'error' | 'stopped' | 'finished' | 'allocating' | 'moving';
+/** Torrent file */
+export interface TorrentFile {
+    index: number;
+    path: string;
+    name: string;
+    size: number;
+    downloaded: number;
+    progress: number;
+    priority: FilePriority;
+    wanted: boolean;
+}
+/** File priority */
+export type FilePriority = 'skip' | 'low' | 'normal' | 'high';
+/** Torrent tracker */
+export interface TorrentTracker {
+    url: string;
+    tier: number;
+    status: TrackerStatus;
+    seeds?: number;
+    leechers?: number;
+    lastAnnounce?: Date;
+    nextAnnounce?: Date;
+    errorMessage?: string;
+}
+/** Tracker status */
+export type TrackerStatus = 'working' | 'updating' | 'error' | 'disabled' | 'not_contacted';
+/** Piece status */
+export type PieceStatus = 'missing' | 'requested' | 'downloading' | 'complete';
+/** Peer */
+export interface Peer {
+    id: string;
+    ip: string;
+    port: number;
+    client: string;
+    country?: string;
+    flags: PeerFlags;
+    progress: number;
+    downloadSpeed: TransferSpeed;
+    uploadSpeed: TransferSpeed;
+    downloaded: number;
+    uploaded: number;
+    connectionType: 'incoming' | 'outgoing';
+    isEncrypted: boolean;
+}
+/** Peer flags */
+export interface PeerFlags {
+    interested: boolean;
+    choked: boolean;
+    snubbed: boolean;
+    optimisticUnchoke: boolean;
+    peerInterested: boolean;
+    peerChoked: boolean;
+    supportsExtensions: boolean;
+    localConnection: boolean;
+    dht: boolean;
+    pex: boolean;
+    lpd: boolean;
+    utp: boolean;
+    webSeed: boolean;
+}
+/** Torrent creation options */
+export interface TorrentCreationOptions {
+    name: string;
+    sourcePath: string;
+    trackers: string[];
+    webSeeds?: string[];
+    pieceSize?: number;
+    isPrivate?: boolean;
+    comment?: string;
+    source?: string;
+}
+/** Created torrent */
+export interface CreatedTorrent {
+    infoHash: string;
+    magnetLink: string;
+    torrentFile: Uint8Array;
+    size: number;
+    pieceCount: number;
+    pieceSize: number;
+}
+/** Torrent dashboard stats */
+export interface TorrentDashboardStats {
+    downloadSpeed: TransferSpeed;
+    uploadSpeed: TransferSpeed;
+    activeDownloads: number;
+    activeSeeders: number;
+    totalDownloaded: number;
+    totalUploaded: number;
+    globalRatio: number;
+    dhtNodes: number;
+    totalPeers: number;
+    sessionDuration: number;
+}
+/** Streaming player config */
+export interface StreamingPlayerConfig {
+    bufferSize: number;
+    minBufferBeforePlay: number;
+    maxBufferAhead: number;
+    preferredQuality?: StreamQuality;
+    castEnabled?: boolean;
+    subtitleLanguages?: string[];
+}
+/** Stream quality */
+export type StreamQuality = 'auto' | '4k' | '1080p' | '720p' | '480p' | '360p' | 'audio_only';
+/** Stream status */
+export interface StreamStatus {
+    isPlaying: boolean;
+    isBuffering: boolean;
+    bufferProgress: number;
+    playbackPosition: number;
+    duration?: number;
+    currentQuality: StreamQuality;
+    availableQualities: StreamQuality[];
+    castingTo?: CastDevice;
+}
+/** Cast device */
+export interface CastDevice {
+    id: string;
+    name: string;
+    type: CastDeviceType;
+    status: 'idle' | 'casting' | 'unavailable';
+}
+/** Cast device type */
+export type CastDeviceType = 'chromecast' | 'dlna' | 'airplay' | 'roku';
+/** Video preview info */
+export interface VideoPreviewInfo {
+    duration: number;
+    width: number;
+    height: number;
+    codec: string;
+    bitrate: number;
+    frameRate: number;
+    thumbnails?: VideoThumbnail[];
+    audioTracks?: AudioTrackInfo[];
+    subtitleTracks?: SubtitleTrackInfo[];
+}
+/** Video thumbnail */
+export interface VideoThumbnail {
+    timestamp: number;
+    url: string;
+    width: number;
+    height: number;
+}
+/** Audio track info */
+export interface AudioTrackInfo {
+    index: number;
+    language: string;
+    codec: string;
+    channels: number;
+    bitrate: number;
+    default: boolean;
+}
+/** Subtitle track info */
+export interface SubtitleTrackInfo {
+    index: number;
+    language: string;
+    format: 'srt' | 'ass' | 'vtt' | 'sub';
+    default: boolean;
+    forced: boolean;
+}
+/** Audio preview info */
+export interface AudioPreviewInfo {
+    duration: number;
+    codec: string;
+    bitrate: number;
+    sampleRate: number;
+    channels: number;
+    waveformData?: number[];
+    metadata?: AudioMetadata;
+}
+/** Audio metadata (ID3 tags) */
+export interface AudioMetadata {
+    title?: string;
+    artist?: string;
+    album?: string;
+    year?: number;
+    track?: number;
+    genre?: string;
+    albumArt?: string;
+    duration?: number;
+}
+/** Archive contents */
+export interface ArchiveContents {
+    format: ArchiveFormat;
+    files: ArchiveFile[];
+    totalSize: number;
+    compressedSize: number;
+    compressionRatio: number;
+    isEncrypted: boolean;
+    comment?: string;
+}
+/** Archive format */
+export type ArchiveFormat = 'zip' | 'rar' | '7z' | 'tar' | 'tar.gz' | 'tar.bz2' | 'tar.xz';
+/** Archive file */
+export interface ArchiveFile {
+    path: string;
+    name: string;
+    size: number;
+    compressedSize: number;
+    isDirectory: boolean;
+    modifiedDate?: Date;
+    crc?: string;
+}
+/** Download scheduler config */
+export interface DownloadSchedulerConfig {
+    enabled: boolean;
+    rules: ScheduleRule[];
+    defaultBandwidth: BandwidthLimit;
+    autoShutdown?: AutoShutdownConfig;
+    wakeOnLan?: WakeOnLanConfig;
+}
+/** Schedule rule */
+export interface ScheduleRule {
+    id: string;
+    name: string;
+    enabled: boolean;
+    startTime: string;
+    endTime: string;
+    daysOfWeek: number[];
+    bandwidth?: BandwidthLimit;
+    priority?: DownloadPriority;
+    action?: ScheduleAction;
+}
+/** Schedule action */
+export type ScheduleAction = 'start' | 'pause' | 'limit' | 'unlimited';
+/** Auto shutdown config */
+export interface AutoShutdownConfig {
+    enabled: boolean;
+    action: 'shutdown' | 'hibernate' | 'sleep' | 'logout';
+    whenQueueEmpty?: boolean;
+    afterTime?: number;
+}
+/** Wake on LAN config */
+export interface WakeOnLanConfig {
+    enabled: boolean;
+    macAddress: string;
+    broadcastAddress: string;
+    port: number;
+}
+/** RSS feed config */
+export interface RSSFeedConfig {
+    id: string;
+    name: string;
+    url: string;
+    enabled: boolean;
+    refreshInterval: number;
+    filters: RSSFilter[];
+    downloadPath?: string;
+    lastUpdated?: Date;
+    lastError?: string;
+}
+/** RSS filter */
+export interface RSSFilter {
+    id: string;
+    name: string;
+    enabled: boolean;
+    matchType: 'include' | 'exclude';
+    pattern: string;
+    isRegex: boolean;
+    qualityPreference?: string[];
+    episodeRange?: {
+        min?: number;
+        max?: number;
+    };
+}
+/** RSS item */
+export interface RSSItem {
+    id: string;
+    feedId: string;
+    title: string;
+    link: string;
+    pubDate: Date;
+    description?: string;
+    enclosure?: {
+        url: string;
+        type: string;
+        length: number;
+    };
+    matched: boolean;
+    downloaded: boolean;
+}
+/** Watch folder config */
+export interface WatchFolderConfig {
+    id: string;
+    path: string;
+    enabled: boolean;
+    patterns: string[];
+    recursive: boolean;
+    processedPath?: string;
+    action: WatchFolderAction;
+}
+/** Watch folder action */
+export type WatchFolderAction = 'add' | 'add_paused' | 'add_and_delete';
+/** Automation rule */
+export interface AutomationRule {
+    id: string;
+    name: string;
+    enabled: boolean;
+    trigger: AutomationTrigger;
+    conditions: AutomationCondition[];
+    actions: AutomationAction[];
+}
+/** Automation trigger */
+export type AutomationTrigger = 'on_add' | 'on_start' | 'on_complete' | 'on_error' | 'on_ratio_reached' | 'on_seed_time_reached';
+/** Automation condition */
+export interface AutomationCondition {
+    field: AutomationField;
+    operator: AutomationOperator;
+    value: string | number;
+}
+/** Automation field */
+export type AutomationField = 'name' | 'size' | 'category' | 'tracker' | 'file_type' | 'ratio' | 'seed_time';
+/** Automation operator */
+export type AutomationOperator = 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'matches_regex';
+/** Automation action */
+export interface AutomationAction {
+    type: AutomationActionType;
+    parameters?: Record<string, unknown>;
+}
+/** Automation action type */
+export type AutomationActionType = 'move' | 'rename' | 'set_category' | 'set_label' | 'run_script' | 'send_notification' | 'pause' | 'resume' | 'remove' | 'remove_with_data';
+/** Script config */
+export interface ScriptConfig {
+    id: string;
+    name: string;
+    trigger: ScriptTrigger;
+    command: string;
+    shell?: 'cmd' | 'powershell' | 'bash' | 'sh';
+    arguments?: string[];
+    workingDirectory?: string;
+    timeout?: number;
+    variables?: ScriptVariable[];
+}
+/** Script trigger */
+export type ScriptTrigger = 'on_download_start' | 'on_download_complete' | 'on_download_error' | 'on_torrent_complete' | 'on_ratio_reached';
+/** Script variable */
+export interface ScriptVariable {
+    name: string;
+    description: string;
+    example: string;
+}
+/** Usenet config */
+export interface UsenetConfig {
+    servers: UsenetServer[];
+    downloadPath: string;
+    tempPath?: string;
+    maxConnections: number;
+    par2Repair: boolean;
+    autoExtract: boolean;
+    deleteAfterExtract: boolean;
+}
+/** Usenet server */
+export interface UsenetServer {
+    id: string;
+    host: string;
+    port: number;
+    ssl: boolean;
+    username: string;
+    password: string;
+    connections: number;
+    priority: number;
+    enabled: boolean;
+    retention?: number;
+}
+/** NZB file */
+export interface NZBFile {
+    id: string;
+    name: string;
+    status: UsenetStatus;
+    size: number;
+    downloaded: number;
+    progress: number;
+    speed: TransferSpeed;
+    eta?: number;
+    files: NZBFileEntry[];
+    parStatus?: ParStatus;
+    unpackStatus?: UnpackStatus;
+}
+/** Usenet status */
+export type UsenetStatus = 'queued' | 'downloading' | 'verifying' | 'repairing' | 'extracting' | 'completed' | 'failed';
+/** NZB file entry */
+export interface NZBFileEntry {
+    name: string;
+    size: number;
+    downloaded: number;
+    segments: number;
+    segmentsDownloaded: number;
+}
+/** Par status */
+export interface ParStatus {
+    status: 'none' | 'checking' | 'repairing' | 'success' | 'failed';
+    repairNeeded: boolean;
+    blocksNeeded?: number;
+    blocksAvailable?: number;
+}
+/** Unpack status */
+export interface UnpackStatus {
+    status: 'none' | 'extracting' | 'success' | 'failed' | 'password_required';
+    progress: number;
+    errorMessage?: string;
+}
+/** Debrid service config */
+export interface DebridServiceConfig {
+    service: DebridService;
+    apiKey: string;
+    enabled: boolean;
+}
+/** Debrid service */
+export type DebridService = 'real_debrid' | 'all_debrid' | 'premiumize' | 'debrid_link';
+/** Debrid account */
+export interface DebridAccount {
+    service: DebridService;
+    username: string;
+    email?: string;
+    premium: boolean;
+    expirationDate?: Date;
+    pointsRemaining?: number;
+    trafficRemaining?: number;
+    trafficReset?: Date;
+}
+/** Unrestricted link */
+export interface UnrestrictedLink {
+    original: string;
+    unrestricted: string;
+    filename: string;
+    size: number;
+    host: string;
+    streamable?: boolean;
+}
+/** Cloud storage config */
+export interface CloudStorageConfig {
+    provider: CloudProvider;
+    credentials: CloudCredentials;
+    enabled: boolean;
+    syncPath?: string;
+}
+/** Cloud provider */
+export type CloudProvider = 'mega' | 'google_drive' | 'onedrive' | 'dropbox' | 'pcloud' | 'box';
+/** Cloud credentials */
+export interface CloudCredentials {
+    accessToken?: string;
+    refreshToken?: string;
+    apiKey?: string;
+    expiresAt?: Date;
+}
+/** Cloud file */
+export interface CloudFile {
+    id: string;
+    name: string;
+    path: string;
+    size: number;
+    mimeType: string;
+    modifiedDate: Date;
+    downloadUrl?: string;
+    isFolder: boolean;
+}
+/** YTDLP config */
+export interface YTDLPConfig {
+    outputPath: string;
+    outputTemplate: string;
+    preferredFormat: MediaFormat;
+    preferredQuality: string;
+    embedMetadata: boolean;
+    embedThumbnail: boolean;
+    downloadSubtitles: boolean;
+    subtitleLanguages?: string[];
+    cookies?: string;
+    proxy?: string;
+}
+/** Media format */
+export type MediaFormat = 'best' | 'bestvideo+bestaudio' | 'bestvideo' | 'bestaudio' | 'mp4' | 'webm' | 'mkv' | 'mp3' | 'flac' | 'opus';
+/** YTDLP download */
+export interface YTDLPDownload {
+    id: string;
+    url: string;
+    title: string;
+    uploader?: string;
+    duration?: number;
+    thumbnail?: string;
+    formats: YTDLPFormat[];
+    selectedFormat?: string;
+    status: DownloadStatus;
+    progress: number;
+    speed: TransferSpeed;
+    eta?: number;
+    outputPath?: string;
+}
+/** YTDLP format */
+export interface YTDLPFormat {
+    formatId: string;
+    extension: string;
+    resolution?: string;
+    fps?: number;
+    vcodec?: string;
+    acodec?: string;
+    filesize?: number;
+    quality?: number;
+}
+/** Indexer config */
+export interface IndexerConfig {
+    type: IndexerType;
+    name: string;
+    url: string;
+    apiKey: string;
+    enabled: boolean;
+    categories?: number[];
+}
+/** Indexer type */
+export type IndexerType = 'torznab' | 'newznab' | 'rss';
+/** Indexer search result */
+export interface IndexerSearchResult {
+    indexer: string;
+    title: string;
+    link: string;
+    downloadUrl: string;
+    size: number;
+    seeders?: number;
+    leechers?: number;
+    pubDate: Date;
+    category?: string;
+    imdbId?: string;
+    tvdbId?: string;
+}
+/** Media organizer config */
+export interface MediaOrganizerConfig {
+    enabled: boolean;
+    tvShowPath: string;
+    moviePath: string;
+    musicPath: string;
+    renameTemplate: RenameTemplate;
+    fetchMetadata: boolean;
+    downloadArtwork: boolean;
+    generateNfo: boolean;
+    duplicateHandling: DuplicateHandling;
+}
+/** Rename template */
+export interface RenameTemplate {
+    tvShow: string;
+    movie: string;
+    music: string;
+}
+/** Duplicate handling */
+export type DuplicateHandling = 'keep_both' | 'keep_larger' | 'keep_newer' | 'skip' | 'replace';
+/** Media item */
+export interface MediaItem {
+    id: string;
+    type: MediaItemType;
+    title: string;
+    originalPath: string;
+    organizedPath?: string;
+    metadata?: MediaItemMetadata;
+    status: MediaItemStatus;
+}
+/** Media item type */
+export type MediaItemType = 'movie' | 'tv_episode' | 'music_track' | 'music_album' | 'unknown';
+/** Media item metadata */
+export interface MediaItemMetadata {
+    title: string;
+    year?: number;
+    overview?: string;
+    genres?: string[];
+    rating?: number;
+    posterUrl?: string;
+    backdropUrl?: string;
+    seriesTitle?: string;
+    season?: number;
+    episode?: number;
+    episodeTitle?: string;
+    artist?: string;
+    album?: string;
+    track?: number;
+    albumArtUrl?: string;
+    imdbId?: string;
+    tmdbId?: number;
+    tvdbId?: number;
+    musicBrainzId?: string;
+}
+/** Media item status */
+export type MediaItemStatus = 'pending' | 'identified' | 'organized' | 'failed' | 'skipped';
+/** Subtitle search result */
+export interface SubtitleSearchResult {
+    id: string;
+    provider: SubtitleProvider;
+    language: string;
+    languageCode: string;
+    fileName: string;
+    format: SubtitleFormat;
+    uploadDate?: Date;
+    downloads?: number;
+    rating?: number;
+    hearingImpaired?: boolean;
+    matchScore?: number;
+}
+/** Subtitle provider */
+export type SubtitleProvider = 'opensubtitles' | 'subscene' | 'addic7ed' | 'podnapisi';
+/** Subtitle format */
+export type SubtitleFormat = 'srt' | 'ass' | 'ssa' | 'vtt' | 'sub';
+/** Media server notification */
+export interface MediaServerNotification {
+    server: MediaServerType;
+    url: string;
+    apiKey?: string;
+    libraryId?: string;
+    enabled: boolean;
+}
+/** Media server type */
+export type MediaServerType = 'plex' | 'emby' | 'jellyfin' | 'kodi';
+/** Arr integration config */
+export interface ArrIntegrationConfig {
+    type: ArrType;
+    url: string;
+    apiKey: string;
+    enabled: boolean;
+    priority?: number;
+    categories?: string[];
+}
+/** Arr type */
+export type ArrType = 'sonarr' | 'radarr' | 'lidarr' | 'readarr' | 'prowlarr';
+/** VPN integration config */
+export interface VPNIntegrationConfig {
+    enabled: boolean;
+    killSwitch: boolean;
+    interface?: string;
+    splitTunneling?: SplitTunnelingConfig;
+}
+/** Split tunneling config */
+export interface SplitTunnelingConfig {
+    enabled: boolean;
+    mode: 'include' | 'exclude';
+    apps: string[];
+    addresses?: string[];
+}
+/** VPN status */
+export interface VPNStatus {
+    connected: boolean;
+    server?: string;
+    country?: string;
+    ip?: string;
+    protocol?: string;
+    uptime?: number;
+}
+/** Bandwidth monitor config */
+export interface BandwidthMonitorConfig {
+    enabled: boolean;
+    trackPerApp: boolean;
+    dataCap?: DataCap;
+    alertThresholds?: AlertThreshold[];
+}
+/** Data cap */
+export interface DataCap {
+    limit: number;
+    unit: 'MB' | 'GB' | 'TB';
+    period: 'daily' | 'weekly' | 'monthly';
+    resetDay?: number;
+}
+/** Alert threshold */
+export interface AlertThreshold {
+    percentage: number;
+    notificationType: 'toast' | 'email' | 'both';
+}
+/** Bandwidth usage */
+export interface BandwidthUsage {
+    downloaded: number;
+    uploaded: number;
+    period: string;
+    history: BandwidthHistoryEntry[];
+}
+/** Bandwidth history entry */
+export interface BandwidthHistoryEntry {
+    timestamp: Date;
+    downloaded: number;
+    uploaded: number;
+}
+/** IP filter config */
+export interface IPFilterConfig {
+    enabled: boolean;
+    blocklists: Blocklist[];
+    countryBlocking?: CountryBlocking;
+    customRanges?: IPRange[];
+}
+/** Blocklist */
+export interface Blocklist {
+    id: string;
+    name: string;
+    url: string;
+    format: 'peerguardian' | 'emule' | 'text';
+    enabled: boolean;
+    autoUpdate: boolean;
+    updateInterval: number;
+    lastUpdated?: Date;
+    entryCount?: number;
+}
+/** Country blocking */
+export interface CountryBlocking {
+    enabled: boolean;
+    mode: 'block' | 'allow';
+    countries: string[];
+}
+/** IP range */
+export interface IPRange {
+    start: string;
+    end: string;
+    description?: string;
+}
+/** Web UI config */
+export interface WebUIConfig {
+    enabled: boolean;
+    port: number;
+    https: boolean;
+    certPath?: string;
+    keyPath?: string;
+    username: string;
+    passwordHash: string;
+    allowedIPs?: string[];
+    sessionTimeout: number;
+}
+/** REST API config */
+export interface RESTAPIConfig {
+    enabled: boolean;
+    port: number;
+    https: boolean;
+    apiKeys: APIKey[];
+    rateLimiting?: RateLimitConfig;
+    webhooks?: WebhookConfig[];
+}
+/** API key */
+export interface APIKey {
+    id: string;
+    name: string;
+    key: string;
+    permissions: APIPermission[];
+    createdDate: Date;
+    lastUsed?: Date;
+    expiresAt?: Date;
+}
+/** API permission */
+export type APIPermission = 'read' | 'write' | 'delete' | 'admin';
+/** Rate limit config */
+export interface RateLimitConfig {
+    enabled: boolean;
+    requestsPerMinute: number;
+    burstLimit: number;
+}
+/** Webhook config */
+export interface WebhookConfig {
+    id: string;
+    name: string;
+    url: string;
+    events: WebhookEvent[];
+    secret?: string;
+    enabled: boolean;
+}
+/** Webhook event */
+export type WebhookEvent = 'download_added' | 'download_started' | 'download_completed' | 'download_failed' | 'torrent_added' | 'torrent_completed' | 'ratio_reached';
+/** Browser extension config */
+export interface BrowserExtensionConfig {
+    enabled: boolean;
+    interceptDownloads: boolean;
+    minFileSize?: number;
+    fileTypes?: string[];
+    excludeHosts?: string[];
+    shareCookies: boolean;
+}
+/** Download statistics */
+export interface DownloadStatistics {
+    totalDownloaded: number;
+    totalUploaded: number;
+    sessionDownloaded: number;
+    sessionUploaded: number;
+    completedDownloads: number;
+    failedDownloads: number;
+    averageSpeed: TransferSpeed;
+    peakSpeed: TransferSpeed;
+    downloadsByCategory: Record<string, number>;
+    downloadsByType: Record<string, number>;
+    downloadHistory: DownloadHistoryEntry[];
+}
+/** Download history entry */
+export interface DownloadHistoryEntry {
+    date: Date;
+    downloaded: number;
+    uploaded: number;
+    count: number;
+}
+/** Torrent statistics */
+export interface TorrentStatistics {
+    totalDownloaded: number;
+    totalUploaded: number;
+    globalRatio: number;
+    totalSeedingTime: number;
+    totalPeerConnections: number;
+    trackerStats: TrackerStats[];
+    peerCountryStats: Record<string, number>;
+}
+/** Tracker stats */
+export interface TrackerStats {
+    host: string;
+    announces: number;
+    successfulAnnounces: number;
+    failedAnnounces: number;
+    averageResponseTime: number;
+}
+/** Report config */
+export interface ReportConfig {
+    id: string;
+    name: string;
+    type: ReportType;
+    format: ReportFormat;
+    dateRange: ReportDateRange;
+    includeCharts: boolean;
+    schedule?: ReportSchedule;
+    emailRecipients?: string[];
+}
+/** Report type */
+export type ReportType = 'download_summary' | 'torrent_summary' | 'bandwidth_usage' | 'category_breakdown' | 'full_report';
+/** Report format */
+export type ReportFormat = 'pdf' | 'excel' | 'csv' | 'html';
+/** Report date range */
+export interface ReportDateRange {
+    type: 'last_7_days' | 'last_30_days' | 'last_90_days' | 'custom';
+    startDate?: Date;
+    endDate?: Date;
+}
+/** Report schedule */
+export interface ReportSchedule {
+    enabled: boolean;
+    frequency: 'daily' | 'weekly' | 'monthly';
+    dayOfWeek?: number;
+    dayOfMonth?: number;
+    time: string;
+}
+//# sourceMappingURL=download-torrent.d.ts.map