Dark-Alex-17
35ed3f359d
DownloadStatus was declared four times, byte for byte identically, in radarr_models, sonarr_models, lidarr_models, and readarr_models: the same variants, the same derive list, and the same serde, strum, and display_style attributes. Every servarr's queue endpoint reports the same status vocabulary, so there is nothing servarr specific about the type. Move it into servarr_models, preserving that file's alphabetical ordering (between DiskSpace and IndexerSettings), and drop the four copies. The DownloadRecord types keep their per-servarr shapes and now reference the shared enum. The two enum tests, test_download_status_display and test_download_status_to_display_str, were likewise duplicated in the four per-servarr model test files. Keep one copy of each in servarr_models_tests alongside the other shared enum display tests and delete the rest. The per-servarr DownloadRecord fallback deserialization tests stay where they are since they exercise each servarr's own record type. Behavior is unchanged. Every remaining edit is an import path update.
604 lines
17 KiB
Rust
604 lines
17 KiB
Rust
use std::fmt::{Display, Formatter};
|
|
|
|
use crate::{
|
|
models::servarr_models::{IndexerSettings, IndexerTestResult},
|
|
serde_enum_from,
|
|
};
|
|
use chrono::{DateTime, Utc};
|
|
use clap::ValueEnum;
|
|
use derivative::Derivative;
|
|
use enum_display_style_derive::EnumDisplayStyle;
|
|
use serde::{Deserialize, Serialize};
|
|
use serde_json::{Number, Value};
|
|
use strum::EnumIter;
|
|
use strum_macros::Display;
|
|
|
|
use super::{
|
|
HorizontallyScrollableText, Serdeable,
|
|
servarr_models::{
|
|
DiskSpace, DownloadStatus, HostConfig, Indexer, Language, LogResponse, QualityProfile,
|
|
QualityWrapper, QueueEvent, RootFolder, SecurityConfig, SystemStatus, Tag, Update,
|
|
},
|
|
};
|
|
|
|
#[cfg(test)]
|
|
#[path = "sonarr_models_tests.rs"]
|
|
mod sonarr_models_tests;
|
|
|
|
#[derive(Default, Clone, Serialize, Debug, PartialEq, Eq)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct AddSeriesBody {
|
|
pub tvdb_id: i64,
|
|
pub title: String,
|
|
pub monitored: bool,
|
|
pub root_folder_path: String,
|
|
pub quality_profile_id: i64,
|
|
pub language_profile_id: i64,
|
|
pub series_type: SeriesType,
|
|
pub season_folder: bool,
|
|
pub tags: Vec<i64>,
|
|
#[serde(skip_serializing, skip_deserializing)]
|
|
pub tag_input_string: Option<String>,
|
|
pub add_options: AddSeriesOptions,
|
|
}
|
|
|
|
#[derive(Derivative, Serialize, Deserialize, Debug, Default, Clone, PartialEq, Eq)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct AddSeriesSearchResult {
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub tvdb_id: i64,
|
|
pub title: HorizontallyScrollableText,
|
|
pub status: Option<String>,
|
|
pub ended: bool,
|
|
pub overview: Option<String>,
|
|
pub genres: Vec<String>,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub year: i64,
|
|
pub network: Option<String>,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub runtime: i64,
|
|
pub ratings: Option<Rating>,
|
|
pub statistics: Option<AddSeriesSearchResultStatistics>,
|
|
}
|
|
|
|
#[derive(Derivative, Serialize, Deserialize, Debug, Default, Clone, PartialEq, Eq)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct AddSeriesSearchResultStatistics {
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub season_count: i64,
|
|
}
|
|
|
|
#[derive(Default, Clone, Serialize, Debug, PartialEq, Eq)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct AddSeriesOptions {
|
|
pub monitor: SeriesMonitor,
|
|
pub search_for_cutoff_unmet_episodes: bool,
|
|
pub search_for_missing_episodes: bool,
|
|
}
|
|
|
|
#[derive(Default, Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct BlocklistItem {
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub id: i64,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub series_id: i64,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub series_title: Option<String>,
|
|
pub episode_ids: Vec<Number>,
|
|
pub source_title: String,
|
|
pub languages: Vec<Option<Language>>,
|
|
pub quality: QualityWrapper,
|
|
pub date: DateTime<Utc>,
|
|
pub protocol: String,
|
|
pub indexer: String,
|
|
pub message: String,
|
|
}
|
|
|
|
#[derive(Default, Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
|
|
pub struct BlocklistResponse {
|
|
pub records: Vec<BlocklistItem>,
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Debug, Default, Clone, Eq, PartialEq)]
|
|
#[serde(rename_all = "lowercase")]
|
|
pub struct DeleteSeriesParams {
|
|
pub id: i64,
|
|
pub delete_series_files: bool,
|
|
pub add_list_exclusion: bool,
|
|
}
|
|
|
|
#[derive(Derivative, Serialize, Deserialize, Debug, Default, Clone, PartialEq)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct DownloadRecord {
|
|
pub title: String,
|
|
#[serde(deserialize_with = "super::from_json_or_default")]
|
|
pub status: DownloadStatus,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub id: i64,
|
|
pub episode_id: Option<Number>,
|
|
#[serde(deserialize_with = "super::from_f64")]
|
|
pub size: f64,
|
|
#[serde(deserialize_with = "super::from_f64")]
|
|
pub sizeleft: f64,
|
|
pub output_path: Option<HorizontallyScrollableText>,
|
|
#[serde(default)]
|
|
pub indexer: String,
|
|
pub download_client: Option<String>,
|
|
}
|
|
|
|
impl Eq for DownloadRecord {}
|
|
|
|
#[derive(Default, Clone, Serialize, Deserialize, Debug, PartialEq, Eq)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct DownloadsResponse {
|
|
pub records: Vec<DownloadRecord>,
|
|
}
|
|
|
|
#[derive(Default, Clone, Serialize, Debug, PartialEq, Eq)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct EditSeriesParams {
|
|
pub series_id: i64,
|
|
pub monitored: Option<bool>,
|
|
pub use_season_folders: Option<bool>,
|
|
pub quality_profile_id: Option<i64>,
|
|
pub language_profile_id: Option<i64>,
|
|
pub series_type: Option<SeriesType>,
|
|
pub root_folder_path: Option<String>,
|
|
pub tags: Option<Vec<i64>>,
|
|
#[serde(skip_serializing, skip_deserializing)]
|
|
pub tag_input_string: Option<String>,
|
|
pub clear_tags: bool,
|
|
}
|
|
|
|
#[derive(Default, Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct Episode {
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub id: i64,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub series_id: i64,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub tvdb_id: i64,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub episode_file_id: i64,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub season_number: i64,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub episode_number: i64,
|
|
pub title: String,
|
|
pub air_date_utc: Option<DateTime<Utc>>,
|
|
pub overview: Option<String>,
|
|
pub has_file: bool,
|
|
pub monitored: bool,
|
|
pub episode_file: Option<EpisodeFile>,
|
|
}
|
|
|
|
impl Display for Episode {
|
|
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
|
|
write!(f, "{}", self.title)
|
|
}
|
|
}
|
|
|
|
#[derive(Default, Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct EpisodeFile {
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub id: i64,
|
|
pub relative_path: String,
|
|
pub path: String,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub size: i64,
|
|
pub languages: Vec<Option<Language>>,
|
|
pub quality: QualityWrapper,
|
|
pub date_added: DateTime<Utc>,
|
|
pub media_info: Option<MediaInfo>,
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Derivative, Debug, Clone, PartialEq, Eq)]
|
|
#[derivative(Default)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct MediaInfo {
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub audio_bitrate: i64,
|
|
#[derivative(Default(value = "Number::from(0)"))]
|
|
pub audio_channels: Number,
|
|
pub audio_codec: Option<String>,
|
|
pub audio_languages: Option<String>,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub audio_stream_count: i64,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub video_bit_depth: i64,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub video_bitrate: i64,
|
|
pub video_codec: Option<String>,
|
|
#[derivative(Default(value = "Number::from(0)"))]
|
|
pub video_fps: Number,
|
|
pub resolution: String,
|
|
pub run_time: String,
|
|
pub scan_type: String,
|
|
pub subtitles: Option<String>,
|
|
}
|
|
|
|
#[derive(Default, Serialize, Debug)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct MonitorEpisodeBody {
|
|
pub episode_ids: Vec<i64>,
|
|
pub monitored: bool,
|
|
}
|
|
|
|
#[derive(Derivative, Serialize, Deserialize, Debug, Clone, PartialEq)]
|
|
#[derivative(Default)]
|
|
pub struct Rating {
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub votes: i64,
|
|
#[serde(deserialize_with = "super::from_f64")]
|
|
pub value: f64,
|
|
}
|
|
|
|
impl Eq for Rating {}
|
|
|
|
#[derive(Derivative, Serialize, Deserialize, Debug, Default, Clone, PartialEq, Eq)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct Season {
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub title: Option<String>,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub season_number: i64,
|
|
pub monitored: bool,
|
|
pub statistics: Option<SeasonStatistics>,
|
|
}
|
|
|
|
#[derive(Derivative, Serialize, Deserialize, Debug, Default, Clone, PartialEq)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct SeasonStatistics {
|
|
pub next_airing: Option<DateTime<Utc>>,
|
|
pub previous_airing: Option<DateTime<Utc>>,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub episode_file_count: i64,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub episode_count: i64,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub total_episode_count: i64,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub size_on_disk: i64,
|
|
#[serde(deserialize_with = "super::from_f64")]
|
|
pub percent_of_episodes: f64,
|
|
}
|
|
|
|
impl Eq for SeasonStatistics {}
|
|
|
|
#[derive(Derivative, Serialize, Deserialize, Debug, Default, Clone, PartialEq, Eq)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct Series {
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub id: i64,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub tvdb_id: i64,
|
|
pub title: HorizontallyScrollableText,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub quality_profile_id: i64,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub language_profile_id: i64,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub runtime: i64,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub year: i64,
|
|
pub monitored: bool,
|
|
#[serde(deserialize_with = "super::from_json_or_default")]
|
|
pub series_type: SeriesType,
|
|
pub path: String,
|
|
pub genres: Vec<String>,
|
|
pub tags: Vec<Number>,
|
|
pub ratings: Rating,
|
|
pub ended: bool,
|
|
#[serde(deserialize_with = "super::from_json_or_default")]
|
|
pub status: SeriesStatus,
|
|
pub overview: Option<String>,
|
|
pub network: Option<String>,
|
|
pub season_folder: bool,
|
|
pub certification: Option<String>,
|
|
pub statistics: Option<SeriesStatistics>,
|
|
pub seasons: Option<Vec<Season>>,
|
|
}
|
|
|
|
#[derive(
|
|
Serialize,
|
|
Deserialize,
|
|
Default,
|
|
PartialEq,
|
|
Eq,
|
|
Clone,
|
|
Copy,
|
|
Debug,
|
|
EnumIter,
|
|
ValueEnum,
|
|
Display,
|
|
EnumDisplayStyle,
|
|
)]
|
|
#[serde(rename_all = "camelCase")]
|
|
#[strum(serialize_all = "camelCase")]
|
|
pub enum SeriesMonitor {
|
|
#[default]
|
|
#[display_style(name = "All Episodes")]
|
|
All,
|
|
Unknown,
|
|
#[display_style(name = "Future Episodes")]
|
|
Future,
|
|
#[display_style(name = "Missing Episodes")]
|
|
Missing,
|
|
#[display_style(name = "Existing Episodes")]
|
|
Existing,
|
|
#[display_style(name = "Only First Season")]
|
|
FirstSeason,
|
|
#[display_style(name = "Only Last Season")]
|
|
LastSeason,
|
|
#[display_style(name = "Only Latest Season")]
|
|
LatestSeason,
|
|
#[display_style(name = "Pilot Episode")]
|
|
Pilot,
|
|
#[display_style(name = "Recent Episodes")]
|
|
Recent,
|
|
#[display_style(name = "Only Specials")]
|
|
MonitorSpecials,
|
|
#[display_style(name = "Not Specials")]
|
|
UnmonitorSpecials,
|
|
None,
|
|
Skip,
|
|
}
|
|
|
|
#[derive(
|
|
Serialize,
|
|
Deserialize,
|
|
Default,
|
|
PartialEq,
|
|
Eq,
|
|
Clone,
|
|
Copy,
|
|
Debug,
|
|
EnumIter,
|
|
ValueEnum,
|
|
Display,
|
|
EnumDisplayStyle,
|
|
)]
|
|
#[serde(rename_all = "camelCase")]
|
|
#[strum(serialize_all = "camelCase")]
|
|
pub enum SeriesType {
|
|
#[default]
|
|
Standard,
|
|
Daily,
|
|
Anime,
|
|
}
|
|
|
|
#[derive(Derivative, Serialize, Deserialize, Debug, Default, Clone, PartialEq)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct SeriesStatistics {
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub season_count: i64,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub episode_file_count: i64,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub episode_count: i64,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub total_episode_count: i64,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub size_on_disk: i64,
|
|
#[serde(deserialize_with = "super::from_f64")]
|
|
pub percent_of_episodes: f64,
|
|
}
|
|
|
|
impl Eq for SeriesStatistics {}
|
|
|
|
#[derive(
|
|
Serialize,
|
|
Deserialize,
|
|
Default,
|
|
PartialEq,
|
|
Eq,
|
|
Clone,
|
|
Copy,
|
|
Debug,
|
|
EnumIter,
|
|
Display,
|
|
EnumDisplayStyle,
|
|
)]
|
|
#[serde(rename_all = "camelCase")]
|
|
#[strum(serialize_all = "camelCase")]
|
|
pub enum SeriesStatus {
|
|
#[default]
|
|
Continuing,
|
|
Ended,
|
|
Upcoming,
|
|
Deleted,
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Default, Debug, Clone, PartialEq, Eq)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct SonarrHistoryWrapper {
|
|
pub records: Vec<SonarrHistoryItem>,
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Default, Debug, Clone, PartialEq, Eq)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct SonarrHistoryData {
|
|
pub dropped_path: Option<String>,
|
|
pub imported_path: Option<String>,
|
|
pub indexer: Option<String>,
|
|
pub release_group: Option<String>,
|
|
pub series_match_type: Option<String>,
|
|
pub nzb_info_url: Option<String>,
|
|
pub download_client_name: Option<String>,
|
|
pub age: Option<String>,
|
|
pub published_date: Option<DateTime<Utc>>,
|
|
pub message: Option<String>,
|
|
pub reason: Option<String>,
|
|
pub source_path: Option<String>,
|
|
pub source_relative_path: Option<String>,
|
|
pub path: Option<String>,
|
|
pub relative_path: Option<String>,
|
|
}
|
|
|
|
#[derive(
|
|
Serialize, Deserialize, Default, Debug, Clone, PartialEq, Eq, Display, EnumDisplayStyle,
|
|
)]
|
|
#[serde(rename_all = "camelCase")]
|
|
#[strum(serialize_all = "camelCase")]
|
|
pub enum SonarrHistoryEventType {
|
|
#[default]
|
|
Unknown,
|
|
Grabbed,
|
|
#[display_style(name = "Series Folder Imported")]
|
|
SeriesFolderImported,
|
|
#[display_style(name = "Download Folder Imported")]
|
|
DownloadFolderImported,
|
|
#[display_style(name = "Download Failed")]
|
|
DownloadFailed,
|
|
#[display_style(name = "Episode File Deleted")]
|
|
EpisodeFileDeleted,
|
|
#[display_style(name = "Episode File Renamed")]
|
|
EpisodeFileRenamed,
|
|
#[display_style(name = "Download Ignored")]
|
|
DownloadIgnored,
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Default, Debug, Clone, PartialEq, Eq)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct SonarrHistoryItem {
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub id: i64,
|
|
pub source_title: HorizontallyScrollableText,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub episode_id: i64,
|
|
pub quality: QualityWrapper,
|
|
pub languages: Vec<Option<Language>>,
|
|
pub date: DateTime<Utc>,
|
|
#[serde(deserialize_with = "super::from_json_or_default")]
|
|
pub event_type: SonarrHistoryEventType,
|
|
pub data: SonarrHistoryData,
|
|
}
|
|
|
|
#[derive(Default, Serialize, Debug)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct SonarrCommandBody {
|
|
pub name: String,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub series_id: Option<i64>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub season_number: Option<i64>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub episode_ids: Option<Vec<i64>>,
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq, Eq)]
|
|
#[serde(rename_all = "camelCase")]
|
|
#[serde(default)]
|
|
pub struct SonarrRelease {
|
|
pub guid: String,
|
|
pub protocol: String,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub age: i64,
|
|
pub title: HorizontallyScrollableText,
|
|
pub indexer: String,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub indexer_id: i64,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub size: i64,
|
|
pub rejected: bool,
|
|
pub rejections: Option<Vec<String>>,
|
|
pub seeders: Option<Number>,
|
|
pub leechers: Option<Number>,
|
|
pub languages: Option<Vec<Option<Language>>>,
|
|
pub quality: QualityWrapper,
|
|
pub full_season: bool,
|
|
}
|
|
|
|
#[derive(Default, Serialize, Debug, PartialEq, Eq, Clone)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct SonarrReleaseDownloadBody {
|
|
pub guid: String,
|
|
pub indexer_id: i64,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub series_id: Option<i64>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub episode_id: Option<i64>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub season_number: Option<i64>,
|
|
}
|
|
|
|
#[derive(Default, Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct SonarrTask {
|
|
pub name: String,
|
|
#[serde(deserialize_with = "super::from_json_or_default")]
|
|
pub task_name: SonarrTaskName,
|
|
#[serde(deserialize_with = "super::from_i64")]
|
|
pub interval: i64,
|
|
pub last_execution: DateTime<Utc>,
|
|
pub next_execution: DateTime<Utc>,
|
|
}
|
|
|
|
#[derive(Default, Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Copy, ValueEnum)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum SonarrTaskName {
|
|
#[default]
|
|
ApplicationUpdateCheck,
|
|
Backup,
|
|
CheckHealth,
|
|
CleanUpRecycleBin,
|
|
Housekeeping,
|
|
ImportListSync,
|
|
MessagingCleanup,
|
|
RefreshMonitoredDownloads,
|
|
RefreshSeries,
|
|
RssSync,
|
|
UpdateSceneMapping,
|
|
}
|
|
|
|
impl Display for SonarrTaskName {
|
|
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
|
|
let task_name = serde_json::to_string(&self)
|
|
.expect("Unable to serialize task name")
|
|
.replace('"', "");
|
|
write!(f, "{task_name}")
|
|
}
|
|
}
|
|
|
|
impl From<SonarrSerdeable> for Serdeable {
|
|
fn from(value: SonarrSerdeable) -> Serdeable {
|
|
Serdeable::Sonarr(value)
|
|
}
|
|
}
|
|
|
|
serde_enum_from!(
|
|
SonarrSerdeable {
|
|
AddSeriesSearchResults(Vec<AddSeriesSearchResult>),
|
|
BlocklistResponse(BlocklistResponse),
|
|
DownloadsResponse(DownloadsResponse),
|
|
DiskSpaces(Vec<DiskSpace>),
|
|
Episode(Episode),
|
|
Episodes(Vec<Episode>),
|
|
EpisodeFiles(Vec<EpisodeFile>),
|
|
HostConfig(HostConfig),
|
|
IndexerSettings(IndexerSettings),
|
|
Indexers(Vec<Indexer>),
|
|
IndexerTestResults(Vec<IndexerTestResult>),
|
|
LanguageProfiles(Vec<Language>),
|
|
LogResponse(LogResponse),
|
|
QualityProfiles(Vec<QualityProfile>),
|
|
QueueEvents(Vec<QueueEvent>),
|
|
Releases(Vec<SonarrRelease>),
|
|
RootFolders(Vec<RootFolder>),
|
|
SecurityConfig(SecurityConfig),
|
|
SeriesVec(Vec<Series>),
|
|
Series(Series),
|
|
SonarrHistoryItems(Vec<SonarrHistoryItem>),
|
|
SonarrHistoryWrapper(SonarrHistoryWrapper),
|
|
SystemStatus(SystemStatus),
|
|
Tag(Tag),
|
|
Tags(Vec<Tag>),
|
|
Tasks(Vec<SonarrTask>),
|
|
Updates(Vec<Update>),
|
|
Value(Value),
|
|
}
|
|
);
|