7866 lines
286 KiB
Rust
7866 lines
286 KiB
Rust
/// An entity representing a user's access schedule.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct AccessSchedule {
|
|
/// Gets the id of this instance.
|
|
#[serde(rename = "Id")]
|
|
pub id: i32,
|
|
/// Gets the id of the associated user.
|
|
#[serde(rename = "UserId")]
|
|
pub user_id: uuid::Uuid,
|
|
/// Gets or sets the day of week.
|
|
#[serde(rename = "DayOfWeek")]
|
|
pub day_of_week: DynamicDayOfWeek,
|
|
/// Gets or sets the start hour.
|
|
#[serde(rename = "StartHour")]
|
|
pub start_hour: f64,
|
|
/// Gets or sets the end hour.
|
|
#[serde(rename = "EndHour")]
|
|
pub end_hour: f64,
|
|
}
|
|
/// An activity log entry.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ActivityLogEntry {
|
|
/// Gets or sets the identifier.
|
|
#[serde(rename = "Id")]
|
|
pub id: i64,
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: String,
|
|
/// Gets or sets the overview.
|
|
#[serde(rename = "Overview")]
|
|
pub overview: Option<String>,
|
|
/// Gets or sets the short overview.
|
|
#[serde(rename = "ShortOverview")]
|
|
pub short_overview: Option<String>,
|
|
/// Gets or sets the type.
|
|
#[serde(rename = "Type")]
|
|
pub _type: String,
|
|
/// Gets or sets the item identifier.
|
|
#[serde(rename = "ItemId")]
|
|
pub item_id: Option<String>,
|
|
/// Gets or sets the date.
|
|
#[serde(rename = "Date")]
|
|
pub date: jiff::Zoned,
|
|
/// Gets or sets the user identifier.
|
|
#[serde(rename = "UserId")]
|
|
pub user_id: uuid::Uuid,
|
|
/// Gets or sets the user primary image tag.
|
|
#[serde(rename = "UserPrimaryImageTag")]
|
|
pub user_primary_image_tag: Option<String>,
|
|
/// Gets or sets the log severity.
|
|
#[serde(rename = "Severity")]
|
|
pub severity: LogLevel,
|
|
}
|
|
/// Activity log created message.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ActivityLogEntryMessage {
|
|
/// Gets or sets the data.
|
|
#[serde(rename = "Data")]
|
|
pub data: Option<Vec<ActivityLogEntry>>,
|
|
/// Gets or sets the message id.
|
|
#[serde(rename = "MessageId")]
|
|
pub message_id: uuid::Uuid,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Query result container.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ActivityLogEntryQueryResult {
|
|
/// Gets or sets the items.
|
|
#[serde(rename = "Items")]
|
|
pub items: Vec<ActivityLogEntry>,
|
|
/// Gets or sets the total number of records available.
|
|
#[serde(rename = "TotalRecordCount")]
|
|
pub total_record_count: i32,
|
|
/// Gets or sets the index of the first record in Items.
|
|
#[serde(rename = "StartIndex")]
|
|
pub start_index: i32,
|
|
}
|
|
/** Activity log entry start message.
|
|
Data is the timing data encoded as "$initialDelay,$interval" in ms.*/
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ActivityLogEntryStartMessage {
|
|
/// Gets or sets the data.
|
|
#[serde(rename = "Data")]
|
|
pub data: Option<String>,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Activity log entry stop message.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ActivityLogEntryStopMessage {
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Add virtual folder dto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct AddVirtualFolderDto {
|
|
/// Gets or sets library options.
|
|
#[serde(rename = "LibraryOptions")]
|
|
pub library_options: Option<LibraryOptions>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct AlbumInfo {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the original title.
|
|
#[serde(rename = "OriginalTitle")]
|
|
pub original_title: Option<String>,
|
|
/// Gets or sets the path.
|
|
#[serde(rename = "Path")]
|
|
pub path: Option<String>,
|
|
/// Gets or sets the metadata language.
|
|
#[serde(rename = "MetadataLanguage")]
|
|
pub metadata_language: Option<String>,
|
|
/// Gets or sets the metadata country code.
|
|
#[serde(rename = "MetadataCountryCode")]
|
|
pub metadata_country_code: Option<String>,
|
|
/// Gets or sets the provider ids.
|
|
#[serde(rename = "ProviderIds")]
|
|
pub provider_ids: Option<std::collections::HashMap<String, Option<String>>>,
|
|
/// Gets or sets the year.
|
|
#[serde(rename = "Year")]
|
|
pub year: Option<i32>,
|
|
#[serde(rename = "IndexNumber")]
|
|
pub index_number: Option<i32>,
|
|
#[serde(rename = "ParentIndexNumber")]
|
|
pub parent_index_number: Option<i32>,
|
|
#[serde(rename = "PremiereDate")]
|
|
pub premiere_date: Option<jiff::Zoned>,
|
|
#[serde(rename = "IsAutomated")]
|
|
pub is_automated: bool,
|
|
/// Gets or sets the album artist.
|
|
#[serde(rename = "AlbumArtists")]
|
|
pub album_artists: Vec<String>,
|
|
/// Gets or sets the artist provider ids.
|
|
#[serde(rename = "ArtistProviderIds")]
|
|
pub artist_provider_ids: std::collections::HashMap<String, Option<String>>,
|
|
#[serde(rename = "SongInfos")]
|
|
pub song_infos: Vec<SongInfo>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct AlbumInfoRemoteSearchQuery {
|
|
#[serde(rename = "SearchInfo")]
|
|
pub search_info: Option<AlbumInfo>,
|
|
#[serde(rename = "ItemId")]
|
|
pub item_id: uuid::Uuid,
|
|
/// Gets or sets the provider name to search within if set.
|
|
#[serde(rename = "SearchProviderName")]
|
|
pub search_provider_name: Option<String>,
|
|
/// Gets or sets a value indicating whether disabled providers should be included.
|
|
#[serde(rename = "IncludeDisabledProviders")]
|
|
pub include_disabled_providers: bool,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct AllThemeMediaResult {
|
|
/// Class ThemeMediaResult.
|
|
#[serde(rename = "ThemeVideosResult")]
|
|
pub theme_videos_result: Option<ThemeMediaResult>,
|
|
/// Class ThemeMediaResult.
|
|
#[serde(rename = "ThemeSongsResult")]
|
|
pub theme_songs_result: Option<ThemeMediaResult>,
|
|
/// Class ThemeMediaResult.
|
|
#[serde(rename = "SoundtrackSongsResult")]
|
|
pub soundtrack_songs_result: Option<ThemeMediaResult>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ArtistInfo {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the original title.
|
|
#[serde(rename = "OriginalTitle")]
|
|
pub original_title: Option<String>,
|
|
/// Gets or sets the path.
|
|
#[serde(rename = "Path")]
|
|
pub path: Option<String>,
|
|
/// Gets or sets the metadata language.
|
|
#[serde(rename = "MetadataLanguage")]
|
|
pub metadata_language: Option<String>,
|
|
/// Gets or sets the metadata country code.
|
|
#[serde(rename = "MetadataCountryCode")]
|
|
pub metadata_country_code: Option<String>,
|
|
/// Gets or sets the provider ids.
|
|
#[serde(rename = "ProviderIds")]
|
|
pub provider_ids: Option<std::collections::HashMap<String, Option<String>>>,
|
|
/// Gets or sets the year.
|
|
#[serde(rename = "Year")]
|
|
pub year: Option<i32>,
|
|
#[serde(rename = "IndexNumber")]
|
|
pub index_number: Option<i32>,
|
|
#[serde(rename = "ParentIndexNumber")]
|
|
pub parent_index_number: Option<i32>,
|
|
#[serde(rename = "PremiereDate")]
|
|
pub premiere_date: Option<jiff::Zoned>,
|
|
#[serde(rename = "IsAutomated")]
|
|
pub is_automated: bool,
|
|
#[serde(rename = "SongInfos")]
|
|
pub song_infos: Vec<SongInfo>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ArtistInfoRemoteSearchQuery {
|
|
#[serde(rename = "SearchInfo")]
|
|
pub search_info: Option<ArtistInfo>,
|
|
#[serde(rename = "ItemId")]
|
|
pub item_id: uuid::Uuid,
|
|
/// Gets or sets the provider name to search within if set.
|
|
#[serde(rename = "SearchProviderName")]
|
|
pub search_provider_name: Option<String>,
|
|
/// Gets or sets a value indicating whether disabled providers should be included.
|
|
#[serde(rename = "IncludeDisabledProviders")]
|
|
pub include_disabled_providers: bool,
|
|
}
|
|
/// The authenticate user by name request body.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct AuthenticateUserByName {
|
|
/// Gets or sets the username.
|
|
#[serde(rename = "Username")]
|
|
pub username: Option<String>,
|
|
/// Gets or sets the plain text password.
|
|
#[serde(rename = "Pw")]
|
|
pub pw: Option<String>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct AuthenticationInfo {
|
|
/// Gets or sets the identifier.
|
|
#[serde(rename = "Id")]
|
|
pub id: i64,
|
|
/// Gets or sets the access token.
|
|
#[serde(rename = "AccessToken")]
|
|
pub access_token: Option<String>,
|
|
/// Gets or sets the device identifier.
|
|
#[serde(rename = "DeviceId")]
|
|
pub device_id: Option<String>,
|
|
/// Gets or sets the name of the application.
|
|
#[serde(rename = "AppName")]
|
|
pub app_name: Option<String>,
|
|
/// Gets or sets the application version.
|
|
#[serde(rename = "AppVersion")]
|
|
pub app_version: Option<String>,
|
|
/// Gets or sets the name of the device.
|
|
#[serde(rename = "DeviceName")]
|
|
pub device_name: Option<String>,
|
|
/// Gets or sets the user identifier.
|
|
#[serde(rename = "UserId")]
|
|
pub user_id: uuid::Uuid,
|
|
/// Gets or sets a value indicating whether this instance is active.
|
|
#[serde(rename = "IsActive")]
|
|
pub is_active: bool,
|
|
/// Gets or sets the date created.
|
|
#[serde(rename = "DateCreated")]
|
|
pub date_created: jiff::Zoned,
|
|
/// Gets or sets the date revoked.
|
|
#[serde(rename = "DateRevoked")]
|
|
pub date_revoked: Option<jiff::Zoned>,
|
|
#[serde(rename = "DateLastActivity")]
|
|
pub date_last_activity: jiff::Zoned,
|
|
#[serde(rename = "UserName")]
|
|
pub user_name: Option<String>,
|
|
}
|
|
/// Query result container.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct AuthenticationInfoQueryResult {
|
|
/// Gets or sets the items.
|
|
#[serde(rename = "Items")]
|
|
pub items: Vec<AuthenticationInfo>,
|
|
/// Gets or sets the total number of records available.
|
|
#[serde(rename = "TotalRecordCount")]
|
|
pub total_record_count: i32,
|
|
/// Gets or sets the index of the first record in Items.
|
|
#[serde(rename = "StartIndex")]
|
|
pub start_index: i32,
|
|
}
|
|
/// A class representing an authentication result.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct AuthenticationResult {
|
|
/// Class UserDto.
|
|
#[serde(rename = "User")]
|
|
pub user: Option<UserDto>,
|
|
/// Session info DTO.
|
|
#[serde(rename = "SessionInfo")]
|
|
pub session_info: Option<SessionInfoDto>,
|
|
/// Gets or sets the access token.
|
|
#[serde(rename = "AccessToken")]
|
|
pub access_token: Option<String>,
|
|
/// Gets or sets the server id.
|
|
#[serde(rename = "ServerId")]
|
|
pub server_id: Option<String>,
|
|
}
|
|
/** This is strictly used as a data transfer object from the api layer.
|
|
This holds information about a BaseItem in a format that is convenient for the client.*/
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct BaseItemDto {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
#[serde(rename = "OriginalTitle")]
|
|
pub original_title: Option<String>,
|
|
/// Gets or sets the server identifier.
|
|
#[serde(rename = "ServerId")]
|
|
pub server_id: Option<String>,
|
|
/// Gets or sets the id.
|
|
#[serde(rename = "Id")]
|
|
pub id: uuid::Uuid,
|
|
/// Gets or sets the etag.
|
|
#[serde(rename = "Etag")]
|
|
pub etag: Option<String>,
|
|
/// Gets or sets the type of the source.
|
|
#[serde(rename = "SourceType")]
|
|
pub source_type: Option<String>,
|
|
/// Gets or sets the playlist item identifier.
|
|
#[serde(rename = "PlaylistItemId")]
|
|
pub playlist_item_id: Option<String>,
|
|
/// Gets or sets the date created.
|
|
#[serde(rename = "DateCreated")]
|
|
pub date_created: Option<jiff::Zoned>,
|
|
#[serde(rename = "DateLastMediaAdded")]
|
|
pub date_last_media_added: Option<jiff::Zoned>,
|
|
#[serde(rename = "ExtraType")]
|
|
pub extra_type: Option<ExtraType>,
|
|
#[serde(rename = "AirsBeforeSeasonNumber")]
|
|
pub airs_before_season_number: Option<i32>,
|
|
#[serde(rename = "AirsAfterSeasonNumber")]
|
|
pub airs_after_season_number: Option<i32>,
|
|
#[serde(rename = "AirsBeforeEpisodeNumber")]
|
|
pub airs_before_episode_number: Option<i32>,
|
|
#[serde(rename = "CanDelete")]
|
|
pub can_delete: Option<bool>,
|
|
#[serde(rename = "CanDownload")]
|
|
pub can_download: Option<bool>,
|
|
#[serde(rename = "HasLyrics")]
|
|
pub has_lyrics: Option<bool>,
|
|
#[serde(rename = "HasSubtitles")]
|
|
pub has_subtitles: Option<bool>,
|
|
#[serde(rename = "PreferredMetadataLanguage")]
|
|
pub preferred_metadata_language: Option<String>,
|
|
#[serde(rename = "PreferredMetadataCountryCode")]
|
|
pub preferred_metadata_country_code: Option<String>,
|
|
#[serde(rename = "Container")]
|
|
pub container: Option<String>,
|
|
/// Gets or sets the name of the sort.
|
|
#[serde(rename = "SortName")]
|
|
pub sort_name: Option<String>,
|
|
#[serde(rename = "ForcedSortName")]
|
|
pub forced_sort_name: Option<String>,
|
|
/// Gets or sets the video3 D format.
|
|
#[serde(rename = "Video3DFormat")]
|
|
pub video3_d_format: Option<Video3DFormat>,
|
|
/// Gets or sets the premiere date.
|
|
#[serde(rename = "PremiereDate")]
|
|
pub premiere_date: Option<jiff::Zoned>,
|
|
/// Gets or sets the external urls.
|
|
#[serde(rename = "ExternalUrls")]
|
|
pub external_urls: Option<Vec<ExternalUrl>>,
|
|
/// Gets or sets the media versions.
|
|
#[serde(rename = "MediaSources")]
|
|
pub media_sources: Option<Vec<MediaSourceInfo>>,
|
|
/// Gets or sets the critic rating.
|
|
#[serde(rename = "CriticRating")]
|
|
pub critic_rating: Option<f32>,
|
|
#[serde(rename = "ProductionLocations")]
|
|
pub production_locations: Option<Vec<String>>,
|
|
/// Gets or sets the path.
|
|
#[serde(rename = "Path")]
|
|
pub path: Option<String>,
|
|
#[serde(rename = "EnableMediaSourceDisplay")]
|
|
pub enable_media_source_display: Option<bool>,
|
|
/// Gets or sets the official rating.
|
|
#[serde(rename = "OfficialRating")]
|
|
pub official_rating: Option<String>,
|
|
/// Gets or sets the custom rating.
|
|
#[serde(rename = "CustomRating")]
|
|
pub custom_rating: Option<String>,
|
|
/// Gets or sets the channel identifier.
|
|
#[serde(rename = "ChannelId")]
|
|
pub channel_id: Option<uuid::Uuid>,
|
|
#[serde(rename = "ChannelName")]
|
|
pub channel_name: Option<String>,
|
|
/// Gets or sets the overview.
|
|
#[serde(rename = "Overview")]
|
|
pub overview: Option<String>,
|
|
/// Gets or sets the taglines.
|
|
#[serde(rename = "Taglines")]
|
|
pub taglines: Option<Vec<String>>,
|
|
/// Gets or sets the genres.
|
|
#[serde(rename = "Genres")]
|
|
pub genres: Option<Vec<String>>,
|
|
/// Gets or sets the community rating.
|
|
#[serde(rename = "CommunityRating")]
|
|
pub community_rating: Option<f32>,
|
|
/// Gets or sets the cumulative run time ticks.
|
|
#[serde(rename = "CumulativeRunTimeTicks")]
|
|
pub cumulative_run_time_ticks: Option<i64>,
|
|
/// Gets or sets the run time ticks.
|
|
#[serde(rename = "RunTimeTicks")]
|
|
pub run_time_ticks: Option<i64>,
|
|
/// Gets or sets the play access.
|
|
#[serde(rename = "PlayAccess")]
|
|
pub play_access: Option<PlayAccess>,
|
|
/// Gets or sets the aspect ratio.
|
|
#[serde(rename = "AspectRatio")]
|
|
pub aspect_ratio: Option<String>,
|
|
/// Gets or sets the production year.
|
|
#[serde(rename = "ProductionYear")]
|
|
pub production_year: Option<i32>,
|
|
/// Gets or sets a value indicating whether this instance is place holder.
|
|
#[serde(rename = "IsPlaceHolder")]
|
|
pub is_place_holder: Option<bool>,
|
|
/// Gets or sets the number.
|
|
#[serde(rename = "Number")]
|
|
pub number: Option<String>,
|
|
#[serde(rename = "ChannelNumber")]
|
|
pub channel_number: Option<String>,
|
|
/// Gets or sets the index number.
|
|
#[serde(rename = "IndexNumber")]
|
|
pub index_number: Option<i32>,
|
|
/// Gets or sets the index number end.
|
|
#[serde(rename = "IndexNumberEnd")]
|
|
pub index_number_end: Option<i32>,
|
|
/// Gets or sets the parent index number.
|
|
#[serde(rename = "ParentIndexNumber")]
|
|
pub parent_index_number: Option<i32>,
|
|
/// Gets or sets the trailer urls.
|
|
#[serde(rename = "RemoteTrailers")]
|
|
pub remote_trailers: Option<Vec<MediaUrl>>,
|
|
/// Gets or sets the provider ids.
|
|
#[serde(rename = "ProviderIds")]
|
|
pub provider_ids: Option<std::collections::HashMap<String, Option<String>>>,
|
|
/// Gets or sets a value indicating whether this instance is HD.
|
|
#[serde(rename = "IsHD")]
|
|
pub is_hd: Option<bool>,
|
|
/// Gets or sets a value indicating whether this instance is folder.
|
|
#[serde(rename = "IsFolder")]
|
|
pub is_folder: Option<bool>,
|
|
/// Gets or sets the parent id.
|
|
#[serde(rename = "ParentId")]
|
|
pub parent_id: Option<uuid::Uuid>,
|
|
/// Gets or sets the type.
|
|
#[serde(rename = "Type")]
|
|
pub _type: BaseItemKind,
|
|
/// Gets or sets the people.
|
|
#[serde(rename = "People")]
|
|
pub people: Option<Vec<BaseItemPerson>>,
|
|
/// Gets or sets the studios.
|
|
#[serde(rename = "Studios")]
|
|
pub studios: Option<Vec<NameGuidPair>>,
|
|
#[serde(rename = "GenreItems")]
|
|
pub genre_items: Option<Vec<NameGuidPair>>,
|
|
/// Gets or sets whether the item has a logo, this will hold the Id of the Parent that has one.
|
|
#[serde(rename = "ParentLogoItemId")]
|
|
pub parent_logo_item_id: Option<uuid::Uuid>,
|
|
/// Gets or sets whether the item has any backdrops, this will hold the Id of the Parent that has one.
|
|
#[serde(rename = "ParentBackdropItemId")]
|
|
pub parent_backdrop_item_id: Option<uuid::Uuid>,
|
|
/// Gets or sets the parent backdrop image tags.
|
|
#[serde(rename = "ParentBackdropImageTags")]
|
|
pub parent_backdrop_image_tags: Option<Vec<String>>,
|
|
/// Gets or sets the local trailer count.
|
|
#[serde(rename = "LocalTrailerCount")]
|
|
pub local_trailer_count: Option<i32>,
|
|
/// Gets or sets the user data for this item based on the user it's being requested for.
|
|
#[serde(rename = "UserData")]
|
|
pub user_data: Option<UserItemDataDto>,
|
|
/// Gets or sets the recursive item count.
|
|
#[serde(rename = "RecursiveItemCount")]
|
|
pub recursive_item_count: Option<i32>,
|
|
/// Gets or sets the child count.
|
|
#[serde(rename = "ChildCount")]
|
|
pub child_count: Option<i32>,
|
|
/// Gets or sets the name of the series.
|
|
#[serde(rename = "SeriesName")]
|
|
pub series_name: Option<String>,
|
|
/// Gets or sets the series id.
|
|
#[serde(rename = "SeriesId")]
|
|
pub series_id: Option<uuid::Uuid>,
|
|
/// Gets or sets the season identifier.
|
|
#[serde(rename = "SeasonId")]
|
|
pub season_id: Option<uuid::Uuid>,
|
|
/// Gets or sets the special feature count.
|
|
#[serde(rename = "SpecialFeatureCount")]
|
|
pub special_feature_count: Option<i32>,
|
|
/// Gets or sets the display preferences id.
|
|
#[serde(rename = "DisplayPreferencesId")]
|
|
pub display_preferences_id: Option<String>,
|
|
/// Gets or sets the status.
|
|
#[serde(rename = "Status")]
|
|
pub status: Option<String>,
|
|
/// Gets or sets the air time.
|
|
#[serde(rename = "AirTime")]
|
|
pub air_time: Option<String>,
|
|
/// Gets or sets the air days.
|
|
#[serde(rename = "AirDays")]
|
|
pub air_days: Option<Vec<DayOfWeek>>,
|
|
/// Gets or sets the tags.
|
|
#[serde(rename = "Tags")]
|
|
pub tags: Option<Vec<String>>,
|
|
/// Gets or sets the primary image aspect ratio, after image enhancements.
|
|
#[serde(rename = "PrimaryImageAspectRatio")]
|
|
pub primary_image_aspect_ratio: Option<f64>,
|
|
/// Gets or sets the artists.
|
|
#[serde(rename = "Artists")]
|
|
pub artists: Option<Vec<String>>,
|
|
/// Gets or sets the artist items.
|
|
#[serde(rename = "ArtistItems")]
|
|
pub artist_items: Option<Vec<NameGuidPair>>,
|
|
/// Gets or sets the album.
|
|
#[serde(rename = "Album")]
|
|
pub album: Option<String>,
|
|
/// Gets or sets the type of the collection.
|
|
#[serde(rename = "CollectionType")]
|
|
pub collection_type: Option<CollectionType>,
|
|
/// Gets or sets the display order.
|
|
#[serde(rename = "DisplayOrder")]
|
|
pub display_order: Option<String>,
|
|
/// Gets or sets the album id.
|
|
#[serde(rename = "AlbumId")]
|
|
pub album_id: Option<uuid::Uuid>,
|
|
/// Gets or sets the album image tag.
|
|
#[serde(rename = "AlbumPrimaryImageTag")]
|
|
pub album_primary_image_tag: Option<String>,
|
|
/// Gets or sets the series primary image tag.
|
|
#[serde(rename = "SeriesPrimaryImageTag")]
|
|
pub series_primary_image_tag: Option<String>,
|
|
/// Gets or sets the album artist.
|
|
#[serde(rename = "AlbumArtist")]
|
|
pub album_artist: Option<String>,
|
|
/// Gets or sets the album artists.
|
|
#[serde(rename = "AlbumArtists")]
|
|
pub album_artists: Option<Vec<NameGuidPair>>,
|
|
/// Gets or sets the name of the season.
|
|
#[serde(rename = "SeasonName")]
|
|
pub season_name: Option<String>,
|
|
/// Gets or sets the media streams.
|
|
#[serde(rename = "MediaStreams")]
|
|
pub media_streams: Option<Vec<MediaStream>>,
|
|
/// Gets or sets the type of the video.
|
|
#[serde(rename = "VideoType")]
|
|
pub video_type: Option<VideoType>,
|
|
/// Gets or sets the part count.
|
|
#[serde(rename = "PartCount")]
|
|
pub part_count: Option<i32>,
|
|
#[serde(rename = "MediaSourceCount")]
|
|
pub media_source_count: Option<i32>,
|
|
/// Gets or sets the image tags.
|
|
#[serde(rename = "ImageTags")]
|
|
pub image_tags: Option<std::collections::HashMap<String, String>>,
|
|
/// Gets or sets the backdrop image tags.
|
|
#[serde(rename = "BackdropImageTags")]
|
|
pub backdrop_image_tags: Option<Vec<String>>,
|
|
/// Gets or sets the screenshot image tags.
|
|
#[serde(rename = "ScreenshotImageTags")]
|
|
pub screenshot_image_tags: Option<Vec<String>>,
|
|
/// Gets or sets the parent logo image tag.
|
|
#[serde(rename = "ParentLogoImageTag")]
|
|
pub parent_logo_image_tag: Option<String>,
|
|
/// Gets or sets whether the item has fan art, this will hold the Id of the Parent that has one.
|
|
#[serde(rename = "ParentArtItemId")]
|
|
pub parent_art_item_id: Option<uuid::Uuid>,
|
|
/// Gets or sets the parent art image tag.
|
|
#[serde(rename = "ParentArtImageTag")]
|
|
pub parent_art_image_tag: Option<String>,
|
|
/// Gets or sets the series thumb image tag.
|
|
#[serde(rename = "SeriesThumbImageTag")]
|
|
pub series_thumb_image_tag: Option<String>,
|
|
/** Gets or sets the blurhashes for the image tags.
|
|
Maps image type to dictionary mapping image tag to blurhash value.*/
|
|
#[serde(rename = "ImageBlurHashes")]
|
|
pub image_blur_hashes: Option<std::collections::HashMap<String, serde_json::Value>>,
|
|
/// Gets or sets the series studio.
|
|
#[serde(rename = "SeriesStudio")]
|
|
pub series_studio: Option<String>,
|
|
/// Gets or sets the parent thumb item id.
|
|
#[serde(rename = "ParentThumbItemId")]
|
|
pub parent_thumb_item_id: Option<uuid::Uuid>,
|
|
/// Gets or sets the parent thumb image tag.
|
|
#[serde(rename = "ParentThumbImageTag")]
|
|
pub parent_thumb_image_tag: Option<String>,
|
|
/// Gets or sets the parent primary image item identifier.
|
|
#[serde(rename = "ParentPrimaryImageItemId")]
|
|
pub parent_primary_image_item_id: Option<String>,
|
|
/// Gets or sets the parent primary image tag.
|
|
#[serde(rename = "ParentPrimaryImageTag")]
|
|
pub parent_primary_image_tag: Option<String>,
|
|
/// Gets or sets the chapters.
|
|
#[serde(rename = "Chapters")]
|
|
pub chapters: Option<Vec<ChapterInfo>>,
|
|
/// Gets or sets the trickplay manifest.
|
|
#[serde(rename = "Trickplay")]
|
|
pub trickplay: Option<
|
|
std::collections::HashMap<
|
|
String,
|
|
std::collections::HashMap<String, TrickplayInfo>,
|
|
>,
|
|
>,
|
|
/// Gets or sets the type of the location.
|
|
#[serde(rename = "LocationType")]
|
|
pub location_type: Option<LocationType>,
|
|
/// Gets or sets the type of the iso.
|
|
#[serde(rename = "IsoType")]
|
|
pub iso_type: Option<IsoType>,
|
|
/// Gets or sets the type of the media.
|
|
#[serde(rename = "MediaType")]
|
|
pub media_type: MediaType,
|
|
/// Gets or sets the end date.
|
|
#[serde(rename = "EndDate")]
|
|
pub end_date: Option<jiff::Zoned>,
|
|
/// Gets or sets the locked fields.
|
|
#[serde(rename = "LockedFields")]
|
|
pub locked_fields: Option<Vec<MetadataField>>,
|
|
/// Gets or sets the trailer count.
|
|
#[serde(rename = "TrailerCount")]
|
|
pub trailer_count: Option<i32>,
|
|
/// Gets or sets the movie count.
|
|
#[serde(rename = "MovieCount")]
|
|
pub movie_count: Option<i32>,
|
|
/// Gets or sets the series count.
|
|
#[serde(rename = "SeriesCount")]
|
|
pub series_count: Option<i32>,
|
|
#[serde(rename = "ProgramCount")]
|
|
pub program_count: Option<i32>,
|
|
/// Gets or sets the episode count.
|
|
#[serde(rename = "EpisodeCount")]
|
|
pub episode_count: Option<i32>,
|
|
/// Gets or sets the song count.
|
|
#[serde(rename = "SongCount")]
|
|
pub song_count: Option<i32>,
|
|
/// Gets or sets the album count.
|
|
#[serde(rename = "AlbumCount")]
|
|
pub album_count: Option<i32>,
|
|
#[serde(rename = "ArtistCount")]
|
|
pub artist_count: Option<i32>,
|
|
/// Gets or sets the music video count.
|
|
#[serde(rename = "MusicVideoCount")]
|
|
pub music_video_count: Option<i32>,
|
|
/// Gets or sets a value indicating whether [enable internet providers].
|
|
#[serde(rename = "LockData")]
|
|
pub lock_data: Option<bool>,
|
|
#[serde(rename = "Width")]
|
|
pub width: Option<i32>,
|
|
#[serde(rename = "Height")]
|
|
pub height: Option<i32>,
|
|
#[serde(rename = "CameraMake")]
|
|
pub camera_make: Option<String>,
|
|
#[serde(rename = "CameraModel")]
|
|
pub camera_model: Option<String>,
|
|
#[serde(rename = "Software")]
|
|
pub software: Option<String>,
|
|
#[serde(rename = "ExposureTime")]
|
|
pub exposure_time: Option<f64>,
|
|
#[serde(rename = "FocalLength")]
|
|
pub focal_length: Option<f64>,
|
|
#[serde(rename = "ImageOrientation")]
|
|
pub image_orientation: Option<ImageOrientation>,
|
|
#[serde(rename = "Aperture")]
|
|
pub aperture: Option<f64>,
|
|
#[serde(rename = "ShutterSpeed")]
|
|
pub shutter_speed: Option<f64>,
|
|
#[serde(rename = "Latitude")]
|
|
pub latitude: Option<f64>,
|
|
#[serde(rename = "Longitude")]
|
|
pub longitude: Option<f64>,
|
|
#[serde(rename = "Altitude")]
|
|
pub altitude: Option<f64>,
|
|
#[serde(rename = "IsoSpeedRating")]
|
|
pub iso_speed_rating: Option<i32>,
|
|
/// Gets or sets the series timer identifier.
|
|
#[serde(rename = "SeriesTimerId")]
|
|
pub series_timer_id: Option<String>,
|
|
/// Gets or sets the program identifier.
|
|
#[serde(rename = "ProgramId")]
|
|
pub program_id: Option<String>,
|
|
/// Gets or sets the channel primary image tag.
|
|
#[serde(rename = "ChannelPrimaryImageTag")]
|
|
pub channel_primary_image_tag: Option<String>,
|
|
/// Gets or sets the start date of the recording, in UTC.
|
|
#[serde(rename = "StartDate")]
|
|
pub start_date: Option<jiff::Zoned>,
|
|
/// Gets or sets the completion percentage.
|
|
#[serde(rename = "CompletionPercentage")]
|
|
pub completion_percentage: Option<f64>,
|
|
/// Gets or sets a value indicating whether this instance is repeat.
|
|
#[serde(rename = "IsRepeat")]
|
|
pub is_repeat: Option<bool>,
|
|
/// Gets or sets the episode title.
|
|
#[serde(rename = "EpisodeTitle")]
|
|
pub episode_title: Option<String>,
|
|
/// Gets or sets the type of the channel.
|
|
#[serde(rename = "ChannelType")]
|
|
pub channel_type: Option<ChannelType>,
|
|
/// Gets or sets the audio.
|
|
#[serde(rename = "Audio")]
|
|
pub audio: Option<ProgramAudio>,
|
|
/// Gets or sets a value indicating whether this instance is movie.
|
|
#[serde(rename = "IsMovie")]
|
|
pub is_movie: Option<bool>,
|
|
/// Gets or sets a value indicating whether this instance is sports.
|
|
#[serde(rename = "IsSports")]
|
|
pub is_sports: Option<bool>,
|
|
/// Gets or sets a value indicating whether this instance is series.
|
|
#[serde(rename = "IsSeries")]
|
|
pub is_series: Option<bool>,
|
|
/// Gets or sets a value indicating whether this instance is live.
|
|
#[serde(rename = "IsLive")]
|
|
pub is_live: Option<bool>,
|
|
/// Gets or sets a value indicating whether this instance is news.
|
|
#[serde(rename = "IsNews")]
|
|
pub is_news: Option<bool>,
|
|
/// Gets or sets a value indicating whether this instance is kids.
|
|
#[serde(rename = "IsKids")]
|
|
pub is_kids: Option<bool>,
|
|
/// Gets or sets a value indicating whether this instance is premiere.
|
|
#[serde(rename = "IsPremiere")]
|
|
pub is_premiere: Option<bool>,
|
|
/// Gets or sets the timer identifier.
|
|
#[serde(rename = "TimerId")]
|
|
pub timer_id: Option<String>,
|
|
/// Gets or sets the gain required for audio normalization.
|
|
#[serde(rename = "NormalizationGain")]
|
|
pub normalization_gain: Option<f32>,
|
|
/// Gets or sets the current program.
|
|
#[serde(rename = "CurrentProgram")]
|
|
pub current_program: Option<Box<BaseItemDto>>,
|
|
}
|
|
/// Query result container.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct BaseItemDtoQueryResult {
|
|
/// Gets or sets the items.
|
|
#[serde(rename = "Items")]
|
|
pub items: Vec<BaseItemDto>,
|
|
/// Gets or sets the total number of records available.
|
|
#[serde(rename = "TotalRecordCount")]
|
|
pub total_record_count: i32,
|
|
/// Gets or sets the index of the first record in Items.
|
|
#[serde(rename = "StartIndex")]
|
|
pub start_index: i32,
|
|
}
|
|
/// This is used by the api to get information about a Person within a BaseItem.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct BaseItemPerson {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the identifier.
|
|
#[serde(rename = "Id")]
|
|
pub id: uuid::Uuid,
|
|
/// Gets or sets the role.
|
|
#[serde(rename = "Role")]
|
|
pub role: Option<String>,
|
|
/// Gets or sets the type.
|
|
#[serde(rename = "Type")]
|
|
pub _type: PersonKind,
|
|
/// Gets or sets the primary image tag.
|
|
#[serde(rename = "PrimaryImageTag")]
|
|
pub primary_image_tag: Option<String>,
|
|
/// Gets or sets the primary image blurhash.
|
|
#[serde(rename = "ImageBlurHashes")]
|
|
pub image_blur_hashes: Option<std::collections::HashMap<String, serde_json::Value>>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct BookInfo {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the original title.
|
|
#[serde(rename = "OriginalTitle")]
|
|
pub original_title: Option<String>,
|
|
/// Gets or sets the path.
|
|
#[serde(rename = "Path")]
|
|
pub path: Option<String>,
|
|
/// Gets or sets the metadata language.
|
|
#[serde(rename = "MetadataLanguage")]
|
|
pub metadata_language: Option<String>,
|
|
/// Gets or sets the metadata country code.
|
|
#[serde(rename = "MetadataCountryCode")]
|
|
pub metadata_country_code: Option<String>,
|
|
/// Gets or sets the provider ids.
|
|
#[serde(rename = "ProviderIds")]
|
|
pub provider_ids: Option<std::collections::HashMap<String, Option<String>>>,
|
|
/// Gets or sets the year.
|
|
#[serde(rename = "Year")]
|
|
pub year: Option<i32>,
|
|
#[serde(rename = "IndexNumber")]
|
|
pub index_number: Option<i32>,
|
|
#[serde(rename = "ParentIndexNumber")]
|
|
pub parent_index_number: Option<i32>,
|
|
#[serde(rename = "PremiereDate")]
|
|
pub premiere_date: Option<jiff::Zoned>,
|
|
#[serde(rename = "IsAutomated")]
|
|
pub is_automated: bool,
|
|
#[serde(rename = "SeriesName")]
|
|
pub series_name: Option<String>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct BookInfoRemoteSearchQuery {
|
|
#[serde(rename = "SearchInfo")]
|
|
pub search_info: Option<BookInfo>,
|
|
#[serde(rename = "ItemId")]
|
|
pub item_id: uuid::Uuid,
|
|
/// Gets or sets the provider name to search within if set.
|
|
#[serde(rename = "SearchProviderName")]
|
|
pub search_provider_name: Option<String>,
|
|
/// Gets or sets a value indicating whether disabled providers should be included.
|
|
#[serde(rename = "IncludeDisabledProviders")]
|
|
pub include_disabled_providers: bool,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct BoxSetInfo {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the original title.
|
|
#[serde(rename = "OriginalTitle")]
|
|
pub original_title: Option<String>,
|
|
/// Gets or sets the path.
|
|
#[serde(rename = "Path")]
|
|
pub path: Option<String>,
|
|
/// Gets or sets the metadata language.
|
|
#[serde(rename = "MetadataLanguage")]
|
|
pub metadata_language: Option<String>,
|
|
/// Gets or sets the metadata country code.
|
|
#[serde(rename = "MetadataCountryCode")]
|
|
pub metadata_country_code: Option<String>,
|
|
/// Gets or sets the provider ids.
|
|
#[serde(rename = "ProviderIds")]
|
|
pub provider_ids: Option<std::collections::HashMap<String, Option<String>>>,
|
|
/// Gets or sets the year.
|
|
#[serde(rename = "Year")]
|
|
pub year: Option<i32>,
|
|
#[serde(rename = "IndexNumber")]
|
|
pub index_number: Option<i32>,
|
|
#[serde(rename = "ParentIndexNumber")]
|
|
pub parent_index_number: Option<i32>,
|
|
#[serde(rename = "PremiereDate")]
|
|
pub premiere_date: Option<jiff::Zoned>,
|
|
#[serde(rename = "IsAutomated")]
|
|
pub is_automated: bool,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct BoxSetInfoRemoteSearchQuery {
|
|
#[serde(rename = "SearchInfo")]
|
|
pub search_info: Option<BoxSetInfo>,
|
|
#[serde(rename = "ItemId")]
|
|
pub item_id: uuid::Uuid,
|
|
/// Gets or sets the provider name to search within if set.
|
|
#[serde(rename = "SearchProviderName")]
|
|
pub search_provider_name: Option<String>,
|
|
/// Gets or sets a value indicating whether disabled providers should be included.
|
|
#[serde(rename = "IncludeDisabledProviders")]
|
|
pub include_disabled_providers: bool,
|
|
}
|
|
/// The branding options.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct BrandingOptions {
|
|
/// Gets or sets the login disclaimer.
|
|
#[serde(rename = "LoginDisclaimer")]
|
|
pub login_disclaimer: Option<String>,
|
|
/// Gets or sets the custom CSS.
|
|
#[serde(rename = "CustomCss")]
|
|
pub custom_css: Option<String>,
|
|
/// Gets or sets a value indicating whether to enable the splashscreen.
|
|
#[serde(rename = "SplashscreenEnabled")]
|
|
pub splashscreen_enabled: bool,
|
|
}
|
|
/// Class BufferRequestDto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct BufferRequestDto {
|
|
/// Gets or sets when the request has been made by the client.
|
|
#[serde(rename = "When")]
|
|
pub when: jiff::Zoned,
|
|
/// Gets or sets the position ticks.
|
|
#[serde(rename = "PositionTicks")]
|
|
pub position_ticks: i64,
|
|
/// Gets or sets a value indicating whether the client playback is unpaused.
|
|
#[serde(rename = "IsPlaying")]
|
|
pub is_playing: bool,
|
|
/// Gets or sets the playlist item identifier of the playing item.
|
|
#[serde(rename = "PlaylistItemId")]
|
|
pub playlist_item_id: uuid::Uuid,
|
|
}
|
|
/// The cast receiver application model.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct CastReceiverApplication {
|
|
/// Gets or sets the cast receiver application id.
|
|
#[serde(rename = "Id")]
|
|
pub id: String,
|
|
/// Gets or sets the cast receiver application name.
|
|
#[serde(rename = "Name")]
|
|
pub name: String,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ChannelFeatures {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: String,
|
|
/// Gets or sets the identifier.
|
|
#[serde(rename = "Id")]
|
|
pub id: uuid::Uuid,
|
|
/// Gets or sets a value indicating whether this instance can search.
|
|
#[serde(rename = "CanSearch")]
|
|
pub can_search: bool,
|
|
/// Gets or sets the media types.
|
|
#[serde(rename = "MediaTypes")]
|
|
pub media_types: Vec<ChannelMediaType>,
|
|
/// Gets or sets the content types.
|
|
#[serde(rename = "ContentTypes")]
|
|
pub content_types: Vec<ChannelMediaContentType>,
|
|
/// Gets or sets the maximum number of records the channel allows retrieving at a time.
|
|
#[serde(rename = "MaxPageSize")]
|
|
pub max_page_size: Option<i32>,
|
|
/// Gets or sets the automatic refresh levels.
|
|
#[serde(rename = "AutoRefreshLevels")]
|
|
pub auto_refresh_levels: Option<i32>,
|
|
/// Gets or sets the default sort orders.
|
|
#[serde(rename = "DefaultSortFields")]
|
|
pub default_sort_fields: Vec<ChannelItemSortField>,
|
|
/// Gets or sets a value indicating whether a sort ascending/descending toggle is supported.
|
|
#[serde(rename = "SupportsSortOrderToggle")]
|
|
pub supports_sort_order_toggle: bool,
|
|
/// Gets or sets a value indicating whether [supports latest media].
|
|
#[serde(rename = "SupportsLatestMedia")]
|
|
pub supports_latest_media: bool,
|
|
/// Gets or sets a value indicating whether this instance can filter.
|
|
#[serde(rename = "CanFilter")]
|
|
pub can_filter: bool,
|
|
/// Gets or sets a value indicating whether [supports content downloading].
|
|
#[serde(rename = "SupportsContentDownloading")]
|
|
pub supports_content_downloading: bool,
|
|
}
|
|
/// Channel mapping options dto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ChannelMappingOptionsDto {
|
|
/// Gets or sets list of tuner channels.
|
|
#[serde(rename = "TunerChannels")]
|
|
pub tuner_channels: Vec<TunerChannelMapping>,
|
|
/// Gets or sets list of provider channels.
|
|
#[serde(rename = "ProviderChannels")]
|
|
pub provider_channels: Vec<NameIdPair>,
|
|
/// Gets or sets list of mappings.
|
|
#[serde(rename = "Mappings")]
|
|
pub mappings: Vec<NameValuePair>,
|
|
/// Gets or sets provider name.
|
|
#[serde(rename = "ProviderName")]
|
|
pub provider_name: Option<String>,
|
|
}
|
|
/// Class ChapterInfo.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ChapterInfo {
|
|
/// Gets or sets the start position ticks.
|
|
#[serde(rename = "StartPositionTicks")]
|
|
pub start_position_ticks: i64,
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the image path.
|
|
#[serde(rename = "ImagePath")]
|
|
pub image_path: Option<String>,
|
|
#[serde(rename = "ImageDateModified")]
|
|
pub image_date_modified: jiff::Zoned,
|
|
#[serde(rename = "ImageTag")]
|
|
pub image_tag: Option<String>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct CheckpointId {
|
|
#[serde(rename = "Id")]
|
|
pub id: uuid::Uuid,
|
|
}
|
|
/// Client capabilities dto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ClientCapabilitiesDto {
|
|
/// Gets or sets the list of playable media types.
|
|
#[serde(rename = "PlayableMediaTypes")]
|
|
pub playable_media_types: Vec<MediaType>,
|
|
/// Gets or sets the list of supported commands.
|
|
#[serde(rename = "SupportedCommands")]
|
|
pub supported_commands: Vec<GeneralCommandType>,
|
|
/// Gets or sets a value indicating whether session supports media control.
|
|
#[serde(rename = "SupportsMediaControl")]
|
|
pub supports_media_control: bool,
|
|
/// Gets or sets a value indicating whether session supports a persistent identifier.
|
|
#[serde(rename = "SupportsPersistentIdentifier")]
|
|
pub supports_persistent_identifier: bool,
|
|
/// Gets or sets the device profile.
|
|
#[serde(rename = "DeviceProfile")]
|
|
pub device_profile: Option<DeviceProfile>,
|
|
/// Gets or sets the app store url.
|
|
#[serde(rename = "AppStoreUrl")]
|
|
pub app_store_url: Option<String>,
|
|
/// Gets or sets the icon url.
|
|
#[serde(rename = "IconUrl")]
|
|
pub icon_url: Option<String>,
|
|
}
|
|
/// Client log document response dto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ClientLogDocumentResponseDto {
|
|
/// Gets the resulting filename.
|
|
#[serde(rename = "FileName")]
|
|
pub file_name: String,
|
|
}
|
|
/// Defines the MediaBrowser.Model.Dlna.CodecProfile.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct CodecProfile {
|
|
/// Gets or sets the MediaBrowser.Model.Dlna.CodecType which this container must meet.
|
|
#[serde(rename = "Type")]
|
|
pub _type: CodecType,
|
|
/// Gets or sets the list of MediaBrowser.Model.Dlna.ProfileCondition which this profile must meet.
|
|
#[serde(rename = "Conditions")]
|
|
pub conditions: Vec<ProfileCondition>,
|
|
/// Gets or sets the list of MediaBrowser.Model.Dlna.ProfileCondition to apply if this profile is met.
|
|
#[serde(rename = "ApplyConditions")]
|
|
pub apply_conditions: Vec<ProfileCondition>,
|
|
/// Gets or sets the codec(s) that this profile applies to.
|
|
#[serde(rename = "Codec")]
|
|
pub codec: Option<String>,
|
|
/// Gets or sets the container(s) which this profile will be applied to.
|
|
#[serde(rename = "Container")]
|
|
pub container: Option<String>,
|
|
/// Gets or sets the sub-container(s) which this profile will be applied to.
|
|
#[serde(rename = "SubContainer")]
|
|
pub sub_container: Option<String>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct CollectionCreationResult {
|
|
#[serde(rename = "Id")]
|
|
pub id: uuid::Uuid,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ConfigImageTypes {
|
|
#[serde(rename = "BackdropSizes")]
|
|
pub backdrop_sizes: Option<Vec<String>>,
|
|
#[serde(rename = "BaseUrl")]
|
|
pub base_url: Option<String>,
|
|
#[serde(rename = "LogoSizes")]
|
|
pub logo_sizes: Option<Vec<String>>,
|
|
#[serde(rename = "PosterSizes")]
|
|
pub poster_sizes: Option<Vec<String>>,
|
|
#[serde(rename = "ProfileSizes")]
|
|
pub profile_sizes: Option<Vec<String>>,
|
|
#[serde(rename = "SecureBaseUrl")]
|
|
pub secure_base_url: Option<String>,
|
|
#[serde(rename = "StillSizes")]
|
|
pub still_sizes: Option<Vec<String>>,
|
|
}
|
|
/// The configuration page info.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ConfigurationPageInfo {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: String,
|
|
/// Gets or sets a value indicating whether the configurations page is enabled in the main menu.
|
|
#[serde(rename = "EnableInMainMenu")]
|
|
pub enable_in_main_menu: bool,
|
|
/// Gets or sets the menu section.
|
|
#[serde(rename = "MenuSection")]
|
|
pub menu_section: Option<String>,
|
|
/// Gets or sets the menu icon.
|
|
#[serde(rename = "MenuIcon")]
|
|
pub menu_icon: Option<String>,
|
|
/// Gets or sets the display name.
|
|
#[serde(rename = "DisplayName")]
|
|
pub display_name: Option<String>,
|
|
/// Gets or sets the plugin id.
|
|
#[serde(rename = "PluginId")]
|
|
pub plugin_id: Option<uuid::Uuid>,
|
|
}
|
|
/// Defines the MediaBrowser.Model.Dlna.ContainerProfile.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ContainerProfile {
|
|
/// Gets or sets the MediaBrowser.Model.Dlna.DlnaProfileType which this container must meet.
|
|
#[serde(rename = "Type")]
|
|
pub _type: DlnaProfileType,
|
|
/// Gets or sets the list of MediaBrowser.Model.Dlna.ProfileCondition which this container will be applied to.
|
|
#[serde(rename = "Conditions")]
|
|
pub conditions: Vec<ProfileCondition>,
|
|
/// Gets or sets the container(s) which this container must meet.
|
|
#[serde(rename = "Container")]
|
|
pub container: Option<String>,
|
|
/// Gets or sets the sub container(s) which this container must meet.
|
|
#[serde(rename = "SubContainer")]
|
|
pub sub_container: Option<String>,
|
|
}
|
|
/// Class CountryInfo.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct CountryInfo {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the display name.
|
|
#[serde(rename = "DisplayName")]
|
|
pub display_name: Option<String>,
|
|
/// Gets or sets the name of the two letter ISO region.
|
|
#[serde(rename = "TwoLetterISORegionName")]
|
|
pub two_letter_iso_region_name: Option<String>,
|
|
/// Gets or sets the name of the three letter ISO region.
|
|
#[serde(rename = "ThreeLetterISORegionName")]
|
|
pub three_letter_iso_region_name: Option<String>,
|
|
}
|
|
/// Create new playlist dto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct CreatePlaylistDto {
|
|
/// Gets or sets the name of the new playlist.
|
|
#[serde(rename = "Name")]
|
|
pub name: String,
|
|
/// Gets or sets item ids to add to the playlist.
|
|
#[serde(rename = "Ids")]
|
|
pub ids: Vec<uuid::Uuid>,
|
|
/// Gets or sets the user id.
|
|
#[serde(rename = "UserId")]
|
|
pub user_id: Option<uuid::Uuid>,
|
|
/// Gets or sets the media type.
|
|
#[serde(rename = "MediaType")]
|
|
pub media_type: Option<MediaType>,
|
|
/// Gets or sets the playlist users.
|
|
#[serde(rename = "Users")]
|
|
pub users: Vec<PlaylistUserPermissions>,
|
|
/// Gets or sets a value indicating whether the playlist is public.
|
|
#[serde(rename = "IsPublic")]
|
|
pub is_public: bool,
|
|
}
|
|
/// The create user by name request body.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct CreateUserByName {
|
|
/// Gets or sets the username.
|
|
#[serde(rename = "Name")]
|
|
pub name: String,
|
|
/// Gets or sets the password.
|
|
#[serde(rename = "Password")]
|
|
pub password: Option<String>,
|
|
}
|
|
/// Class CultureDto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct CultureDto {
|
|
/// Gets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: String,
|
|
/// Gets the display name.
|
|
#[serde(rename = "DisplayName")]
|
|
pub display_name: String,
|
|
/// Gets the name of the two letter ISO language.
|
|
#[serde(rename = "TwoLetterISOLanguageName")]
|
|
pub two_letter_iso_language_name: String,
|
|
/// Gets the name of the three letter ISO language.
|
|
#[serde(rename = "ThreeLetterISOLanguageName")]
|
|
pub three_letter_iso_language_name: Option<String>,
|
|
#[serde(rename = "ThreeLetterISOLanguageNames")]
|
|
pub three_letter_iso_language_names: Vec<String>,
|
|
}
|
|
/// Default directory browser info.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct DefaultDirectoryBrowserInfoDto {
|
|
/// Gets or sets the path.
|
|
#[serde(rename = "Path")]
|
|
pub path: Option<String>,
|
|
}
|
|
/// A DTO representing device information.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct DeviceInfoDto {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the custom name.
|
|
#[serde(rename = "CustomName")]
|
|
pub custom_name: Option<String>,
|
|
/// Gets or sets the access token.
|
|
#[serde(rename = "AccessToken")]
|
|
pub access_token: Option<String>,
|
|
/// Gets or sets the identifier.
|
|
#[serde(rename = "Id")]
|
|
pub id: Option<String>,
|
|
/// Gets or sets the last name of the user.
|
|
#[serde(rename = "LastUserName")]
|
|
pub last_user_name: Option<String>,
|
|
/// Gets or sets the name of the application.
|
|
#[serde(rename = "AppName")]
|
|
pub app_name: Option<String>,
|
|
/// Gets or sets the application version.
|
|
#[serde(rename = "AppVersion")]
|
|
pub app_version: Option<String>,
|
|
/// Gets or sets the last user identifier.
|
|
#[serde(rename = "LastUserId")]
|
|
pub last_user_id: Option<uuid::Uuid>,
|
|
/// Gets or sets the date last modified.
|
|
#[serde(rename = "DateLastActivity")]
|
|
pub date_last_activity: Option<jiff::Zoned>,
|
|
/// Gets or sets the capabilities.
|
|
#[serde(rename = "Capabilities")]
|
|
pub capabilities: ClientCapabilitiesDto,
|
|
/// Gets or sets the icon URL.
|
|
#[serde(rename = "IconUrl")]
|
|
pub icon_url: Option<String>,
|
|
}
|
|
/// Query result container.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct DeviceInfoDtoQueryResult {
|
|
/// Gets or sets the items.
|
|
#[serde(rename = "Items")]
|
|
pub items: Vec<DeviceInfoDto>,
|
|
/// Gets or sets the total number of records available.
|
|
#[serde(rename = "TotalRecordCount")]
|
|
pub total_record_count: i32,
|
|
/// Gets or sets the index of the first record in Items.
|
|
#[serde(rename = "StartIndex")]
|
|
pub start_index: i32,
|
|
}
|
|
/// A dto representing custom options for a device.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct DeviceOptionsDto {
|
|
/// Gets or sets the id.
|
|
#[serde(rename = "Id")]
|
|
pub id: i32,
|
|
/// Gets or sets the device id.
|
|
#[serde(rename = "DeviceId")]
|
|
pub device_id: Option<String>,
|
|
/// Gets or sets the custom name.
|
|
#[serde(rename = "CustomName")]
|
|
pub custom_name: Option<String>,
|
|
}
|
|
/** A MediaBrowser.Model.Dlna.DeviceProfile represents a set of metadata which determines which content a certain device is able to play.
|
|
<br />
|
|
Specifically, it defines the supported <see cref="P:MediaBrowser.Model.Dlna.DeviceProfile.ContainerProfiles">containers</see> and
|
|
<see cref="P:MediaBrowser.Model.Dlna.DeviceProfile.CodecProfiles">codecs</see> (video and/or audio, including codec profiles and levels)
|
|
the device is able to direct play (without transcoding or remuxing),
|
|
as well as which <see cref="P:MediaBrowser.Model.Dlna.DeviceProfile.TranscodingProfiles">containers/codecs to transcode to</see> in case it isn't.*/
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct DeviceProfile {
|
|
/// Gets or sets the name of this device profile. User profiles must have a unique name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the unique internal identifier.
|
|
#[serde(rename = "Id")]
|
|
pub id: Option<uuid::Uuid>,
|
|
/// Gets or sets the maximum allowed bitrate for all streamed content.
|
|
#[serde(rename = "MaxStreamingBitrate")]
|
|
pub max_streaming_bitrate: Option<i32>,
|
|
/// Gets or sets the maximum allowed bitrate for statically streamed content (= direct played files).
|
|
#[serde(rename = "MaxStaticBitrate")]
|
|
pub max_static_bitrate: Option<i32>,
|
|
/// Gets or sets the maximum allowed bitrate for transcoded music streams.
|
|
#[serde(rename = "MusicStreamingTranscodingBitrate")]
|
|
pub music_streaming_transcoding_bitrate: Option<i32>,
|
|
/// Gets or sets the maximum allowed bitrate for statically streamed (= direct played) music files.
|
|
#[serde(rename = "MaxStaticMusicBitrate")]
|
|
pub max_static_music_bitrate: Option<i32>,
|
|
/// Gets or sets the direct play profiles.
|
|
#[serde(rename = "DirectPlayProfiles")]
|
|
pub direct_play_profiles: Vec<DirectPlayProfile>,
|
|
/// Gets or sets the transcoding profiles.
|
|
#[serde(rename = "TranscodingProfiles")]
|
|
pub transcoding_profiles: Vec<TranscodingProfile>,
|
|
/// Gets or sets the container profiles. Failing to meet these optional conditions causes transcoding to occur.
|
|
#[serde(rename = "ContainerProfiles")]
|
|
pub container_profiles: Vec<ContainerProfile>,
|
|
/// Gets or sets the codec profiles.
|
|
#[serde(rename = "CodecProfiles")]
|
|
pub codec_profiles: Vec<CodecProfile>,
|
|
/// Gets or sets the subtitle profiles.
|
|
#[serde(rename = "SubtitleProfiles")]
|
|
pub subtitle_profiles: Vec<SubtitleProfile>,
|
|
}
|
|
/// Defines the MediaBrowser.Model.Dlna.DirectPlayProfile.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct DirectPlayProfile {
|
|
/// Gets or sets the container.
|
|
#[serde(rename = "Container")]
|
|
pub container: String,
|
|
/// Gets or sets the audio codec.
|
|
#[serde(rename = "AudioCodec")]
|
|
pub audio_codec: Option<String>,
|
|
/// Gets or sets the video codec.
|
|
#[serde(rename = "VideoCodec")]
|
|
pub video_codec: Option<String>,
|
|
/// Gets or sets the Dlna profile type.
|
|
#[serde(rename = "Type")]
|
|
pub _type: DlnaProfileType,
|
|
}
|
|
/// Defines the display preferences for any item that supports them (usually Folders).
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct DisplayPreferencesDto {
|
|
/// Gets or sets the user id.
|
|
#[serde(rename = "Id")]
|
|
pub id: Option<String>,
|
|
/// Gets or sets the type of the view.
|
|
#[serde(rename = "ViewType")]
|
|
pub view_type: Option<String>,
|
|
/// Gets or sets the sort by.
|
|
#[serde(rename = "SortBy")]
|
|
pub sort_by: Option<String>,
|
|
/// Gets or sets the index by.
|
|
#[serde(rename = "IndexBy")]
|
|
pub index_by: Option<String>,
|
|
/// Gets or sets a value indicating whether [remember indexing].
|
|
#[serde(rename = "RememberIndexing")]
|
|
pub remember_indexing: bool,
|
|
/// Gets or sets the height of the primary image.
|
|
#[serde(rename = "PrimaryImageHeight")]
|
|
pub primary_image_height: i32,
|
|
/// Gets or sets the width of the primary image.
|
|
#[serde(rename = "PrimaryImageWidth")]
|
|
pub primary_image_width: i32,
|
|
/// Gets or sets the custom prefs.
|
|
#[serde(rename = "CustomPrefs")]
|
|
pub custom_prefs: std::collections::HashMap<String, Option<String>>,
|
|
/// Gets or sets the scroll direction.
|
|
#[serde(rename = "ScrollDirection")]
|
|
pub scroll_direction: ScrollDirection,
|
|
/// Gets or sets a value indicating whether to show backdrops on this item.
|
|
#[serde(rename = "ShowBackdrop")]
|
|
pub show_backdrop: bool,
|
|
/// Gets or sets a value indicating whether [remember sorting].
|
|
#[serde(rename = "RememberSorting")]
|
|
pub remember_sorting: bool,
|
|
/// Gets or sets the sort order.
|
|
#[serde(rename = "SortOrder")]
|
|
pub sort_order: SortOrder,
|
|
/// Gets or sets a value indicating whether [show sidebar].
|
|
#[serde(rename = "ShowSidebar")]
|
|
pub show_sidebar: bool,
|
|
/// Gets or sets the client.
|
|
#[serde(rename = "Client")]
|
|
pub client: Option<String>,
|
|
}
|
|
/// Class EncodingOptions.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct EncodingOptions {
|
|
/// Gets or sets the thread count used for encoding.
|
|
#[serde(rename = "EncodingThreadCount")]
|
|
pub encoding_thread_count: i32,
|
|
/// Gets or sets the temporary transcoding path.
|
|
#[serde(rename = "TranscodingTempPath")]
|
|
pub transcoding_temp_path: Option<String>,
|
|
/// Gets or sets the path to the fallback font.
|
|
#[serde(rename = "FallbackFontPath")]
|
|
pub fallback_font_path: Option<String>,
|
|
/// Gets or sets a value indicating whether to use the fallback font.
|
|
#[serde(rename = "EnableFallbackFont")]
|
|
pub enable_fallback_font: bool,
|
|
/// Gets or sets a value indicating whether audio VBR is enabled.
|
|
#[serde(rename = "EnableAudioVbr")]
|
|
pub enable_audio_vbr: bool,
|
|
/// Gets or sets the audio boost applied when downmixing audio.
|
|
#[serde(rename = "DownMixAudioBoost")]
|
|
pub down_mix_audio_boost: f64,
|
|
/// Gets or sets the algorithm used for downmixing audio to stereo.
|
|
#[serde(rename = "DownMixStereoAlgorithm")]
|
|
pub down_mix_stereo_algorithm: DownMixStereoAlgorithms,
|
|
/// Gets or sets the maximum size of the muxing queue.
|
|
#[serde(rename = "MaxMuxingQueueSize")]
|
|
pub max_muxing_queue_size: i32,
|
|
/// Gets or sets a value indicating whether throttling is enabled.
|
|
#[serde(rename = "EnableThrottling")]
|
|
pub enable_throttling: bool,
|
|
/// Gets or sets the delay after which throttling happens.
|
|
#[serde(rename = "ThrottleDelaySeconds")]
|
|
pub throttle_delay_seconds: i32,
|
|
/// Gets or sets a value indicating whether segment deletion is enabled.
|
|
#[serde(rename = "EnableSegmentDeletion")]
|
|
pub enable_segment_deletion: bool,
|
|
/// Gets or sets seconds for which segments should be kept before being deleted.
|
|
#[serde(rename = "SegmentKeepSeconds")]
|
|
pub segment_keep_seconds: i32,
|
|
/// Gets or sets the hardware acceleration type.
|
|
#[serde(rename = "HardwareAccelerationType")]
|
|
pub hardware_acceleration_type: HardwareAccelerationType,
|
|
/// Gets or sets the FFmpeg path as set by the user via the UI.
|
|
#[serde(rename = "EncoderAppPath")]
|
|
pub encoder_app_path: Option<String>,
|
|
/// Gets or sets the current FFmpeg path being used by the system and displayed on the transcode page.
|
|
#[serde(rename = "EncoderAppPathDisplay")]
|
|
pub encoder_app_path_display: Option<String>,
|
|
/// Gets or sets the VA-API device.
|
|
#[serde(rename = "VaapiDevice")]
|
|
pub vaapi_device: Option<String>,
|
|
/// Gets or sets the QSV device.
|
|
#[serde(rename = "QsvDevice")]
|
|
pub qsv_device: Option<String>,
|
|
/// Gets or sets a value indicating whether tonemapping is enabled.
|
|
#[serde(rename = "EnableTonemapping")]
|
|
pub enable_tonemapping: bool,
|
|
/// Gets or sets a value indicating whether VPP tonemapping is enabled.
|
|
#[serde(rename = "EnableVppTonemapping")]
|
|
pub enable_vpp_tonemapping: bool,
|
|
/// Gets or sets a value indicating whether videotoolbox tonemapping is enabled.
|
|
#[serde(rename = "EnableVideoToolboxTonemapping")]
|
|
pub enable_video_toolbox_tonemapping: bool,
|
|
/// Gets or sets the tone-mapping algorithm.
|
|
#[serde(rename = "TonemappingAlgorithm")]
|
|
pub tonemapping_algorithm: TonemappingAlgorithm,
|
|
/// Gets or sets the tone-mapping mode.
|
|
#[serde(rename = "TonemappingMode")]
|
|
pub tonemapping_mode: TonemappingMode,
|
|
/// Gets or sets the tone-mapping range.
|
|
#[serde(rename = "TonemappingRange")]
|
|
pub tonemapping_range: TonemappingRange,
|
|
/// Gets or sets the tone-mapping desaturation.
|
|
#[serde(rename = "TonemappingDesat")]
|
|
pub tonemapping_desat: f64,
|
|
/// Gets or sets the tone-mapping peak.
|
|
#[serde(rename = "TonemappingPeak")]
|
|
pub tonemapping_peak: f64,
|
|
/// Gets or sets the tone-mapping parameters.
|
|
#[serde(rename = "TonemappingParam")]
|
|
pub tonemapping_param: f64,
|
|
/// Gets or sets the VPP tone-mapping brightness.
|
|
#[serde(rename = "VppTonemappingBrightness")]
|
|
pub vpp_tonemapping_brightness: f64,
|
|
/// Gets or sets the VPP tone-mapping contrast.
|
|
#[serde(rename = "VppTonemappingContrast")]
|
|
pub vpp_tonemapping_contrast: f64,
|
|
/// Gets or sets the H264 CRF.
|
|
#[serde(rename = "H264Crf")]
|
|
pub h264_crf: i32,
|
|
/// Gets or sets the H265 CRF.
|
|
#[serde(rename = "H265Crf")]
|
|
pub h265_crf: i32,
|
|
/// Gets or sets the encoder preset.
|
|
#[serde(rename = "EncoderPreset")]
|
|
pub encoder_preset: Option<EncoderPreset>,
|
|
/// Gets or sets a value indicating whether the framerate is doubled when deinterlacing.
|
|
#[serde(rename = "DeinterlaceDoubleRate")]
|
|
pub deinterlace_double_rate: bool,
|
|
/// Gets or sets the deinterlace method.
|
|
#[serde(rename = "DeinterlaceMethod")]
|
|
pub deinterlace_method: DeinterlaceMethod,
|
|
/// Gets or sets a value indicating whether 10bit HEVC decoding is enabled.
|
|
#[serde(rename = "EnableDecodingColorDepth10Hevc")]
|
|
pub enable_decoding_color_depth10_hevc: bool,
|
|
/// Gets or sets a value indicating whether 10bit VP9 decoding is enabled.
|
|
#[serde(rename = "EnableDecodingColorDepth10Vp9")]
|
|
pub enable_decoding_color_depth10_vp9: bool,
|
|
/// Gets or sets a value indicating whether 8/10bit HEVC RExt decoding is enabled.
|
|
#[serde(rename = "EnableDecodingColorDepth10HevcRext")]
|
|
pub enable_decoding_color_depth10_hevc_rext: bool,
|
|
/// Gets or sets a value indicating whether 12bit HEVC RExt decoding is enabled.
|
|
#[serde(rename = "EnableDecodingColorDepth12HevcRext")]
|
|
pub enable_decoding_color_depth12_hevc_rext: bool,
|
|
/// Gets or sets a value indicating whether the enhanced NVDEC is enabled.
|
|
#[serde(rename = "EnableEnhancedNvdecDecoder")]
|
|
pub enable_enhanced_nvdec_decoder: bool,
|
|
/// Gets or sets a value indicating whether the system native hardware decoder should be used.
|
|
#[serde(rename = "PreferSystemNativeHwDecoder")]
|
|
pub prefer_system_native_hw_decoder: bool,
|
|
/// Gets or sets a value indicating whether the Intel H264 low-power hardware encoder should be used.
|
|
#[serde(rename = "EnableIntelLowPowerH264HwEncoder")]
|
|
pub enable_intel_low_power_h264_hw_encoder: bool,
|
|
/// Gets or sets a value indicating whether the Intel HEVC low-power hardware encoder should be used.
|
|
#[serde(rename = "EnableIntelLowPowerHevcHwEncoder")]
|
|
pub enable_intel_low_power_hevc_hw_encoder: bool,
|
|
/// Gets or sets a value indicating whether hardware encoding is enabled.
|
|
#[serde(rename = "EnableHardwareEncoding")]
|
|
pub enable_hardware_encoding: bool,
|
|
/// Gets or sets a value indicating whether HEVC encoding is enabled.
|
|
#[serde(rename = "AllowHevcEncoding")]
|
|
pub allow_hevc_encoding: bool,
|
|
/// Gets or sets a value indicating whether AV1 encoding is enabled.
|
|
#[serde(rename = "AllowAv1Encoding")]
|
|
pub allow_av1_encoding: bool,
|
|
/// Gets or sets a value indicating whether subtitle extraction is enabled.
|
|
#[serde(rename = "EnableSubtitleExtraction")]
|
|
pub enable_subtitle_extraction: bool,
|
|
/// Gets or sets the codecs hardware encoding is used for.
|
|
#[serde(rename = "HardwareDecodingCodecs")]
|
|
pub hardware_decoding_codecs: Option<Vec<String>>,
|
|
/// Gets or sets the file extensions on-demand metadata based keyframe extraction is enabled for.
|
|
#[serde(rename = "AllowOnDemandMetadataBasedKeyframeExtractionForExtensions")]
|
|
pub allow_on_demand_metadata_based_keyframe_extraction_for_extensions: Option<
|
|
Vec<String>,
|
|
>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct EndPointInfo {
|
|
#[serde(rename = "IsLocal")]
|
|
pub is_local: bool,
|
|
#[serde(rename = "IsInNetwork")]
|
|
pub is_in_network: bool,
|
|
}
|
|
/// Represents the external id information for serialization to the client.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ExternalIdInfo {
|
|
/// Gets or sets the display name of the external id provider (IE: IMDB, MusicBrainz, etc).
|
|
#[serde(rename = "Name")]
|
|
pub name: String,
|
|
/// Gets or sets the unique key for this id. This key should be unique across all providers.
|
|
#[serde(rename = "Key")]
|
|
pub key: String,
|
|
/** Gets or sets the specific media type for this id. This is used to distinguish between the different
|
|
external id types for providers with multiple ids.
|
|
A null value indicates there is no specific media type associated with the external id, or this is the
|
|
default id for the external provider so there is no need to specify a type.*/
|
|
#[serde(rename = "Type")]
|
|
pub _type: Option<ExternalIdMediaType>,
|
|
/// Gets or sets the URL format string.
|
|
#[serde(rename = "UrlFormatString")]
|
|
pub url_format_string: Option<String>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ExternalUrl {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the type of the item.
|
|
#[serde(rename = "Url")]
|
|
pub url: Option<String>,
|
|
}
|
|
/// Class FileSystemEntryInfo.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct FileSystemEntryInfo {
|
|
/// Gets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: String,
|
|
/// Gets the path.
|
|
#[serde(rename = "Path")]
|
|
pub path: String,
|
|
/// Gets the type.
|
|
#[serde(rename = "Type")]
|
|
pub _type: FileSystemEntryType,
|
|
}
|
|
/// Class FontFile.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct FontFile {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the size.
|
|
#[serde(rename = "Size")]
|
|
pub size: i64,
|
|
/// Gets or sets the date created.
|
|
#[serde(rename = "DateCreated")]
|
|
pub date_created: jiff::Zoned,
|
|
/// Gets or sets the date modified.
|
|
#[serde(rename = "DateModified")]
|
|
pub date_modified: jiff::Zoned,
|
|
}
|
|
/// Force keep alive websocket messages.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ForceKeepAliveMessage {
|
|
/// Gets or sets the data.
|
|
#[serde(rename = "Data")]
|
|
pub data: i32,
|
|
/// Gets or sets the message id.
|
|
#[serde(rename = "MessageId")]
|
|
pub message_id: uuid::Uuid,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Forgot Password request body DTO.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ForgotPasswordDto {
|
|
/// Gets or sets the entered username to have its password reset.
|
|
#[serde(rename = "EnteredUsername")]
|
|
pub entered_username: String,
|
|
}
|
|
/// Forgot Password Pin enter request body DTO.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ForgotPasswordPinDto {
|
|
/// Gets or sets the entered pin to have the password reset.
|
|
#[serde(rename = "Pin")]
|
|
pub pin: String,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ForgotPasswordResult {
|
|
/// Gets or sets the action.
|
|
#[serde(rename = "Action")]
|
|
pub action: ForgotPasswordAction,
|
|
/// Gets or sets the pin file.
|
|
#[serde(rename = "PinFile")]
|
|
pub pin_file: Option<String>,
|
|
/// Gets or sets the pin expiration date.
|
|
#[serde(rename = "PinExpirationDate")]
|
|
pub pin_expiration_date: Option<jiff::Zoned>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct GeneralCommand {
|
|
/// This exists simply to identify a set of known commands.
|
|
#[serde(rename = "Name")]
|
|
pub name: GeneralCommandType,
|
|
#[serde(rename = "ControllingUserId")]
|
|
pub controlling_user_id: uuid::Uuid,
|
|
#[serde(rename = "Arguments")]
|
|
pub arguments: std::collections::HashMap<String, Option<String>>,
|
|
}
|
|
/// General command websocket message.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct GeneralCommandMessage {
|
|
/// Gets or sets the data.
|
|
#[serde(rename = "Data")]
|
|
pub data: Option<GeneralCommand>,
|
|
/// Gets or sets the message id.
|
|
#[serde(rename = "MessageId")]
|
|
pub message_id: uuid::Uuid,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Get programs dto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct GetProgramsDto {
|
|
/// Gets or sets the channels to return guide information for.
|
|
#[serde(rename = "ChannelIds")]
|
|
pub channel_ids: Option<Vec<uuid::Uuid>>,
|
|
/// Gets or sets optional. Filter by user id.
|
|
#[serde(rename = "UserId")]
|
|
pub user_id: Option<uuid::Uuid>,
|
|
/// Gets or sets the minimum premiere start date.
|
|
#[serde(rename = "MinStartDate")]
|
|
pub min_start_date: Option<jiff::Zoned>,
|
|
/// Gets or sets filter by programs that have completed airing, or not.
|
|
#[serde(rename = "HasAired")]
|
|
pub has_aired: Option<bool>,
|
|
/// Gets or sets filter by programs that are currently airing, or not.
|
|
#[serde(rename = "IsAiring")]
|
|
pub is_airing: Option<bool>,
|
|
/// Gets or sets the maximum premiere start date.
|
|
#[serde(rename = "MaxStartDate")]
|
|
pub max_start_date: Option<jiff::Zoned>,
|
|
/// Gets or sets the minimum premiere end date.
|
|
#[serde(rename = "MinEndDate")]
|
|
pub min_end_date: Option<jiff::Zoned>,
|
|
/// Gets or sets the maximum premiere end date.
|
|
#[serde(rename = "MaxEndDate")]
|
|
pub max_end_date: Option<jiff::Zoned>,
|
|
/// Gets or sets filter for movies.
|
|
#[serde(rename = "IsMovie")]
|
|
pub is_movie: Option<bool>,
|
|
/// Gets or sets filter for series.
|
|
#[serde(rename = "IsSeries")]
|
|
pub is_series: Option<bool>,
|
|
/// Gets or sets filter for news.
|
|
#[serde(rename = "IsNews")]
|
|
pub is_news: Option<bool>,
|
|
/// Gets or sets filter for kids.
|
|
#[serde(rename = "IsKids")]
|
|
pub is_kids: Option<bool>,
|
|
/// Gets or sets filter for sports.
|
|
#[serde(rename = "IsSports")]
|
|
pub is_sports: Option<bool>,
|
|
/// Gets or sets the record index to start at. All items with a lower index will be dropped from the results.
|
|
#[serde(rename = "StartIndex")]
|
|
pub start_index: Option<i32>,
|
|
/// Gets or sets the maximum number of records to return.
|
|
#[serde(rename = "Limit")]
|
|
pub limit: Option<i32>,
|
|
/// Gets or sets specify one or more sort orders, comma delimited. Options: Name, StartDate.
|
|
#[serde(rename = "SortBy")]
|
|
pub sort_by: Option<Vec<ItemSortBy>>,
|
|
/// Gets or sets sort order.
|
|
#[serde(rename = "SortOrder")]
|
|
pub sort_order: Option<Vec<SortOrder>>,
|
|
/// Gets or sets the genres to return guide information for.
|
|
#[serde(rename = "Genres")]
|
|
pub genres: Option<Vec<String>>,
|
|
/// Gets or sets the genre ids to return guide information for.
|
|
#[serde(rename = "GenreIds")]
|
|
pub genre_ids: Option<Vec<uuid::Uuid>>,
|
|
/// Gets or sets include image information in output.
|
|
#[serde(rename = "EnableImages")]
|
|
pub enable_images: Option<bool>,
|
|
/// Gets or sets a value indicating whether retrieve total record count.
|
|
#[serde(rename = "EnableTotalRecordCount")]
|
|
pub enable_total_record_count: bool,
|
|
/// Gets or sets the max number of images to return, per image type.
|
|
#[serde(rename = "ImageTypeLimit")]
|
|
pub image_type_limit: Option<i32>,
|
|
/// Gets or sets the image types to include in the output.
|
|
#[serde(rename = "EnableImageTypes")]
|
|
pub enable_image_types: Option<Vec<ImageType>>,
|
|
/// Gets or sets include user data.
|
|
#[serde(rename = "EnableUserData")]
|
|
pub enable_user_data: Option<bool>,
|
|
/// Gets or sets filter by series timer id.
|
|
#[serde(rename = "SeriesTimerId")]
|
|
pub series_timer_id: Option<String>,
|
|
/// Gets or sets filter by library series id.
|
|
#[serde(rename = "LibrarySeriesId")]
|
|
pub library_series_id: Option<uuid::Uuid>,
|
|
/// Gets or sets specify additional fields of information to return in the output.
|
|
#[serde(rename = "Fields")]
|
|
pub fields: Option<Vec<ItemFields>>,
|
|
}
|
|
/// Class GroupInfoDto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct GroupInfoDto {
|
|
/// Gets the group identifier.
|
|
#[serde(rename = "GroupId")]
|
|
pub group_id: uuid::Uuid,
|
|
/// Gets the group name.
|
|
#[serde(rename = "GroupName")]
|
|
pub group_name: String,
|
|
/// Gets the group state.
|
|
#[serde(rename = "State")]
|
|
pub state: GroupStateType,
|
|
/// Gets the participants.
|
|
#[serde(rename = "Participants")]
|
|
pub participants: Vec<String>,
|
|
/// Gets the date when this DTO has been created.
|
|
#[serde(rename = "LastUpdatedAt")]
|
|
pub last_updated_at: jiff::Zoned,
|
|
}
|
|
/// Class GroupUpdate.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct GroupInfoDtoGroupUpdate {
|
|
/// Gets the group identifier.
|
|
#[serde(rename = "GroupId")]
|
|
pub group_id: uuid::Uuid,
|
|
/// Gets the update type.
|
|
#[serde(rename = "Type")]
|
|
pub _type: GroupUpdateType,
|
|
/// Gets the update data.
|
|
#[serde(rename = "Data")]
|
|
pub data: GroupInfoDto,
|
|
}
|
|
/// Class GroupStateUpdate.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct GroupStateUpdate {
|
|
/// Gets the state of the group.
|
|
#[serde(rename = "State")]
|
|
pub state: GroupStateType,
|
|
/// Gets the reason of the state change.
|
|
#[serde(rename = "Reason")]
|
|
pub reason: PlaybackRequestType,
|
|
}
|
|
/// Class GroupUpdate.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct GroupStateUpdateGroupUpdate {
|
|
/// Gets the group identifier.
|
|
#[serde(rename = "GroupId")]
|
|
pub group_id: uuid::Uuid,
|
|
/// Gets the update type.
|
|
#[serde(rename = "Type")]
|
|
pub _type: GroupUpdateType,
|
|
/// Gets the update data.
|
|
#[serde(rename = "Data")]
|
|
pub data: GroupStateUpdate,
|
|
}
|
|
/// Group update without data.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct GroupUpdate {
|
|
/// Gets the group identifier.
|
|
#[serde(rename = "GroupId")]
|
|
pub group_id: uuid::Uuid,
|
|
/// Gets the update type.
|
|
#[serde(rename = "Type")]
|
|
pub _type: GroupUpdateType,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct GuideInfo {
|
|
/// Gets or sets the start date.
|
|
#[serde(rename = "StartDate")]
|
|
pub start_date: jiff::Zoned,
|
|
/// Gets or sets the end date.
|
|
#[serde(rename = "EndDate")]
|
|
pub end_date: jiff::Zoned,
|
|
}
|
|
/// Class IgnoreWaitRequestDto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct IgnoreWaitRequestDto {
|
|
/// Gets or sets a value indicating whether the client should be ignored.
|
|
#[serde(rename = "IgnoreWait")]
|
|
pub ignore_wait: bool,
|
|
}
|
|
/// Class ImageInfo.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ImageInfo {
|
|
/// Gets or sets the type of the image.
|
|
#[serde(rename = "ImageType")]
|
|
pub image_type: ImageType,
|
|
/// Gets or sets the index of the image.
|
|
#[serde(rename = "ImageIndex")]
|
|
pub image_index: Option<i32>,
|
|
/// Gets or sets the image tag.
|
|
#[serde(rename = "ImageTag")]
|
|
pub image_tag: Option<String>,
|
|
/// Gets or sets the path.
|
|
#[serde(rename = "Path")]
|
|
pub path: Option<String>,
|
|
/// Gets or sets the blurhash.
|
|
#[serde(rename = "BlurHash")]
|
|
pub blur_hash: Option<String>,
|
|
/// Gets or sets the height.
|
|
#[serde(rename = "Height")]
|
|
pub height: Option<i32>,
|
|
/// Gets or sets the width.
|
|
#[serde(rename = "Width")]
|
|
pub width: Option<i32>,
|
|
/// Gets or sets the size.
|
|
#[serde(rename = "Size")]
|
|
pub size: i64,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ImageOption {
|
|
/// Gets or sets the type.
|
|
#[serde(rename = "Type")]
|
|
pub _type: ImageType,
|
|
/// Gets or sets the limit.
|
|
#[serde(rename = "Limit")]
|
|
pub limit: i32,
|
|
/// Gets or sets the minimum width.
|
|
#[serde(rename = "MinWidth")]
|
|
pub min_width: i32,
|
|
}
|
|
/// Class ImageProviderInfo.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ImageProviderInfo {
|
|
/// Gets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: String,
|
|
/// Gets the supported image types.
|
|
#[serde(rename = "SupportedImages")]
|
|
pub supported_images: Vec<ImageType>,
|
|
}
|
|
/// Keep alive websocket messages.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct InboundKeepAliveMessage {
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Class InstallationInfo.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct InstallationInfo {
|
|
/// Gets or sets the Id.
|
|
#[serde(rename = "Guid")]
|
|
pub guid: uuid::Uuid,
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the version.
|
|
#[serde(rename = "Version")]
|
|
pub version: Option<String>,
|
|
/// Gets or sets the changelog for this version.
|
|
#[serde(rename = "Changelog")]
|
|
pub changelog: Option<String>,
|
|
/// Gets or sets the source URL.
|
|
#[serde(rename = "SourceUrl")]
|
|
pub source_url: Option<String>,
|
|
/// Gets or sets a checksum for the binary.
|
|
#[serde(rename = "Checksum")]
|
|
pub checksum: Option<String>,
|
|
/// Gets or sets package information for the installation.
|
|
#[serde(rename = "PackageInfo")]
|
|
pub package_info: Option<PackageInfo>,
|
|
}
|
|
/// Defines the MediaBrowser.Common.Plugins.IPlugin.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct IPlugin {
|
|
/// Gets the name of the plugin.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets the Description.
|
|
#[serde(rename = "Description")]
|
|
pub description: Option<String>,
|
|
/// Gets the unique id.
|
|
#[serde(rename = "Id")]
|
|
pub id: uuid::Uuid,
|
|
/// Gets the plugin version.
|
|
#[serde(rename = "Version")]
|
|
pub version: Option<String>,
|
|
/// Gets the path to the assembly file.
|
|
#[serde(rename = "AssemblyFilePath")]
|
|
pub assembly_file_path: Option<String>,
|
|
/// Gets a value indicating whether the plugin can be uninstalled.
|
|
#[serde(rename = "CanUninstall")]
|
|
pub can_uninstall: bool,
|
|
/// Gets the full path to the data folder, where the plugin can store any miscellaneous files needed.
|
|
#[serde(rename = "DataFolderPath")]
|
|
pub data_folder_path: Option<String>,
|
|
}
|
|
/// Class LibrarySummary.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ItemCounts {
|
|
/// Gets or sets the movie count.
|
|
#[serde(rename = "MovieCount")]
|
|
pub movie_count: i32,
|
|
/// Gets or sets the series count.
|
|
#[serde(rename = "SeriesCount")]
|
|
pub series_count: i32,
|
|
/// Gets or sets the episode count.
|
|
#[serde(rename = "EpisodeCount")]
|
|
pub episode_count: i32,
|
|
/// Gets or sets the artist count.
|
|
#[serde(rename = "ArtistCount")]
|
|
pub artist_count: i32,
|
|
/// Gets or sets the program count.
|
|
#[serde(rename = "ProgramCount")]
|
|
pub program_count: i32,
|
|
/// Gets or sets the trailer count.
|
|
#[serde(rename = "TrailerCount")]
|
|
pub trailer_count: i32,
|
|
/// Gets or sets the song count.
|
|
#[serde(rename = "SongCount")]
|
|
pub song_count: i32,
|
|
/// Gets or sets the album count.
|
|
#[serde(rename = "AlbumCount")]
|
|
pub album_count: i32,
|
|
/// Gets or sets the music video count.
|
|
#[serde(rename = "MusicVideoCount")]
|
|
pub music_video_count: i32,
|
|
/// Gets or sets the box set count.
|
|
#[serde(rename = "BoxSetCount")]
|
|
pub box_set_count: i32,
|
|
/// Gets or sets the book count.
|
|
#[serde(rename = "BookCount")]
|
|
pub book_count: i32,
|
|
/// Gets or sets the item count.
|
|
#[serde(rename = "ItemCount")]
|
|
pub item_count: i32,
|
|
}
|
|
/// Class JoinGroupRequestDto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct JoinGroupRequestDto {
|
|
/// Gets or sets the group identifier.
|
|
#[serde(rename = "GroupId")]
|
|
pub group_id: uuid::Uuid,
|
|
}
|
|
/// Library changed message.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct LibraryChangedMessage {
|
|
/// Class LibraryUpdateInfo.
|
|
#[serde(rename = "Data")]
|
|
pub data: Option<LibraryUpdateInfo>,
|
|
/// Gets or sets the message id.
|
|
#[serde(rename = "MessageId")]
|
|
pub message_id: uuid::Uuid,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Library option info dto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct LibraryOptionInfoDto {
|
|
/// Gets or sets name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets a value indicating whether default enabled.
|
|
#[serde(rename = "DefaultEnabled")]
|
|
pub default_enabled: bool,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct LibraryOptions {
|
|
#[serde(rename = "Enabled")]
|
|
pub enabled: bool,
|
|
#[serde(rename = "EnablePhotos")]
|
|
pub enable_photos: bool,
|
|
#[serde(rename = "EnableRealtimeMonitor")]
|
|
pub enable_realtime_monitor: bool,
|
|
#[serde(rename = "EnableLUFSScan")]
|
|
pub enable_lufs_scan: bool,
|
|
#[serde(rename = "EnableChapterImageExtraction")]
|
|
pub enable_chapter_image_extraction: bool,
|
|
#[serde(rename = "ExtractChapterImagesDuringLibraryScan")]
|
|
pub extract_chapter_images_during_library_scan: bool,
|
|
#[serde(rename = "EnableTrickplayImageExtraction")]
|
|
pub enable_trickplay_image_extraction: bool,
|
|
#[serde(rename = "ExtractTrickplayImagesDuringLibraryScan")]
|
|
pub extract_trickplay_images_during_library_scan: bool,
|
|
#[serde(rename = "PathInfos")]
|
|
pub path_infos: Vec<MediaPathInfo>,
|
|
#[serde(rename = "SaveLocalMetadata")]
|
|
pub save_local_metadata: bool,
|
|
#[serde(rename = "EnableInternetProviders")]
|
|
pub enable_internet_providers: bool,
|
|
#[serde(rename = "EnableAutomaticSeriesGrouping")]
|
|
pub enable_automatic_series_grouping: bool,
|
|
#[serde(rename = "EnableEmbeddedTitles")]
|
|
pub enable_embedded_titles: bool,
|
|
#[serde(rename = "EnableEmbeddedExtrasTitles")]
|
|
pub enable_embedded_extras_titles: bool,
|
|
#[serde(rename = "EnableEmbeddedEpisodeInfos")]
|
|
pub enable_embedded_episode_infos: bool,
|
|
#[serde(rename = "AutomaticRefreshIntervalDays")]
|
|
pub automatic_refresh_interval_days: i32,
|
|
/// Gets or sets the preferred metadata language.
|
|
#[serde(rename = "PreferredMetadataLanguage")]
|
|
pub preferred_metadata_language: Option<String>,
|
|
/// Gets or sets the metadata country code.
|
|
#[serde(rename = "MetadataCountryCode")]
|
|
pub metadata_country_code: Option<String>,
|
|
#[serde(rename = "SeasonZeroDisplayName")]
|
|
pub season_zero_display_name: String,
|
|
#[serde(rename = "MetadataSavers")]
|
|
pub metadata_savers: Option<Vec<String>>,
|
|
#[serde(rename = "DisabledLocalMetadataReaders")]
|
|
pub disabled_local_metadata_readers: Vec<String>,
|
|
#[serde(rename = "LocalMetadataReaderOrder")]
|
|
pub local_metadata_reader_order: Option<Vec<String>>,
|
|
#[serde(rename = "DisabledSubtitleFetchers")]
|
|
pub disabled_subtitle_fetchers: Vec<String>,
|
|
#[serde(rename = "SubtitleFetcherOrder")]
|
|
pub subtitle_fetcher_order: Vec<String>,
|
|
#[serde(rename = "DisabledMediaSegmentProviders")]
|
|
pub disabled_media_segment_providers: Vec<String>,
|
|
#[serde(rename = "MediaSegmentProvideOrder")]
|
|
pub media_segment_provide_order: Vec<String>,
|
|
#[serde(rename = "SkipSubtitlesIfEmbeddedSubtitlesPresent")]
|
|
pub skip_subtitles_if_embedded_subtitles_present: bool,
|
|
#[serde(rename = "SkipSubtitlesIfAudioTrackMatches")]
|
|
pub skip_subtitles_if_audio_track_matches: bool,
|
|
#[serde(rename = "SubtitleDownloadLanguages")]
|
|
pub subtitle_download_languages: Option<Vec<String>>,
|
|
#[serde(rename = "RequirePerfectSubtitleMatch")]
|
|
pub require_perfect_subtitle_match: bool,
|
|
#[serde(rename = "SaveSubtitlesWithMedia")]
|
|
pub save_subtitles_with_media: bool,
|
|
#[serde(rename = "SaveLyricsWithMedia")]
|
|
pub save_lyrics_with_media: bool,
|
|
#[serde(rename = "SaveTrickplayWithMedia")]
|
|
pub save_trickplay_with_media: bool,
|
|
#[serde(rename = "DisabledLyricFetchers")]
|
|
pub disabled_lyric_fetchers: Vec<String>,
|
|
#[serde(rename = "LyricFetcherOrder")]
|
|
pub lyric_fetcher_order: Vec<String>,
|
|
#[serde(rename = "PreferNonstandardArtistsTag")]
|
|
pub prefer_nonstandard_artists_tag: bool,
|
|
#[serde(rename = "UseCustomTagDelimiters")]
|
|
pub use_custom_tag_delimiters: bool,
|
|
#[serde(rename = "CustomTagDelimiters")]
|
|
pub custom_tag_delimiters: Vec<String>,
|
|
#[serde(rename = "DelimiterWhitelist")]
|
|
pub delimiter_whitelist: Vec<String>,
|
|
#[serde(rename = "AutomaticallyAddToCollection")]
|
|
pub automatically_add_to_collection: bool,
|
|
/// An enum representing the options to disable embedded subs.
|
|
#[serde(rename = "AllowEmbeddedSubtitles")]
|
|
pub allow_embedded_subtitles: EmbeddedSubtitleOptions,
|
|
#[serde(rename = "TypeOptions")]
|
|
pub type_options: Vec<TypeOptions>,
|
|
}
|
|
/// Library options result dto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct LibraryOptionsResultDto {
|
|
/// Gets or sets the metadata savers.
|
|
#[serde(rename = "MetadataSavers")]
|
|
pub metadata_savers: Vec<LibraryOptionInfoDto>,
|
|
/// Gets or sets the metadata readers.
|
|
#[serde(rename = "MetadataReaders")]
|
|
pub metadata_readers: Vec<LibraryOptionInfoDto>,
|
|
/// Gets or sets the subtitle fetchers.
|
|
#[serde(rename = "SubtitleFetchers")]
|
|
pub subtitle_fetchers: Vec<LibraryOptionInfoDto>,
|
|
/// Gets or sets the list of lyric fetchers.
|
|
#[serde(rename = "LyricFetchers")]
|
|
pub lyric_fetchers: Vec<LibraryOptionInfoDto>,
|
|
/// Gets or sets the type options.
|
|
#[serde(rename = "TypeOptions")]
|
|
pub type_options: Vec<LibraryTypeOptionsDto>,
|
|
}
|
|
/// Library type options dto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct LibraryTypeOptionsDto {
|
|
/// Gets or sets the type.
|
|
#[serde(rename = "Type")]
|
|
pub _type: Option<String>,
|
|
/// Gets or sets the metadata fetchers.
|
|
#[serde(rename = "MetadataFetchers")]
|
|
pub metadata_fetchers: Vec<LibraryOptionInfoDto>,
|
|
/// Gets or sets the image fetchers.
|
|
#[serde(rename = "ImageFetchers")]
|
|
pub image_fetchers: Vec<LibraryOptionInfoDto>,
|
|
/// Gets or sets the supported image types.
|
|
#[serde(rename = "SupportedImageTypes")]
|
|
pub supported_image_types: Vec<ImageType>,
|
|
/// Gets or sets the default image options.
|
|
#[serde(rename = "DefaultImageOptions")]
|
|
pub default_image_options: Vec<ImageOption>,
|
|
}
|
|
/// Class LibraryUpdateInfo.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct LibraryUpdateInfo {
|
|
/// Gets or sets the folders added to.
|
|
#[serde(rename = "FoldersAddedTo")]
|
|
pub folders_added_to: Vec<String>,
|
|
/// Gets or sets the folders removed from.
|
|
#[serde(rename = "FoldersRemovedFrom")]
|
|
pub folders_removed_from: Vec<String>,
|
|
/// Gets or sets the items added.
|
|
#[serde(rename = "ItemsAdded")]
|
|
pub items_added: Vec<String>,
|
|
/// Gets or sets the items removed.
|
|
#[serde(rename = "ItemsRemoved")]
|
|
pub items_removed: Vec<String>,
|
|
/// Gets or sets the items updated.
|
|
#[serde(rename = "ItemsUpdated")]
|
|
pub items_updated: Vec<String>,
|
|
#[serde(rename = "CollectionFolders")]
|
|
pub collection_folders: Vec<String>,
|
|
#[serde(rename = "IsEmpty")]
|
|
pub is_empty: bool,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ListingsProviderInfo {
|
|
#[serde(rename = "Id")]
|
|
pub id: Option<String>,
|
|
#[serde(rename = "Type")]
|
|
pub _type: Option<String>,
|
|
#[serde(rename = "Username")]
|
|
pub username: Option<String>,
|
|
#[serde(rename = "Password")]
|
|
pub password: Option<String>,
|
|
#[serde(rename = "ListingsId")]
|
|
pub listings_id: Option<String>,
|
|
#[serde(rename = "ZipCode")]
|
|
pub zip_code: Option<String>,
|
|
#[serde(rename = "Country")]
|
|
pub country: Option<String>,
|
|
#[serde(rename = "Path")]
|
|
pub path: Option<String>,
|
|
#[serde(rename = "EnabledTuners")]
|
|
pub enabled_tuners: Option<Vec<String>>,
|
|
#[serde(rename = "EnableAllTuners")]
|
|
pub enable_all_tuners: bool,
|
|
#[serde(rename = "NewsCategories")]
|
|
pub news_categories: Option<Vec<String>>,
|
|
#[serde(rename = "SportsCategories")]
|
|
pub sports_categories: Option<Vec<String>>,
|
|
#[serde(rename = "KidsCategories")]
|
|
pub kids_categories: Option<Vec<String>>,
|
|
#[serde(rename = "MovieCategories")]
|
|
pub movie_categories: Option<Vec<String>>,
|
|
#[serde(rename = "ChannelMappings")]
|
|
pub channel_mappings: Option<Vec<NameValuePair>>,
|
|
#[serde(rename = "MoviePrefix")]
|
|
pub movie_prefix: Option<String>,
|
|
#[serde(rename = "PreferredLanguage")]
|
|
pub preferred_language: Option<String>,
|
|
#[serde(rename = "UserAgent")]
|
|
pub user_agent: Option<String>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct LiveStreamResponse {
|
|
#[serde(rename = "MediaSource")]
|
|
pub media_source: MediaSourceInfo,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct LiveTvInfo {
|
|
/// Gets or sets the services.
|
|
#[serde(rename = "Services")]
|
|
pub services: Vec<LiveTvServiceInfo>,
|
|
/// Gets or sets a value indicating whether this instance is enabled.
|
|
#[serde(rename = "IsEnabled")]
|
|
pub is_enabled: bool,
|
|
/// Gets or sets the enabled users.
|
|
#[serde(rename = "EnabledUsers")]
|
|
pub enabled_users: Vec<String>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct LiveTvOptions {
|
|
#[serde(rename = "GuideDays")]
|
|
pub guide_days: Option<i32>,
|
|
#[serde(rename = "RecordingPath")]
|
|
pub recording_path: Option<String>,
|
|
#[serde(rename = "MovieRecordingPath")]
|
|
pub movie_recording_path: Option<String>,
|
|
#[serde(rename = "SeriesRecordingPath")]
|
|
pub series_recording_path: Option<String>,
|
|
#[serde(rename = "EnableRecordingSubfolders")]
|
|
pub enable_recording_subfolders: bool,
|
|
#[serde(rename = "EnableOriginalAudioWithEncodedRecordings")]
|
|
pub enable_original_audio_with_encoded_recordings: bool,
|
|
#[serde(rename = "TunerHosts")]
|
|
pub tuner_hosts: Option<Vec<TunerHostInfo>>,
|
|
#[serde(rename = "ListingProviders")]
|
|
pub listing_providers: Option<Vec<ListingsProviderInfo>>,
|
|
#[serde(rename = "PrePaddingSeconds")]
|
|
pub pre_padding_seconds: i32,
|
|
#[serde(rename = "PostPaddingSeconds")]
|
|
pub post_padding_seconds: i32,
|
|
#[serde(rename = "MediaLocationsCreated")]
|
|
pub media_locations_created: Option<Vec<String>>,
|
|
#[serde(rename = "RecordingPostProcessor")]
|
|
pub recording_post_processor: Option<String>,
|
|
#[serde(rename = "RecordingPostProcessorArguments")]
|
|
pub recording_post_processor_arguments: Option<String>,
|
|
#[serde(rename = "SaveRecordingNFO")]
|
|
pub save_recording_nfo: bool,
|
|
#[serde(rename = "SaveRecordingImages")]
|
|
pub save_recording_images: bool,
|
|
}
|
|
/// Class ServiceInfo.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct LiveTvServiceInfo {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the home page URL.
|
|
#[serde(rename = "HomePageUrl")]
|
|
pub home_page_url: Option<String>,
|
|
/// Gets or sets the status.
|
|
#[serde(rename = "Status")]
|
|
pub status: LiveTvServiceStatus,
|
|
/// Gets or sets the status message.
|
|
#[serde(rename = "StatusMessage")]
|
|
pub status_message: Option<String>,
|
|
/// Gets or sets the version.
|
|
#[serde(rename = "Version")]
|
|
pub version: Option<String>,
|
|
/// Gets or sets a value indicating whether this instance has update available.
|
|
#[serde(rename = "HasUpdateAvailable")]
|
|
pub has_update_available: bool,
|
|
/// Gets or sets a value indicating whether this instance is visible.
|
|
#[serde(rename = "IsVisible")]
|
|
pub is_visible: bool,
|
|
#[serde(rename = "Tuners")]
|
|
pub tuners: Option<Vec<String>>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct LocalizationOption {
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
#[serde(rename = "Value")]
|
|
pub value: Option<String>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct LogFile {
|
|
/// Gets or sets the date created.
|
|
#[serde(rename = "DateCreated")]
|
|
pub date_created: jiff::Zoned,
|
|
/// Gets or sets the date modified.
|
|
#[serde(rename = "DateModified")]
|
|
pub date_modified: jiff::Zoned,
|
|
/// Gets or sets the size.
|
|
#[serde(rename = "Size")]
|
|
pub size: i64,
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: String,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct LoginInfoInput {
|
|
#[serde(rename = "Username")]
|
|
pub username: String,
|
|
#[serde(rename = "Password")]
|
|
pub password: String,
|
|
}
|
|
/// LyricResponse model.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct LyricDto {
|
|
/// Gets or sets Metadata for the lyrics.
|
|
#[serde(rename = "Metadata")]
|
|
pub metadata: LyricMetadata,
|
|
/// Gets or sets a collection of individual lyric lines.
|
|
#[serde(rename = "Lyrics")]
|
|
pub lyrics: Vec<LyricLine>,
|
|
}
|
|
/// Lyric model.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct LyricLine {
|
|
/// Gets the text of this lyric line.
|
|
#[serde(rename = "Text")]
|
|
pub text: String,
|
|
/// Gets the start time in ticks.
|
|
#[serde(rename = "Start")]
|
|
pub start: Option<i64>,
|
|
}
|
|
/// LyricMetadata model.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct LyricMetadata {
|
|
/// Gets or sets the song artist.
|
|
#[serde(rename = "Artist")]
|
|
pub artist: Option<String>,
|
|
/// Gets or sets the album this song is on.
|
|
#[serde(rename = "Album")]
|
|
pub album: Option<String>,
|
|
/// Gets or sets the title of the song.
|
|
#[serde(rename = "Title")]
|
|
pub title: Option<String>,
|
|
/// Gets or sets the author of the lyric data.
|
|
#[serde(rename = "Author")]
|
|
pub author: Option<String>,
|
|
/// Gets or sets the length of the song in ticks.
|
|
#[serde(rename = "Length")]
|
|
pub length: Option<i64>,
|
|
/// Gets or sets who the LRC file was created by.
|
|
#[serde(rename = "By")]
|
|
pub by: Option<String>,
|
|
/// Gets or sets the lyric offset compared to audio in ticks.
|
|
#[serde(rename = "Offset")]
|
|
pub offset: Option<i64>,
|
|
/// Gets or sets the software used to create the LRC file.
|
|
#[serde(rename = "Creator")]
|
|
pub creator: Option<String>,
|
|
/// Gets or sets the version of the creator used.
|
|
#[serde(rename = "Version")]
|
|
pub version: Option<String>,
|
|
/// Gets or sets a value indicating whether this lyric is synced.
|
|
#[serde(rename = "IsSynced")]
|
|
pub is_synced: Option<bool>,
|
|
}
|
|
/// Class MediaAttachment.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct MediaAttachment {
|
|
/// Gets or sets the codec.
|
|
#[serde(rename = "Codec")]
|
|
pub codec: Option<String>,
|
|
/// Gets or sets the codec tag.
|
|
#[serde(rename = "CodecTag")]
|
|
pub codec_tag: Option<String>,
|
|
/// Gets or sets the comment.
|
|
#[serde(rename = "Comment")]
|
|
pub comment: Option<String>,
|
|
/// Gets or sets the index.
|
|
#[serde(rename = "Index")]
|
|
pub index: i32,
|
|
/// Gets or sets the filename.
|
|
#[serde(rename = "FileName")]
|
|
pub file_name: Option<String>,
|
|
/// Gets or sets the MIME type.
|
|
#[serde(rename = "MimeType")]
|
|
pub mime_type: Option<String>,
|
|
/// Gets or sets the delivery URL.
|
|
#[serde(rename = "DeliveryUrl")]
|
|
pub delivery_url: Option<String>,
|
|
}
|
|
/// Media Path dto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct MediaPathDto {
|
|
/// Gets or sets the name of the library.
|
|
#[serde(rename = "Name")]
|
|
pub name: String,
|
|
/// Gets or sets the path to add.
|
|
#[serde(rename = "Path")]
|
|
pub path: Option<String>,
|
|
/// Gets or sets the path info.
|
|
#[serde(rename = "PathInfo")]
|
|
pub path_info: Option<MediaPathInfo>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct MediaPathInfo {
|
|
#[serde(rename = "Path")]
|
|
pub path: String,
|
|
}
|
|
/// Api model for MediaSegment's.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct MediaSegmentDto {
|
|
/// Gets or sets the id of the media segment.
|
|
#[serde(rename = "Id")]
|
|
pub id: uuid::Uuid,
|
|
/// Gets or sets the id of the associated item.
|
|
#[serde(rename = "ItemId")]
|
|
pub item_id: uuid::Uuid,
|
|
/// Gets or sets the type of content this segment defines.
|
|
#[serde(rename = "Type")]
|
|
pub _type: MediaSegmentType,
|
|
/// Gets or sets the start of the segment.
|
|
#[serde(rename = "StartTicks")]
|
|
pub start_ticks: i64,
|
|
/// Gets or sets the end of the segment.
|
|
#[serde(rename = "EndTicks")]
|
|
pub end_ticks: i64,
|
|
}
|
|
/// Query result container.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct MediaSegmentDtoQueryResult {
|
|
/// Gets or sets the items.
|
|
#[serde(rename = "Items")]
|
|
pub items: Vec<MediaSegmentDto>,
|
|
/// Gets or sets the total number of records available.
|
|
#[serde(rename = "TotalRecordCount")]
|
|
pub total_record_count: i32,
|
|
/// Gets or sets the index of the first record in Items.
|
|
#[serde(rename = "StartIndex")]
|
|
pub start_index: i32,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct MediaSourceInfo {
|
|
#[serde(rename = "Protocol")]
|
|
pub protocol: MediaProtocol,
|
|
#[serde(rename = "Id")]
|
|
pub id: Option<String>,
|
|
#[serde(rename = "Path")]
|
|
pub path: Option<String>,
|
|
#[serde(rename = "EncoderPath")]
|
|
pub encoder_path: Option<String>,
|
|
#[serde(rename = "EncoderProtocol")]
|
|
pub encoder_protocol: Option<MediaProtocol>,
|
|
#[serde(rename = "Type")]
|
|
pub _type: MediaSourceType,
|
|
#[serde(rename = "Container")]
|
|
pub container: Option<String>,
|
|
#[serde(rename = "Size")]
|
|
pub size: Option<i64>,
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/** Gets or sets a value indicating whether the media is remote.
|
|
Differentiate internet url vs local network.*/
|
|
#[serde(rename = "IsRemote")]
|
|
pub is_remote: bool,
|
|
#[serde(rename = "ETag")]
|
|
pub e_tag: Option<String>,
|
|
#[serde(rename = "RunTimeTicks")]
|
|
pub run_time_ticks: Option<i64>,
|
|
#[serde(rename = "ReadAtNativeFramerate")]
|
|
pub read_at_native_framerate: bool,
|
|
#[serde(rename = "IgnoreDts")]
|
|
pub ignore_dts: bool,
|
|
#[serde(rename = "IgnoreIndex")]
|
|
pub ignore_index: bool,
|
|
#[serde(rename = "GenPtsInput")]
|
|
pub gen_pts_input: bool,
|
|
#[serde(rename = "SupportsTranscoding")]
|
|
pub supports_transcoding: bool,
|
|
#[serde(rename = "SupportsDirectStream")]
|
|
pub supports_direct_stream: bool,
|
|
#[serde(rename = "SupportsDirectPlay")]
|
|
pub supports_direct_play: bool,
|
|
#[serde(rename = "IsInfiniteStream")]
|
|
pub is_infinite_stream: bool,
|
|
#[serde(rename = "UseMostCompatibleTranscodingProfile")]
|
|
pub use_most_compatible_transcoding_profile: bool,
|
|
#[serde(rename = "RequiresOpening")]
|
|
pub requires_opening: bool,
|
|
#[serde(rename = "OpenToken")]
|
|
pub open_token: Option<String>,
|
|
#[serde(rename = "RequiresClosing")]
|
|
pub requires_closing: bool,
|
|
#[serde(rename = "LiveStreamId")]
|
|
pub live_stream_id: Option<String>,
|
|
#[serde(rename = "BufferMs")]
|
|
pub buffer_ms: Option<i32>,
|
|
#[serde(rename = "RequiresLooping")]
|
|
pub requires_looping: bool,
|
|
#[serde(rename = "SupportsProbing")]
|
|
pub supports_probing: bool,
|
|
#[serde(rename = "VideoType")]
|
|
pub video_type: Option<VideoType>,
|
|
#[serde(rename = "IsoType")]
|
|
pub iso_type: Option<IsoType>,
|
|
#[serde(rename = "Video3DFormat")]
|
|
pub video3_d_format: Option<Video3DFormat>,
|
|
#[serde(rename = "MediaStreams")]
|
|
pub media_streams: Option<Vec<MediaStream>>,
|
|
#[serde(rename = "MediaAttachments")]
|
|
pub media_attachments: Option<Vec<MediaAttachment>>,
|
|
#[serde(rename = "Formats")]
|
|
pub formats: Option<Vec<String>>,
|
|
#[serde(rename = "Bitrate")]
|
|
pub bitrate: Option<i32>,
|
|
#[serde(rename = "FallbackMaxStreamingBitrate")]
|
|
pub fallback_max_streaming_bitrate: Option<i32>,
|
|
#[serde(rename = "Timestamp")]
|
|
pub timestamp: Option<TransportStreamTimestamp>,
|
|
#[serde(rename = "RequiredHttpHeaders")]
|
|
pub required_http_headers: Option<std::collections::HashMap<String, Option<String>>>,
|
|
#[serde(rename = "TranscodingUrl")]
|
|
pub transcoding_url: Option<String>,
|
|
/** Media streaming protocol.
|
|
Lowercase for backwards compatibility.*/
|
|
#[serde(rename = "TranscodingSubProtocol")]
|
|
pub transcoding_sub_protocol: MediaStreamProtocol,
|
|
#[serde(rename = "TranscodingContainer")]
|
|
pub transcoding_container: Option<String>,
|
|
#[serde(rename = "AnalyzeDurationMs")]
|
|
pub analyze_duration_ms: Option<i32>,
|
|
#[serde(rename = "DefaultAudioStreamIndex")]
|
|
pub default_audio_stream_index: Option<i32>,
|
|
#[serde(rename = "DefaultSubtitleStreamIndex")]
|
|
pub default_subtitle_stream_index: Option<i32>,
|
|
#[serde(rename = "HasSegments")]
|
|
pub has_segments: bool,
|
|
}
|
|
/// Class MediaStream.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct MediaStream {
|
|
/// Gets or sets the codec.
|
|
#[serde(rename = "Codec")]
|
|
pub codec: Option<String>,
|
|
/// Gets or sets the codec tag.
|
|
#[serde(rename = "CodecTag")]
|
|
pub codec_tag: Option<String>,
|
|
/// Gets or sets the language.
|
|
#[serde(rename = "Language")]
|
|
pub language: Option<String>,
|
|
/// Gets or sets the color range.
|
|
#[serde(rename = "ColorRange")]
|
|
pub color_range: Option<String>,
|
|
/// Gets or sets the color space.
|
|
#[serde(rename = "ColorSpace")]
|
|
pub color_space: Option<String>,
|
|
/// Gets or sets the color transfer.
|
|
#[serde(rename = "ColorTransfer")]
|
|
pub color_transfer: Option<String>,
|
|
/// Gets or sets the color primaries.
|
|
#[serde(rename = "ColorPrimaries")]
|
|
pub color_primaries: Option<String>,
|
|
/// Gets or sets the Dolby Vision version major.
|
|
#[serde(rename = "DvVersionMajor")]
|
|
pub dv_version_major: Option<i32>,
|
|
/// Gets or sets the Dolby Vision version minor.
|
|
#[serde(rename = "DvVersionMinor")]
|
|
pub dv_version_minor: Option<i32>,
|
|
/// Gets or sets the Dolby Vision profile.
|
|
#[serde(rename = "DvProfile")]
|
|
pub dv_profile: Option<i32>,
|
|
/// Gets or sets the Dolby Vision level.
|
|
#[serde(rename = "DvLevel")]
|
|
pub dv_level: Option<i32>,
|
|
/// Gets or sets the Dolby Vision rpu present flag.
|
|
#[serde(rename = "RpuPresentFlag")]
|
|
pub rpu_present_flag: Option<i32>,
|
|
/// Gets or sets the Dolby Vision el present flag.
|
|
#[serde(rename = "ElPresentFlag")]
|
|
pub el_present_flag: Option<i32>,
|
|
/// Gets or sets the Dolby Vision bl present flag.
|
|
#[serde(rename = "BlPresentFlag")]
|
|
pub bl_present_flag: Option<i32>,
|
|
/// Gets or sets the Dolby Vision bl signal compatibility id.
|
|
#[serde(rename = "DvBlSignalCompatibilityId")]
|
|
pub dv_bl_signal_compatibility_id: Option<i32>,
|
|
/// Gets or sets the Rotation in degrees.
|
|
#[serde(rename = "Rotation")]
|
|
pub rotation: Option<i32>,
|
|
/// Gets or sets the comment.
|
|
#[serde(rename = "Comment")]
|
|
pub comment: Option<String>,
|
|
/// Gets or sets the time base.
|
|
#[serde(rename = "TimeBase")]
|
|
pub time_base: Option<String>,
|
|
/// Gets or sets the codec time base.
|
|
#[serde(rename = "CodecTimeBase")]
|
|
pub codec_time_base: Option<String>,
|
|
/// Gets or sets the title.
|
|
#[serde(rename = "Title")]
|
|
pub title: Option<String>,
|
|
/// Gets the video range.
|
|
#[serde(rename = "VideoRange")]
|
|
pub video_range: VideoRange,
|
|
/// Gets the video range type.
|
|
#[serde(rename = "VideoRangeType")]
|
|
pub video_range_type: VideoRangeType,
|
|
/// Gets the video dovi title.
|
|
#[serde(rename = "VideoDoViTitle")]
|
|
pub video_do_vi_title: Option<String>,
|
|
/// Gets the audio spatial format.
|
|
#[serde(rename = "AudioSpatialFormat")]
|
|
pub audio_spatial_format: AudioSpatialFormat,
|
|
#[serde(rename = "LocalizedUndefined")]
|
|
pub localized_undefined: Option<String>,
|
|
#[serde(rename = "LocalizedDefault")]
|
|
pub localized_default: Option<String>,
|
|
#[serde(rename = "LocalizedForced")]
|
|
pub localized_forced: Option<String>,
|
|
#[serde(rename = "LocalizedExternal")]
|
|
pub localized_external: Option<String>,
|
|
#[serde(rename = "LocalizedHearingImpaired")]
|
|
pub localized_hearing_impaired: Option<String>,
|
|
#[serde(rename = "DisplayTitle")]
|
|
pub display_title: Option<String>,
|
|
#[serde(rename = "NalLengthSize")]
|
|
pub nal_length_size: Option<String>,
|
|
/// Gets or sets a value indicating whether this instance is interlaced.
|
|
#[serde(rename = "IsInterlaced")]
|
|
pub is_interlaced: bool,
|
|
#[serde(rename = "IsAVC")]
|
|
pub is_avc: Option<bool>,
|
|
/// Gets or sets the channel layout.
|
|
#[serde(rename = "ChannelLayout")]
|
|
pub channel_layout: Option<String>,
|
|
/// Gets or sets the bit rate.
|
|
#[serde(rename = "BitRate")]
|
|
pub bit_rate: Option<i32>,
|
|
/// Gets or sets the bit depth.
|
|
#[serde(rename = "BitDepth")]
|
|
pub bit_depth: Option<i32>,
|
|
/// Gets or sets the reference frames.
|
|
#[serde(rename = "RefFrames")]
|
|
pub ref_frames: Option<i32>,
|
|
/// Gets or sets the length of the packet.
|
|
#[serde(rename = "PacketLength")]
|
|
pub packet_length: Option<i32>,
|
|
/// Gets or sets the channels.
|
|
#[serde(rename = "Channels")]
|
|
pub channels: Option<i32>,
|
|
/// Gets or sets the sample rate.
|
|
#[serde(rename = "SampleRate")]
|
|
pub sample_rate: Option<i32>,
|
|
/// Gets or sets a value indicating whether this instance is default.
|
|
#[serde(rename = "IsDefault")]
|
|
pub is_default: bool,
|
|
/// Gets or sets a value indicating whether this instance is forced.
|
|
#[serde(rename = "IsForced")]
|
|
pub is_forced: bool,
|
|
/// Gets or sets a value indicating whether this instance is for the hearing impaired.
|
|
#[serde(rename = "IsHearingImpaired")]
|
|
pub is_hearing_impaired: bool,
|
|
/// Gets or sets the height.
|
|
#[serde(rename = "Height")]
|
|
pub height: Option<i32>,
|
|
/// Gets or sets the width.
|
|
#[serde(rename = "Width")]
|
|
pub width: Option<i32>,
|
|
/// Gets or sets the average frame rate.
|
|
#[serde(rename = "AverageFrameRate")]
|
|
pub average_frame_rate: Option<f32>,
|
|
/// Gets or sets the real frame rate.
|
|
#[serde(rename = "RealFrameRate")]
|
|
pub real_frame_rate: Option<f32>,
|
|
/** Gets the framerate used as reference.
|
|
Prefer AverageFrameRate, if that is null or an unrealistic value
|
|
then fallback to RealFrameRate.*/
|
|
#[serde(rename = "ReferenceFrameRate")]
|
|
pub reference_frame_rate: Option<f32>,
|
|
/// Gets or sets the profile.
|
|
#[serde(rename = "Profile")]
|
|
pub profile: Option<String>,
|
|
/// Gets or sets the type.
|
|
#[serde(rename = "Type")]
|
|
pub _type: MediaStreamType,
|
|
/// Gets or sets the aspect ratio.
|
|
#[serde(rename = "AspectRatio")]
|
|
pub aspect_ratio: Option<String>,
|
|
/// Gets or sets the index.
|
|
#[serde(rename = "Index")]
|
|
pub index: i32,
|
|
/// Gets or sets the score.
|
|
#[serde(rename = "Score")]
|
|
pub score: Option<i32>,
|
|
/// Gets or sets a value indicating whether this instance is external.
|
|
#[serde(rename = "IsExternal")]
|
|
pub is_external: bool,
|
|
/// Gets or sets the method.
|
|
#[serde(rename = "DeliveryMethod")]
|
|
pub delivery_method: Option<SubtitleDeliveryMethod>,
|
|
/// Gets or sets the delivery URL.
|
|
#[serde(rename = "DeliveryUrl")]
|
|
pub delivery_url: Option<String>,
|
|
/// Gets or sets a value indicating whether this instance is external URL.
|
|
#[serde(rename = "IsExternalUrl")]
|
|
pub is_external_url: Option<bool>,
|
|
#[serde(rename = "IsTextSubtitleStream")]
|
|
pub is_text_subtitle_stream: bool,
|
|
/// Gets or sets a value indicating whether [supports external stream].
|
|
#[serde(rename = "SupportsExternalStream")]
|
|
pub supports_external_stream: bool,
|
|
/// Gets or sets the filename.
|
|
#[serde(rename = "Path")]
|
|
pub path: Option<String>,
|
|
/// Gets or sets the pixel format.
|
|
#[serde(rename = "PixelFormat")]
|
|
pub pixel_format: Option<String>,
|
|
/// Gets or sets the level.
|
|
#[serde(rename = "Level")]
|
|
pub level: Option<f64>,
|
|
/// Gets or sets whether this instance is anamorphic.
|
|
#[serde(rename = "IsAnamorphic")]
|
|
pub is_anamorphic: Option<bool>,
|
|
}
|
|
/// Media Update Info Dto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct MediaUpdateInfoDto {
|
|
/// Gets or sets the list of updates.
|
|
#[serde(rename = "Updates")]
|
|
pub updates: Vec<MediaUpdateInfoPathDto>,
|
|
}
|
|
/// The media update info path.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct MediaUpdateInfoPathDto {
|
|
/// Gets or sets media path.
|
|
#[serde(rename = "Path")]
|
|
pub path: Option<String>,
|
|
/** Gets or sets media update type.
|
|
Created, Modified, Deleted.*/
|
|
#[serde(rename = "UpdateType")]
|
|
pub update_type: Option<String>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct MediaUrl {
|
|
#[serde(rename = "Url")]
|
|
pub url: Option<String>,
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct MessageCommand {
|
|
#[serde(rename = "Header")]
|
|
pub header: Option<String>,
|
|
#[serde(rename = "Text")]
|
|
pub text: String,
|
|
#[serde(rename = "TimeoutMs")]
|
|
pub timeout_ms: Option<i64>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct MetadataConfiguration {
|
|
#[serde(rename = "UseFileCreationTimeForDateAdded")]
|
|
pub use_file_creation_time_for_date_added: bool,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct MetadataEditorInfo {
|
|
#[serde(rename = "ParentalRatingOptions")]
|
|
pub parental_rating_options: Vec<ParentalRating>,
|
|
#[serde(rename = "Countries")]
|
|
pub countries: Vec<CountryInfo>,
|
|
#[serde(rename = "Cultures")]
|
|
pub cultures: Vec<CultureDto>,
|
|
#[serde(rename = "ExternalIdInfos")]
|
|
pub external_id_infos: Vec<ExternalIdInfo>,
|
|
#[serde(rename = "ContentType")]
|
|
pub content_type: Option<CollectionType>,
|
|
#[serde(rename = "ContentTypeOptions")]
|
|
pub content_type_options: Vec<NameValuePair>,
|
|
}
|
|
/// Class MetadataOptions.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct MetadataOptions {
|
|
#[serde(rename = "ItemType")]
|
|
pub item_type: Option<String>,
|
|
#[serde(rename = "DisabledMetadataSavers")]
|
|
pub disabled_metadata_savers: Option<Vec<String>>,
|
|
#[serde(rename = "LocalMetadataReaderOrder")]
|
|
pub local_metadata_reader_order: Option<Vec<String>>,
|
|
#[serde(rename = "DisabledMetadataFetchers")]
|
|
pub disabled_metadata_fetchers: Option<Vec<String>>,
|
|
#[serde(rename = "MetadataFetcherOrder")]
|
|
pub metadata_fetcher_order: Option<Vec<String>>,
|
|
#[serde(rename = "DisabledImageFetchers")]
|
|
pub disabled_image_fetchers: Option<Vec<String>>,
|
|
#[serde(rename = "ImageFetcherOrder")]
|
|
pub image_fetcher_order: Option<Vec<String>>,
|
|
}
|
|
/// Class MovePlaylistItemRequestDto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct MovePlaylistItemRequestDto {
|
|
/// Gets or sets the playlist identifier of the item.
|
|
#[serde(rename = "PlaylistItemId")]
|
|
pub playlist_item_id: uuid::Uuid,
|
|
/// Gets or sets the new position.
|
|
#[serde(rename = "NewIndex")]
|
|
pub new_index: i32,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct MovieInfo {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the original title.
|
|
#[serde(rename = "OriginalTitle")]
|
|
pub original_title: Option<String>,
|
|
/// Gets or sets the path.
|
|
#[serde(rename = "Path")]
|
|
pub path: Option<String>,
|
|
/// Gets or sets the metadata language.
|
|
#[serde(rename = "MetadataLanguage")]
|
|
pub metadata_language: Option<String>,
|
|
/// Gets or sets the metadata country code.
|
|
#[serde(rename = "MetadataCountryCode")]
|
|
pub metadata_country_code: Option<String>,
|
|
/// Gets or sets the provider ids.
|
|
#[serde(rename = "ProviderIds")]
|
|
pub provider_ids: Option<std::collections::HashMap<String, Option<String>>>,
|
|
/// Gets or sets the year.
|
|
#[serde(rename = "Year")]
|
|
pub year: Option<i32>,
|
|
#[serde(rename = "IndexNumber")]
|
|
pub index_number: Option<i32>,
|
|
#[serde(rename = "ParentIndexNumber")]
|
|
pub parent_index_number: Option<i32>,
|
|
#[serde(rename = "PremiereDate")]
|
|
pub premiere_date: Option<jiff::Zoned>,
|
|
#[serde(rename = "IsAutomated")]
|
|
pub is_automated: bool,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct MovieInfoRemoteSearchQuery {
|
|
#[serde(rename = "SearchInfo")]
|
|
pub search_info: Option<MovieInfo>,
|
|
#[serde(rename = "ItemId")]
|
|
pub item_id: uuid::Uuid,
|
|
/// Gets or sets the provider name to search within if set.
|
|
#[serde(rename = "SearchProviderName")]
|
|
pub search_provider_name: Option<String>,
|
|
/// Gets or sets a value indicating whether disabled providers should be included.
|
|
#[serde(rename = "IncludeDisabledProviders")]
|
|
pub include_disabled_providers: bool,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct MusicVideoInfo {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the original title.
|
|
#[serde(rename = "OriginalTitle")]
|
|
pub original_title: Option<String>,
|
|
/// Gets or sets the path.
|
|
#[serde(rename = "Path")]
|
|
pub path: Option<String>,
|
|
/// Gets or sets the metadata language.
|
|
#[serde(rename = "MetadataLanguage")]
|
|
pub metadata_language: Option<String>,
|
|
/// Gets or sets the metadata country code.
|
|
#[serde(rename = "MetadataCountryCode")]
|
|
pub metadata_country_code: Option<String>,
|
|
/// Gets or sets the provider ids.
|
|
#[serde(rename = "ProviderIds")]
|
|
pub provider_ids: Option<std::collections::HashMap<String, Option<String>>>,
|
|
/// Gets or sets the year.
|
|
#[serde(rename = "Year")]
|
|
pub year: Option<i32>,
|
|
#[serde(rename = "IndexNumber")]
|
|
pub index_number: Option<i32>,
|
|
#[serde(rename = "ParentIndexNumber")]
|
|
pub parent_index_number: Option<i32>,
|
|
#[serde(rename = "PremiereDate")]
|
|
pub premiere_date: Option<jiff::Zoned>,
|
|
#[serde(rename = "IsAutomated")]
|
|
pub is_automated: bool,
|
|
#[serde(rename = "Artists")]
|
|
pub artists: Option<Vec<String>>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct MusicVideoInfoRemoteSearchQuery {
|
|
#[serde(rename = "SearchInfo")]
|
|
pub search_info: Option<MusicVideoInfo>,
|
|
#[serde(rename = "ItemId")]
|
|
pub item_id: uuid::Uuid,
|
|
/// Gets or sets the provider name to search within if set.
|
|
#[serde(rename = "SearchProviderName")]
|
|
pub search_provider_name: Option<String>,
|
|
/// Gets or sets a value indicating whether disabled providers should be included.
|
|
#[serde(rename = "IncludeDisabledProviders")]
|
|
pub include_disabled_providers: bool,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct NameGuidPair {
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
#[serde(rename = "Id")]
|
|
pub id: uuid::Uuid,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct NameIdPair {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the identifier.
|
|
#[serde(rename = "Id")]
|
|
pub id: Option<String>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct NameValuePair {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the value.
|
|
#[serde(rename = "Value")]
|
|
pub value: Option<String>,
|
|
}
|
|
/// Defines the MediaBrowser.Common.Net.NetworkConfiguration.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct NetworkConfiguration {
|
|
/// Gets or sets a value used to specify the URL prefix that your Jellyfin instance can be accessed at.
|
|
#[serde(rename = "BaseUrl")]
|
|
pub base_url: String,
|
|
/// Gets or sets a value indicating whether to use HTTPS.
|
|
#[serde(rename = "EnableHttps")]
|
|
pub enable_https: bool,
|
|
/// Gets or sets a value indicating whether the server should force connections over HTTPS.
|
|
#[serde(rename = "RequireHttps")]
|
|
pub require_https: bool,
|
|
/// Gets or sets the filesystem path of an X.509 certificate to use for SSL.
|
|
#[serde(rename = "CertificatePath")]
|
|
pub certificate_path: String,
|
|
/// Gets or sets the password required to access the X.509 certificate data in the file specified by MediaBrowser.Common.Net.NetworkConfiguration.CertificatePath.
|
|
#[serde(rename = "CertificatePassword")]
|
|
pub certificate_password: String,
|
|
/// Gets or sets the internal HTTP server port.
|
|
#[serde(rename = "InternalHttpPort")]
|
|
pub internal_http_port: i32,
|
|
/// Gets or sets the internal HTTPS server port.
|
|
#[serde(rename = "InternalHttpsPort")]
|
|
pub internal_https_port: i32,
|
|
/// Gets or sets the public HTTP port.
|
|
#[serde(rename = "PublicHttpPort")]
|
|
pub public_http_port: i32,
|
|
/// Gets or sets the public HTTPS port.
|
|
#[serde(rename = "PublicHttpsPort")]
|
|
pub public_https_port: i32,
|
|
/// Gets or sets a value indicating whether Autodiscovery is enabled.
|
|
#[serde(rename = "AutoDiscovery")]
|
|
pub auto_discovery: bool,
|
|
/// Gets or sets a value indicating whether to enable automatic port forwarding.
|
|
#[serde(rename = "EnableUPnP")]
|
|
pub enable_u_pn_p: bool,
|
|
/// Gets or sets a value indicating whether IPv6 is enabled.
|
|
#[serde(rename = "EnableIPv4")]
|
|
pub enable_i_pv4: bool,
|
|
/// Gets or sets a value indicating whether IPv6 is enabled.
|
|
#[serde(rename = "EnableIPv6")]
|
|
pub enable_i_pv6: bool,
|
|
/// Gets or sets a value indicating whether access from outside of the LAN is permitted.
|
|
#[serde(rename = "EnableRemoteAccess")]
|
|
pub enable_remote_access: bool,
|
|
/// Gets or sets the subnets that are deemed to make up the LAN.
|
|
#[serde(rename = "LocalNetworkSubnets")]
|
|
pub local_network_subnets: Vec<String>,
|
|
/// Gets or sets the interface addresses which Jellyfin will bind to. If empty, all interfaces will be used.
|
|
#[serde(rename = "LocalNetworkAddresses")]
|
|
pub local_network_addresses: Vec<String>,
|
|
/// Gets or sets the known proxies.
|
|
#[serde(rename = "KnownProxies")]
|
|
pub known_proxies: Vec<String>,
|
|
/// Gets or sets a value indicating whether address names that match MediaBrowser.Common.Net.NetworkConfiguration.VirtualInterfaceNames should be ignored for the purposes of binding.
|
|
#[serde(rename = "IgnoreVirtualInterfaces")]
|
|
pub ignore_virtual_interfaces: bool,
|
|
/// Gets or sets a value indicating the interface name prefixes that should be ignored. The list can be comma separated and values are case-insensitive. <seealso cref="P:MediaBrowser.Common.Net.NetworkConfiguration.IgnoreVirtualInterfaces" />.
|
|
#[serde(rename = "VirtualInterfaceNames")]
|
|
pub virtual_interface_names: Vec<String>,
|
|
/// Gets or sets a value indicating whether the published server uri is based on information in HTTP requests.
|
|
#[serde(rename = "EnablePublishedServerUriByRequest")]
|
|
pub enable_published_server_uri_by_request: bool,
|
|
/** Gets or sets the PublishedServerUriBySubnet
|
|
Gets or sets PublishedServerUri to advertise for specific subnets.*/
|
|
#[serde(rename = "PublishedServerUriBySubnet")]
|
|
pub published_server_uri_by_subnet: Vec<String>,
|
|
/// Gets or sets the filter for remote IP connectivity. Used in conjunction with <seealso cref="P:MediaBrowser.Common.Net.NetworkConfiguration.IsRemoteIPFilterBlacklist" />.
|
|
#[serde(rename = "RemoteIPFilter")]
|
|
pub remote_ip_filter: Vec<String>,
|
|
/// Gets or sets a value indicating whether <seealso cref="P:MediaBrowser.Common.Net.NetworkConfiguration.RemoteIPFilter" /> contains a blacklist or a whitelist. Default is a whitelist.
|
|
#[serde(rename = "IsRemoteIPFilterBlacklist")]
|
|
pub is_remote_ip_filter_blacklist: bool,
|
|
}
|
|
/// Class NewGroupRequestDto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct NewGroupRequestDto {
|
|
/// Gets or sets the group name.
|
|
#[serde(rename = "GroupName")]
|
|
pub group_name: String,
|
|
}
|
|
/// Class NextItemRequestDto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct NextItemRequestDto {
|
|
/// Gets or sets the playing item identifier.
|
|
#[serde(rename = "PlaylistItemId")]
|
|
pub playlist_item_id: uuid::Uuid,
|
|
}
|
|
/// Open live stream dto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct OpenLiveStreamDto {
|
|
/// Gets or sets the open token.
|
|
#[serde(rename = "OpenToken")]
|
|
pub open_token: Option<String>,
|
|
/// Gets or sets the user id.
|
|
#[serde(rename = "UserId")]
|
|
pub user_id: Option<uuid::Uuid>,
|
|
/// Gets or sets the play session id.
|
|
#[serde(rename = "PlaySessionId")]
|
|
pub play_session_id: Option<String>,
|
|
/// Gets or sets the max streaming bitrate.
|
|
#[serde(rename = "MaxStreamingBitrate")]
|
|
pub max_streaming_bitrate: Option<i32>,
|
|
/// Gets or sets the start time in ticks.
|
|
#[serde(rename = "StartTimeTicks")]
|
|
pub start_time_ticks: Option<i64>,
|
|
/// Gets or sets the audio stream index.
|
|
#[serde(rename = "AudioStreamIndex")]
|
|
pub audio_stream_index: Option<i32>,
|
|
/// Gets or sets the subtitle stream index.
|
|
#[serde(rename = "SubtitleStreamIndex")]
|
|
pub subtitle_stream_index: Option<i32>,
|
|
/// Gets or sets the max audio channels.
|
|
#[serde(rename = "MaxAudioChannels")]
|
|
pub max_audio_channels: Option<i32>,
|
|
/// Gets or sets the item id.
|
|
#[serde(rename = "ItemId")]
|
|
pub item_id: Option<uuid::Uuid>,
|
|
/// Gets or sets a value indicating whether to enable direct play.
|
|
#[serde(rename = "EnableDirectPlay")]
|
|
pub enable_direct_play: Option<bool>,
|
|
/// Gets or sets a value indicating whether to enale direct stream.
|
|
#[serde(rename = "EnableDirectStream")]
|
|
pub enable_direct_stream: Option<bool>,
|
|
/// Gets or sets a value indicating whether always burn in subtitles when transcoding.
|
|
#[serde(rename = "AlwaysBurnInSubtitleWhenTranscoding")]
|
|
pub always_burn_in_subtitle_when_transcoding: Option<bool>,
|
|
/** A MediaBrowser.Model.Dlna.DeviceProfile represents a set of metadata which determines which content a certain device is able to play.
|
|
<br />
|
|
Specifically, it defines the supported <see cref="P:MediaBrowser.Model.Dlna.DeviceProfile.ContainerProfiles">containers</see> and
|
|
<see cref="P:MediaBrowser.Model.Dlna.DeviceProfile.CodecProfiles">codecs</see> (video and/or audio, including codec profiles and levels)
|
|
the device is able to direct play (without transcoding or remuxing),
|
|
as well as which <see cref="P:MediaBrowser.Model.Dlna.DeviceProfile.TranscodingProfiles">containers/codecs to transcode to</see> in case it isn't.*/
|
|
#[serde(rename = "DeviceProfile")]
|
|
pub device_profile: Option<DeviceProfile>,
|
|
/// Gets or sets the device play protocols.
|
|
#[serde(rename = "DirectPlayProtocols")]
|
|
pub direct_play_protocols: Vec<MediaProtocol>,
|
|
}
|
|
/// Keep alive websocket messages.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct OutboundKeepAliveMessage {
|
|
/// Gets or sets the message id.
|
|
#[serde(rename = "MessageId")]
|
|
pub message_id: uuid::Uuid,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Class PackageInfo.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PackageInfo {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "name")]
|
|
pub name: String,
|
|
/// Gets or sets a long description of the plugin containing features or helpful explanations.
|
|
#[serde(rename = "description")]
|
|
pub description: String,
|
|
/// Gets or sets a short overview of what the plugin does.
|
|
#[serde(rename = "overview")]
|
|
pub overview: String,
|
|
/// Gets or sets the owner.
|
|
#[serde(rename = "owner")]
|
|
pub owner: String,
|
|
/// Gets or sets the category.
|
|
#[serde(rename = "category")]
|
|
pub category: String,
|
|
/** Gets or sets the guid of the assembly associated with this plugin.
|
|
This is used to identify the proper item for automatic updates.*/
|
|
#[serde(rename = "guid")]
|
|
pub guid: uuid::Uuid,
|
|
/// Gets or sets the versions.
|
|
#[serde(rename = "versions")]
|
|
pub versions: Vec<VersionInfo>,
|
|
/// Gets or sets the image url for the package.
|
|
#[serde(rename = "imageUrl")]
|
|
pub image_url: Option<String>,
|
|
}
|
|
/// Class ParentalRating.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ParentalRating {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the value.
|
|
#[serde(rename = "Value")]
|
|
pub value: Option<i32>,
|
|
}
|
|
/// Defines the MediaBrowser.Model.Configuration.PathSubstitution.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PathSubstitution {
|
|
/// Gets or sets the value to substitute.
|
|
#[serde(rename = "From")]
|
|
pub from: String,
|
|
/// Gets or sets the value to substitution with.
|
|
#[serde(rename = "To")]
|
|
pub to: String,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PersonLookupInfo {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the original title.
|
|
#[serde(rename = "OriginalTitle")]
|
|
pub original_title: Option<String>,
|
|
/// Gets or sets the path.
|
|
#[serde(rename = "Path")]
|
|
pub path: Option<String>,
|
|
/// Gets or sets the metadata language.
|
|
#[serde(rename = "MetadataLanguage")]
|
|
pub metadata_language: Option<String>,
|
|
/// Gets or sets the metadata country code.
|
|
#[serde(rename = "MetadataCountryCode")]
|
|
pub metadata_country_code: Option<String>,
|
|
/// Gets or sets the provider ids.
|
|
#[serde(rename = "ProviderIds")]
|
|
pub provider_ids: Option<std::collections::HashMap<String, Option<String>>>,
|
|
/// Gets or sets the year.
|
|
#[serde(rename = "Year")]
|
|
pub year: Option<i32>,
|
|
#[serde(rename = "IndexNumber")]
|
|
pub index_number: Option<i32>,
|
|
#[serde(rename = "ParentIndexNumber")]
|
|
pub parent_index_number: Option<i32>,
|
|
#[serde(rename = "PremiereDate")]
|
|
pub premiere_date: Option<jiff::Zoned>,
|
|
#[serde(rename = "IsAutomated")]
|
|
pub is_automated: bool,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PersonLookupInfoRemoteSearchQuery {
|
|
#[serde(rename = "SearchInfo")]
|
|
pub search_info: Option<PersonLookupInfo>,
|
|
#[serde(rename = "ItemId")]
|
|
pub item_id: uuid::Uuid,
|
|
/// Gets or sets the provider name to search within if set.
|
|
#[serde(rename = "SearchProviderName")]
|
|
pub search_provider_name: Option<String>,
|
|
/// Gets or sets a value indicating whether disabled providers should be included.
|
|
#[serde(rename = "IncludeDisabledProviders")]
|
|
pub include_disabled_providers: bool,
|
|
}
|
|
/// Class PingRequestDto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PingRequestDto {
|
|
/// Gets or sets the ping time.
|
|
#[serde(rename = "Ping")]
|
|
pub ping: i64,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PinRedeemResult {
|
|
/// Gets or sets a value indicating whether this MediaBrowser.Model.Users.PinRedeemResult is success.
|
|
#[serde(rename = "Success")]
|
|
pub success: bool,
|
|
/// Gets or sets the users reset.
|
|
#[serde(rename = "UsersReset")]
|
|
pub users_reset: Vec<String>,
|
|
}
|
|
/// Plabyback info dto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PlaybackInfoDto {
|
|
/// Gets or sets the playback userId.
|
|
#[serde(rename = "UserId")]
|
|
pub user_id: Option<uuid::Uuid>,
|
|
/// Gets or sets the max streaming bitrate.
|
|
#[serde(rename = "MaxStreamingBitrate")]
|
|
pub max_streaming_bitrate: Option<i32>,
|
|
/// Gets or sets the start time in ticks.
|
|
#[serde(rename = "StartTimeTicks")]
|
|
pub start_time_ticks: Option<i64>,
|
|
/// Gets or sets the audio stream index.
|
|
#[serde(rename = "AudioStreamIndex")]
|
|
pub audio_stream_index: Option<i32>,
|
|
/// Gets or sets the subtitle stream index.
|
|
#[serde(rename = "SubtitleStreamIndex")]
|
|
pub subtitle_stream_index: Option<i32>,
|
|
/// Gets or sets the max audio channels.
|
|
#[serde(rename = "MaxAudioChannels")]
|
|
pub max_audio_channels: Option<i32>,
|
|
/// Gets or sets the media source id.
|
|
#[serde(rename = "MediaSourceId")]
|
|
pub media_source_id: Option<String>,
|
|
/// Gets or sets the live stream id.
|
|
#[serde(rename = "LiveStreamId")]
|
|
pub live_stream_id: Option<String>,
|
|
/** A MediaBrowser.Model.Dlna.DeviceProfile represents a set of metadata which determines which content a certain device is able to play.
|
|
<br />
|
|
Specifically, it defines the supported <see cref="P:MediaBrowser.Model.Dlna.DeviceProfile.ContainerProfiles">containers</see> and
|
|
<see cref="P:MediaBrowser.Model.Dlna.DeviceProfile.CodecProfiles">codecs</see> (video and/or audio, including codec profiles and levels)
|
|
the device is able to direct play (without transcoding or remuxing),
|
|
as well as which <see cref="P:MediaBrowser.Model.Dlna.DeviceProfile.TranscodingProfiles">containers/codecs to transcode to</see> in case it isn't.*/
|
|
#[serde(rename = "DeviceProfile")]
|
|
pub device_profile: Option<DeviceProfile>,
|
|
/// Gets or sets a value indicating whether to enable direct play.
|
|
#[serde(rename = "EnableDirectPlay")]
|
|
pub enable_direct_play: Option<bool>,
|
|
/// Gets or sets a value indicating whether to enable direct stream.
|
|
#[serde(rename = "EnableDirectStream")]
|
|
pub enable_direct_stream: Option<bool>,
|
|
/// Gets or sets a value indicating whether to enable transcoding.
|
|
#[serde(rename = "EnableTranscoding")]
|
|
pub enable_transcoding: Option<bool>,
|
|
/// Gets or sets a value indicating whether to enable video stream copy.
|
|
#[serde(rename = "AllowVideoStreamCopy")]
|
|
pub allow_video_stream_copy: Option<bool>,
|
|
/// Gets or sets a value indicating whether to allow audio stream copy.
|
|
#[serde(rename = "AllowAudioStreamCopy")]
|
|
pub allow_audio_stream_copy: Option<bool>,
|
|
/// Gets or sets a value indicating whether to auto open the live stream.
|
|
#[serde(rename = "AutoOpenLiveStream")]
|
|
pub auto_open_live_stream: Option<bool>,
|
|
/// Gets or sets a value indicating whether always burn in subtitles when transcoding.
|
|
#[serde(rename = "AlwaysBurnInSubtitleWhenTranscoding")]
|
|
pub always_burn_in_subtitle_when_transcoding: Option<bool>,
|
|
}
|
|
/// Class PlaybackInfoResponse.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PlaybackInfoResponse {
|
|
/// Gets or sets the media sources.
|
|
#[serde(rename = "MediaSources")]
|
|
pub media_sources: Vec<MediaSourceInfo>,
|
|
/// Gets or sets the play session identifier.
|
|
#[serde(rename = "PlaySessionId")]
|
|
pub play_session_id: Option<String>,
|
|
/// Gets or sets the error code.
|
|
#[serde(rename = "ErrorCode")]
|
|
pub error_code: Option<PlaybackErrorCode>,
|
|
}
|
|
/// Class PlaybackProgressInfo.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PlaybackProgressInfo {
|
|
/// Gets or sets a value indicating whether this instance can seek.
|
|
#[serde(rename = "CanSeek")]
|
|
pub can_seek: bool,
|
|
/// Gets or sets the item.
|
|
#[serde(rename = "Item")]
|
|
pub item: Option<BaseItemDto>,
|
|
/// Gets or sets the item identifier.
|
|
#[serde(rename = "ItemId")]
|
|
pub item_id: uuid::Uuid,
|
|
/// Gets or sets the session id.
|
|
#[serde(rename = "SessionId")]
|
|
pub session_id: Option<String>,
|
|
/// Gets or sets the media version identifier.
|
|
#[serde(rename = "MediaSourceId")]
|
|
pub media_source_id: Option<String>,
|
|
/// Gets or sets the index of the audio stream.
|
|
#[serde(rename = "AudioStreamIndex")]
|
|
pub audio_stream_index: Option<i32>,
|
|
/// Gets or sets the index of the subtitle stream.
|
|
#[serde(rename = "SubtitleStreamIndex")]
|
|
pub subtitle_stream_index: Option<i32>,
|
|
/// Gets or sets a value indicating whether this instance is paused.
|
|
#[serde(rename = "IsPaused")]
|
|
pub is_paused: bool,
|
|
/// Gets or sets a value indicating whether this instance is muted.
|
|
#[serde(rename = "IsMuted")]
|
|
pub is_muted: bool,
|
|
/// Gets or sets the position ticks.
|
|
#[serde(rename = "PositionTicks")]
|
|
pub position_ticks: Option<i64>,
|
|
#[serde(rename = "PlaybackStartTimeTicks")]
|
|
pub playback_start_time_ticks: Option<i64>,
|
|
/// Gets or sets the volume level.
|
|
#[serde(rename = "VolumeLevel")]
|
|
pub volume_level: Option<i32>,
|
|
#[serde(rename = "Brightness")]
|
|
pub brightness: Option<i32>,
|
|
#[serde(rename = "AspectRatio")]
|
|
pub aspect_ratio: Option<String>,
|
|
/// Gets or sets the play method.
|
|
#[serde(rename = "PlayMethod")]
|
|
pub play_method: PlayMethod,
|
|
/// Gets or sets the live stream identifier.
|
|
#[serde(rename = "LiveStreamId")]
|
|
pub live_stream_id: Option<String>,
|
|
/// Gets or sets the play session identifier.
|
|
#[serde(rename = "PlaySessionId")]
|
|
pub play_session_id: Option<String>,
|
|
/// Gets or sets the repeat mode.
|
|
#[serde(rename = "RepeatMode")]
|
|
pub repeat_mode: RepeatMode,
|
|
/// Gets or sets the playback order.
|
|
#[serde(rename = "PlaybackOrder")]
|
|
pub playback_order: PlaybackOrder,
|
|
#[serde(rename = "NowPlayingQueue")]
|
|
pub now_playing_queue: Option<Vec<QueueItem>>,
|
|
#[serde(rename = "PlaylistItemId")]
|
|
pub playlist_item_id: Option<String>,
|
|
}
|
|
/// Class PlaybackStartInfo.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PlaybackStartInfo {
|
|
/// Gets or sets a value indicating whether this instance can seek.
|
|
#[serde(rename = "CanSeek")]
|
|
pub can_seek: bool,
|
|
/// Gets or sets the item.
|
|
#[serde(rename = "Item")]
|
|
pub item: Option<BaseItemDto>,
|
|
/// Gets or sets the item identifier.
|
|
#[serde(rename = "ItemId")]
|
|
pub item_id: uuid::Uuid,
|
|
/// Gets or sets the session id.
|
|
#[serde(rename = "SessionId")]
|
|
pub session_id: Option<String>,
|
|
/// Gets or sets the media version identifier.
|
|
#[serde(rename = "MediaSourceId")]
|
|
pub media_source_id: Option<String>,
|
|
/// Gets or sets the index of the audio stream.
|
|
#[serde(rename = "AudioStreamIndex")]
|
|
pub audio_stream_index: Option<i32>,
|
|
/// Gets or sets the index of the subtitle stream.
|
|
#[serde(rename = "SubtitleStreamIndex")]
|
|
pub subtitle_stream_index: Option<i32>,
|
|
/// Gets or sets a value indicating whether this instance is paused.
|
|
#[serde(rename = "IsPaused")]
|
|
pub is_paused: bool,
|
|
/// Gets or sets a value indicating whether this instance is muted.
|
|
#[serde(rename = "IsMuted")]
|
|
pub is_muted: bool,
|
|
/// Gets or sets the position ticks.
|
|
#[serde(rename = "PositionTicks")]
|
|
pub position_ticks: Option<i64>,
|
|
#[serde(rename = "PlaybackStartTimeTicks")]
|
|
pub playback_start_time_ticks: Option<i64>,
|
|
/// Gets or sets the volume level.
|
|
#[serde(rename = "VolumeLevel")]
|
|
pub volume_level: Option<i32>,
|
|
#[serde(rename = "Brightness")]
|
|
pub brightness: Option<i32>,
|
|
#[serde(rename = "AspectRatio")]
|
|
pub aspect_ratio: Option<String>,
|
|
/// Gets or sets the play method.
|
|
#[serde(rename = "PlayMethod")]
|
|
pub play_method: PlayMethod,
|
|
/// Gets or sets the live stream identifier.
|
|
#[serde(rename = "LiveStreamId")]
|
|
pub live_stream_id: Option<String>,
|
|
/// Gets or sets the play session identifier.
|
|
#[serde(rename = "PlaySessionId")]
|
|
pub play_session_id: Option<String>,
|
|
/// Gets or sets the repeat mode.
|
|
#[serde(rename = "RepeatMode")]
|
|
pub repeat_mode: RepeatMode,
|
|
/// Gets or sets the playback order.
|
|
#[serde(rename = "PlaybackOrder")]
|
|
pub playback_order: PlaybackOrder,
|
|
#[serde(rename = "NowPlayingQueue")]
|
|
pub now_playing_queue: Option<Vec<QueueItem>>,
|
|
#[serde(rename = "PlaylistItemId")]
|
|
pub playlist_item_id: Option<String>,
|
|
}
|
|
/// Class PlaybackStopInfo.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PlaybackStopInfo {
|
|
/// Gets or sets the item.
|
|
#[serde(rename = "Item")]
|
|
pub item: Option<BaseItemDto>,
|
|
/// Gets or sets the item identifier.
|
|
#[serde(rename = "ItemId")]
|
|
pub item_id: uuid::Uuid,
|
|
/// Gets or sets the session id.
|
|
#[serde(rename = "SessionId")]
|
|
pub session_id: Option<String>,
|
|
/// Gets or sets the media version identifier.
|
|
#[serde(rename = "MediaSourceId")]
|
|
pub media_source_id: Option<String>,
|
|
/// Gets or sets the position ticks.
|
|
#[serde(rename = "PositionTicks")]
|
|
pub position_ticks: Option<i64>,
|
|
/// Gets or sets the live stream identifier.
|
|
#[serde(rename = "LiveStreamId")]
|
|
pub live_stream_id: Option<String>,
|
|
/// Gets or sets the play session identifier.
|
|
#[serde(rename = "PlaySessionId")]
|
|
pub play_session_id: Option<String>,
|
|
/// Gets or sets a value indicating whether this MediaBrowser.Model.Session.PlaybackStopInfo is failed.
|
|
#[serde(rename = "Failed")]
|
|
pub failed: bool,
|
|
#[serde(rename = "NextMediaType")]
|
|
pub next_media_type: Option<String>,
|
|
#[serde(rename = "PlaylistItemId")]
|
|
pub playlist_item_id: Option<String>,
|
|
#[serde(rename = "NowPlayingQueue")]
|
|
pub now_playing_queue: Option<Vec<QueueItem>>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PlayerStateInfo {
|
|
/// Gets or sets the now playing position ticks.
|
|
#[serde(rename = "PositionTicks")]
|
|
pub position_ticks: Option<i64>,
|
|
/// Gets or sets a value indicating whether this instance can seek.
|
|
#[serde(rename = "CanSeek")]
|
|
pub can_seek: bool,
|
|
/// Gets or sets a value indicating whether this instance is paused.
|
|
#[serde(rename = "IsPaused")]
|
|
pub is_paused: bool,
|
|
/// Gets or sets a value indicating whether this instance is muted.
|
|
#[serde(rename = "IsMuted")]
|
|
pub is_muted: bool,
|
|
/// Gets or sets the volume level.
|
|
#[serde(rename = "VolumeLevel")]
|
|
pub volume_level: Option<i32>,
|
|
/// Gets or sets the index of the now playing audio stream.
|
|
#[serde(rename = "AudioStreamIndex")]
|
|
pub audio_stream_index: Option<i32>,
|
|
/// Gets or sets the index of the now playing subtitle stream.
|
|
#[serde(rename = "SubtitleStreamIndex")]
|
|
pub subtitle_stream_index: Option<i32>,
|
|
/// Gets or sets the now playing media version identifier.
|
|
#[serde(rename = "MediaSourceId")]
|
|
pub media_source_id: Option<String>,
|
|
/// Gets or sets the play method.
|
|
#[serde(rename = "PlayMethod")]
|
|
pub play_method: Option<PlayMethod>,
|
|
/// Gets or sets the repeat mode.
|
|
#[serde(rename = "RepeatMode")]
|
|
pub repeat_mode: RepeatMode,
|
|
/// Gets or sets the playback order.
|
|
#[serde(rename = "PlaybackOrder")]
|
|
pub playback_order: PlaybackOrder,
|
|
/// Gets or sets the now playing live stream identifier.
|
|
#[serde(rename = "LiveStreamId")]
|
|
pub live_stream_id: Option<String>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PlaylistCreationResult {
|
|
#[serde(rename = "Id")]
|
|
pub id: String,
|
|
}
|
|
/// DTO for playlists.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PlaylistDto {
|
|
/// Gets or sets a value indicating whether the playlist is publicly readable.
|
|
#[serde(rename = "OpenAccess")]
|
|
pub open_access: bool,
|
|
/// Gets or sets the share permissions.
|
|
#[serde(rename = "Shares")]
|
|
pub shares: Vec<PlaylistUserPermissions>,
|
|
/// Gets or sets the item ids.
|
|
#[serde(rename = "ItemIds")]
|
|
pub item_ids: Vec<uuid::Uuid>,
|
|
}
|
|
/// Class to hold data on user permissions for playlists.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PlaylistUserPermissions {
|
|
/// Gets or sets the user id.
|
|
#[serde(rename = "UserId")]
|
|
pub user_id: uuid::Uuid,
|
|
/// Gets or sets a value indicating whether the user has edit permissions.
|
|
#[serde(rename = "CanEdit")]
|
|
pub can_edit: bool,
|
|
}
|
|
/// Play command websocket message.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PlayMessage {
|
|
/// Class PlayRequest.
|
|
#[serde(rename = "Data")]
|
|
pub data: Option<PlayRequest>,
|
|
/// Gets or sets the message id.
|
|
#[serde(rename = "MessageId")]
|
|
pub message_id: uuid::Uuid,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Class PlayQueueUpdate.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PlayQueueUpdate {
|
|
/// Gets the request type that originated this update.
|
|
#[serde(rename = "Reason")]
|
|
pub reason: PlayQueueUpdateReason,
|
|
/// Gets the UTC time of the last change to the playing queue.
|
|
#[serde(rename = "LastUpdate")]
|
|
pub last_update: jiff::Zoned,
|
|
/// Gets the playlist.
|
|
#[serde(rename = "Playlist")]
|
|
pub playlist: Vec<SyncPlayQueueItem>,
|
|
/// Gets the playing item index in the playlist.
|
|
#[serde(rename = "PlayingItemIndex")]
|
|
pub playing_item_index: i32,
|
|
/// Gets the start position ticks.
|
|
#[serde(rename = "StartPositionTicks")]
|
|
pub start_position_ticks: i64,
|
|
/// Gets a value indicating whether the current item is playing.
|
|
#[serde(rename = "IsPlaying")]
|
|
pub is_playing: bool,
|
|
/// Gets the shuffle mode.
|
|
#[serde(rename = "ShuffleMode")]
|
|
pub shuffle_mode: GroupShuffleMode,
|
|
/// Gets the repeat mode.
|
|
#[serde(rename = "RepeatMode")]
|
|
pub repeat_mode: GroupRepeatMode,
|
|
}
|
|
/// Class GroupUpdate.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PlayQueueUpdateGroupUpdate {
|
|
/// Gets the group identifier.
|
|
#[serde(rename = "GroupId")]
|
|
pub group_id: uuid::Uuid,
|
|
/// Gets the update type.
|
|
#[serde(rename = "Type")]
|
|
pub _type: GroupUpdateType,
|
|
/// Gets the update data.
|
|
#[serde(rename = "Data")]
|
|
pub data: PlayQueueUpdate,
|
|
}
|
|
/// Class PlayRequest.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PlayRequest {
|
|
/// Gets or sets the item ids.
|
|
#[serde(rename = "ItemIds")]
|
|
pub item_ids: Option<Vec<uuid::Uuid>>,
|
|
/// Gets or sets the start position ticks that the first item should be played at.
|
|
#[serde(rename = "StartPositionTicks")]
|
|
pub start_position_ticks: Option<i64>,
|
|
/// Gets or sets the play command.
|
|
#[serde(rename = "PlayCommand")]
|
|
pub play_command: PlayCommand,
|
|
/// Gets or sets the controlling user identifier.
|
|
#[serde(rename = "ControllingUserId")]
|
|
pub controlling_user_id: uuid::Uuid,
|
|
#[serde(rename = "SubtitleStreamIndex")]
|
|
pub subtitle_stream_index: Option<i32>,
|
|
#[serde(rename = "AudioStreamIndex")]
|
|
pub audio_stream_index: Option<i32>,
|
|
#[serde(rename = "MediaSourceId")]
|
|
pub media_source_id: Option<String>,
|
|
#[serde(rename = "StartIndex")]
|
|
pub start_index: Option<i32>,
|
|
}
|
|
/// Class PlayRequestDto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PlayRequestDto {
|
|
/// Gets or sets the playing queue.
|
|
#[serde(rename = "PlayingQueue")]
|
|
pub playing_queue: Vec<uuid::Uuid>,
|
|
/// Gets or sets the position of the playing item in the queue.
|
|
#[serde(rename = "PlayingItemPosition")]
|
|
pub playing_item_position: i32,
|
|
/// Gets or sets the start position ticks.
|
|
#[serde(rename = "StartPositionTicks")]
|
|
pub start_position_ticks: i64,
|
|
}
|
|
/// Playstate message.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PlaystateMessage {
|
|
/// Gets or sets the data.
|
|
#[serde(rename = "Data")]
|
|
pub data: Option<PlaystateRequest>,
|
|
/// Gets or sets the message id.
|
|
#[serde(rename = "MessageId")]
|
|
pub message_id: uuid::Uuid,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PlaystateRequest {
|
|
/// Enum PlaystateCommand.
|
|
#[serde(rename = "Command")]
|
|
pub command: PlaystateCommand,
|
|
#[serde(rename = "SeekPositionTicks")]
|
|
pub seek_position_ticks: Option<i64>,
|
|
/// Gets or sets the controlling user identifier.
|
|
#[serde(rename = "ControllingUserId")]
|
|
pub controlling_user_id: Option<String>,
|
|
}
|
|
/// This is a serializable stub class that is used by the api to provide information about installed plugins.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PluginInfo {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: String,
|
|
/// Gets or sets the version.
|
|
#[serde(rename = "Version")]
|
|
pub version: String,
|
|
/// Gets or sets the name of the configuration file.
|
|
#[serde(rename = "ConfigurationFileName")]
|
|
pub configuration_file_name: Option<String>,
|
|
/// Gets or sets the description.
|
|
#[serde(rename = "Description")]
|
|
pub description: String,
|
|
/// Gets or sets the unique id.
|
|
#[serde(rename = "Id")]
|
|
pub id: uuid::Uuid,
|
|
/// Gets or sets a value indicating whether the plugin can be uninstalled.
|
|
#[serde(rename = "CanUninstall")]
|
|
pub can_uninstall: bool,
|
|
/// Gets or sets a value indicating whether this plugin has a valid image.
|
|
#[serde(rename = "HasImage")]
|
|
pub has_image: bool,
|
|
/// Gets or sets a value indicating the status of the plugin.
|
|
#[serde(rename = "Status")]
|
|
pub status: PluginStatus,
|
|
}
|
|
/// Plugin installation cancelled message.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PluginInstallationCancelledMessage {
|
|
/// Class InstallationInfo.
|
|
#[serde(rename = "Data")]
|
|
pub data: Option<InstallationInfo>,
|
|
/// Gets or sets the message id.
|
|
#[serde(rename = "MessageId")]
|
|
pub message_id: uuid::Uuid,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Plugin installation completed message.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PluginInstallationCompletedMessage {
|
|
/// Class InstallationInfo.
|
|
#[serde(rename = "Data")]
|
|
pub data: Option<InstallationInfo>,
|
|
/// Gets or sets the message id.
|
|
#[serde(rename = "MessageId")]
|
|
pub message_id: uuid::Uuid,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Plugin installation failed message.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PluginInstallationFailedMessage {
|
|
/// Class InstallationInfo.
|
|
#[serde(rename = "Data")]
|
|
pub data: Option<InstallationInfo>,
|
|
/// Gets or sets the message id.
|
|
#[serde(rename = "MessageId")]
|
|
pub message_id: uuid::Uuid,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Package installing message.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PluginInstallingMessage {
|
|
/// Class InstallationInfo.
|
|
#[serde(rename = "Data")]
|
|
pub data: Option<InstallationInfo>,
|
|
/// Gets or sets the message id.
|
|
#[serde(rename = "MessageId")]
|
|
pub message_id: uuid::Uuid,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Plugin uninstalled message.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PluginUninstalledMessage {
|
|
/// This is a serializable stub class that is used by the api to provide information about installed plugins.
|
|
#[serde(rename = "Data")]
|
|
pub data: Option<PluginInfo>,
|
|
/// Gets or sets the message id.
|
|
#[serde(rename = "MessageId")]
|
|
pub message_id: uuid::Uuid,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Class PreviousItemRequestDto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PreviousItemRequestDto {
|
|
/// Gets or sets the playing item identifier.
|
|
#[serde(rename = "PlaylistItemId")]
|
|
pub playlist_item_id: uuid::Uuid,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ProblemDetails {
|
|
#[serde(rename = "type")]
|
|
pub _type: Option<String>,
|
|
#[serde(rename = "title")]
|
|
pub title: Option<String>,
|
|
#[serde(rename = "status")]
|
|
pub status: Option<i32>,
|
|
#[serde(rename = "detail")]
|
|
pub detail: Option<String>,
|
|
#[serde(rename = "instance")]
|
|
pub instance: Option<String>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ProfileCondition {
|
|
#[serde(rename = "Condition")]
|
|
pub condition: ProfileConditionType,
|
|
#[serde(rename = "Property")]
|
|
pub property: ProfileConditionValue,
|
|
#[serde(rename = "Value")]
|
|
pub value: Option<String>,
|
|
#[serde(rename = "IsRequired")]
|
|
pub is_required: bool,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct PublicSystemInfo {
|
|
/// Gets or sets the local address.
|
|
#[serde(rename = "LocalAddress")]
|
|
pub local_address: Option<String>,
|
|
/// Gets or sets the name of the server.
|
|
#[serde(rename = "ServerName")]
|
|
pub server_name: Option<String>,
|
|
/// Gets or sets the server version.
|
|
#[serde(rename = "Version")]
|
|
pub version: Option<String>,
|
|
/// Gets or sets the product name. This is the AssemblyProduct name.
|
|
#[serde(rename = "ProductName")]
|
|
pub product_name: Option<String>,
|
|
/// Gets or sets the operating system.
|
|
#[serde(rename = "OperatingSystem")]
|
|
pub operating_system: Option<String>,
|
|
/// Gets or sets the id.
|
|
#[serde(rename = "Id")]
|
|
pub id: Option<String>,
|
|
/// Gets or sets a value indicating whether the startup wizard is completed.
|
|
#[serde(rename = "StartupWizardCompleted")]
|
|
pub startup_wizard_completed: Option<bool>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct QueryFilters {
|
|
#[serde(rename = "Genres")]
|
|
pub genres: Option<Vec<NameGuidPair>>,
|
|
#[serde(rename = "Tags")]
|
|
pub tags: Option<Vec<String>>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct QueryFiltersLegacy {
|
|
#[serde(rename = "Genres")]
|
|
pub genres: Option<Vec<String>>,
|
|
#[serde(rename = "Tags")]
|
|
pub tags: Option<Vec<String>>,
|
|
#[serde(rename = "OfficialRatings")]
|
|
pub official_ratings: Option<Vec<String>>,
|
|
#[serde(rename = "Years")]
|
|
pub years: Option<Vec<i32>>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct QueueItem {
|
|
#[serde(rename = "Id")]
|
|
pub id: uuid::Uuid,
|
|
#[serde(rename = "PlaylistItemId")]
|
|
pub playlist_item_id: Option<String>,
|
|
}
|
|
/// Class QueueRequestDto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct QueueRequestDto {
|
|
/// Gets or sets the items to enqueue.
|
|
#[serde(rename = "ItemIds")]
|
|
pub item_ids: Vec<uuid::Uuid>,
|
|
/// Enum GroupQueueMode.
|
|
#[serde(rename = "Mode")]
|
|
pub mode: GroupQueueMode,
|
|
}
|
|
/// The quick connect request body.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct QuickConnectDto {
|
|
/// Gets or sets the quick connect secret.
|
|
#[serde(rename = "Secret")]
|
|
pub secret: String,
|
|
}
|
|
/// Stores the state of an quick connect request.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct QuickConnectResult {
|
|
/// Gets or sets a value indicating whether this request is authorized.
|
|
#[serde(rename = "Authenticated")]
|
|
pub authenticated: bool,
|
|
/// Gets the secret value used to uniquely identify this request. Can be used to retrieve authentication information.
|
|
#[serde(rename = "Secret")]
|
|
pub secret: String,
|
|
/// Gets the user facing code used so the user can quickly differentiate this request from others.
|
|
#[serde(rename = "Code")]
|
|
pub code: String,
|
|
/// Gets the requesting device id.
|
|
#[serde(rename = "DeviceId")]
|
|
pub device_id: String,
|
|
/// Gets the requesting device name.
|
|
#[serde(rename = "DeviceName")]
|
|
pub device_name: String,
|
|
/// Gets the requesting app name.
|
|
#[serde(rename = "AppName")]
|
|
pub app_name: String,
|
|
/// Gets the requesting app version.
|
|
#[serde(rename = "AppVersion")]
|
|
pub app_version: String,
|
|
/// Gets or sets the DateTime that this request was created.
|
|
#[serde(rename = "DateAdded")]
|
|
pub date_added: jiff::Zoned,
|
|
}
|
|
/// Class ReadyRequest.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ReadyRequestDto {
|
|
/// Gets or sets when the request has been made by the client.
|
|
#[serde(rename = "When")]
|
|
pub when: jiff::Zoned,
|
|
/// Gets or sets the position ticks.
|
|
#[serde(rename = "PositionTicks")]
|
|
pub position_ticks: i64,
|
|
/// Gets or sets a value indicating whether the client playback is unpaused.
|
|
#[serde(rename = "IsPlaying")]
|
|
pub is_playing: bool,
|
|
/// Gets or sets the playlist item identifier of the playing item.
|
|
#[serde(rename = "PlaylistItemId")]
|
|
pub playlist_item_id: uuid::Uuid,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct RecommendationDto {
|
|
#[serde(rename = "Items")]
|
|
pub items: Option<Vec<BaseItemDto>>,
|
|
#[serde(rename = "RecommendationType")]
|
|
pub recommendation_type: RecommendationType,
|
|
#[serde(rename = "BaselineItemName")]
|
|
pub baseline_item_name: Option<String>,
|
|
#[serde(rename = "CategoryId")]
|
|
pub category_id: uuid::Uuid,
|
|
}
|
|
/// Refresh progress message.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct RefreshProgressMessage {
|
|
/// Gets or sets the data.
|
|
#[serde(rename = "Data")]
|
|
pub data: Option<std::collections::HashMap<String, Option<String>>>,
|
|
/// Gets or sets the message id.
|
|
#[serde(rename = "MessageId")]
|
|
pub message_id: uuid::Uuid,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Class RemoteImageInfo.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct RemoteImageInfo {
|
|
/// Gets or sets the name of the provider.
|
|
#[serde(rename = "ProviderName")]
|
|
pub provider_name: Option<String>,
|
|
/// Gets or sets the URL.
|
|
#[serde(rename = "Url")]
|
|
pub url: Option<String>,
|
|
/// Gets or sets a url used for previewing a smaller version.
|
|
#[serde(rename = "ThumbnailUrl")]
|
|
pub thumbnail_url: Option<String>,
|
|
/// Gets or sets the height.
|
|
#[serde(rename = "Height")]
|
|
pub height: Option<i32>,
|
|
/// Gets or sets the width.
|
|
#[serde(rename = "Width")]
|
|
pub width: Option<i32>,
|
|
/// Gets or sets the community rating.
|
|
#[serde(rename = "CommunityRating")]
|
|
pub community_rating: Option<f64>,
|
|
/// Gets or sets the vote count.
|
|
#[serde(rename = "VoteCount")]
|
|
pub vote_count: Option<i32>,
|
|
/// Gets or sets the language.
|
|
#[serde(rename = "Language")]
|
|
pub language: Option<String>,
|
|
/// Gets or sets the type.
|
|
#[serde(rename = "Type")]
|
|
pub _type: ImageType,
|
|
/// Gets or sets the type of the rating.
|
|
#[serde(rename = "RatingType")]
|
|
pub rating_type: RatingType,
|
|
}
|
|
/// Class RemoteImageResult.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct RemoteImageResult {
|
|
/// Gets or sets the images.
|
|
#[serde(rename = "Images")]
|
|
pub images: Option<Vec<RemoteImageInfo>>,
|
|
/// Gets or sets the total record count.
|
|
#[serde(rename = "TotalRecordCount")]
|
|
pub total_record_count: i32,
|
|
/// Gets or sets the providers.
|
|
#[serde(rename = "Providers")]
|
|
pub providers: Option<Vec<String>>,
|
|
}
|
|
/// The remote lyric info dto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct RemoteLyricInfoDto {
|
|
/// Gets or sets the id for the lyric.
|
|
#[serde(rename = "Id")]
|
|
pub id: String,
|
|
/// Gets the provider name.
|
|
#[serde(rename = "ProviderName")]
|
|
pub provider_name: String,
|
|
/// Gets the lyrics.
|
|
#[serde(rename = "Lyrics")]
|
|
pub lyrics: LyricDto,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct RemoteSearchResult {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the provider ids.
|
|
#[serde(rename = "ProviderIds")]
|
|
pub provider_ids: Option<std::collections::HashMap<String, Option<String>>>,
|
|
/// Gets or sets the year.
|
|
#[serde(rename = "ProductionYear")]
|
|
pub production_year: Option<i32>,
|
|
#[serde(rename = "IndexNumber")]
|
|
pub index_number: Option<i32>,
|
|
#[serde(rename = "IndexNumberEnd")]
|
|
pub index_number_end: Option<i32>,
|
|
#[serde(rename = "ParentIndexNumber")]
|
|
pub parent_index_number: Option<i32>,
|
|
#[serde(rename = "PremiereDate")]
|
|
pub premiere_date: Option<jiff::Zoned>,
|
|
#[serde(rename = "ImageUrl")]
|
|
pub image_url: Option<String>,
|
|
#[serde(rename = "SearchProviderName")]
|
|
pub search_provider_name: Option<String>,
|
|
#[serde(rename = "Overview")]
|
|
pub overview: Option<String>,
|
|
#[serde(rename = "AlbumArtist")]
|
|
pub album_artist: Option<Box<RemoteSearchResult>>,
|
|
#[serde(rename = "Artists")]
|
|
pub artists: Option<Vec<Box<RemoteSearchResult>>>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct RemoteSubtitleInfo {
|
|
#[serde(rename = "ThreeLetterISOLanguageName")]
|
|
pub three_letter_iso_language_name: Option<String>,
|
|
#[serde(rename = "Id")]
|
|
pub id: Option<String>,
|
|
#[serde(rename = "ProviderName")]
|
|
pub provider_name: Option<String>,
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
#[serde(rename = "Format")]
|
|
pub format: Option<String>,
|
|
#[serde(rename = "Author")]
|
|
pub author: Option<String>,
|
|
#[serde(rename = "Comment")]
|
|
pub comment: Option<String>,
|
|
#[serde(rename = "DateCreated")]
|
|
pub date_created: Option<jiff::Zoned>,
|
|
#[serde(rename = "CommunityRating")]
|
|
pub community_rating: Option<f32>,
|
|
#[serde(rename = "FrameRate")]
|
|
pub frame_rate: Option<f32>,
|
|
#[serde(rename = "DownloadCount")]
|
|
pub download_count: Option<i32>,
|
|
#[serde(rename = "IsHashMatch")]
|
|
pub is_hash_match: Option<bool>,
|
|
#[serde(rename = "AiTranslated")]
|
|
pub ai_translated: Option<bool>,
|
|
#[serde(rename = "MachineTranslated")]
|
|
pub machine_translated: Option<bool>,
|
|
#[serde(rename = "Forced")]
|
|
pub forced: Option<bool>,
|
|
#[serde(rename = "HearingImpaired")]
|
|
pub hearing_impaired: Option<bool>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct RemovedItem {
|
|
#[serde(rename = "ItemId")]
|
|
pub item_id: uuid::Uuid,
|
|
#[serde(rename = "SeriesId")]
|
|
pub series_id: Option<uuid::Uuid>,
|
|
#[serde(rename = "Season")]
|
|
pub season: Option<i32>,
|
|
}
|
|
/// Query result container.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct RemovedItemQueryResult {
|
|
/// Gets or sets the items.
|
|
#[serde(rename = "Items")]
|
|
pub items: Vec<RemovedItem>,
|
|
/// Gets or sets the total number of records available.
|
|
#[serde(rename = "TotalRecordCount")]
|
|
pub total_record_count: i32,
|
|
/// Gets or sets the index of the first record in Items.
|
|
#[serde(rename = "StartIndex")]
|
|
pub start_index: i32,
|
|
}
|
|
/// Class RemoveFromPlaylistRequestDto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct RemoveFromPlaylistRequestDto {
|
|
/// Gets or sets the playlist identifiers of the items. Ignored when clearing the playlist.
|
|
#[serde(rename = "PlaylistItemIds")]
|
|
pub playlist_item_ids: Vec<uuid::Uuid>,
|
|
/// Gets or sets a value indicating whether the entire playlist should be cleared.
|
|
#[serde(rename = "ClearPlaylist")]
|
|
pub clear_playlist: bool,
|
|
/// Gets or sets a value indicating whether the playing item should be removed as well. Used only when clearing the playlist.
|
|
#[serde(rename = "ClearPlayingItem")]
|
|
pub clear_playing_item: bool,
|
|
}
|
|
/// Class RepositoryInfo.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct RepositoryInfo {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the URL.
|
|
#[serde(rename = "Url")]
|
|
pub url: Option<String>,
|
|
/// Gets or sets a value indicating whether the repository is enabled.
|
|
#[serde(rename = "Enabled")]
|
|
pub enabled: bool,
|
|
}
|
|
/// Restart required.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct RestartRequiredMessage {
|
|
/// Gets or sets the message id.
|
|
#[serde(rename = "MessageId")]
|
|
pub message_id: uuid::Uuid,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Scheduled task ended message.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ScheduledTaskEndedMessage {
|
|
/// Class TaskExecutionInfo.
|
|
#[serde(rename = "Data")]
|
|
pub data: Option<TaskResult>,
|
|
/// Gets or sets the message id.
|
|
#[serde(rename = "MessageId")]
|
|
pub message_id: uuid::Uuid,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Scheduled tasks info message.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ScheduledTasksInfoMessage {
|
|
/// Gets or sets the data.
|
|
#[serde(rename = "Data")]
|
|
pub data: Option<Vec<TaskInfo>>,
|
|
/// Gets or sets the message id.
|
|
#[serde(rename = "MessageId")]
|
|
pub message_id: uuid::Uuid,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/** Scheduled tasks info start message.
|
|
Data is the timing data encoded as "$initialDelay,$interval" in ms.*/
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ScheduledTasksInfoStartMessage {
|
|
/// Gets or sets the data.
|
|
#[serde(rename = "Data")]
|
|
pub data: Option<String>,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Scheduled tasks info stop message.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ScheduledTasksInfoStopMessage {
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Class SearchHintResult.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct SearchHint {
|
|
/// Gets or sets the item id.
|
|
#[serde(rename = "ItemId")]
|
|
pub item_id: uuid::Uuid,
|
|
/// Gets or sets the item id.
|
|
#[serde(rename = "Id")]
|
|
pub id: uuid::Uuid,
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: String,
|
|
/// Gets or sets the matched term.
|
|
#[serde(rename = "MatchedTerm")]
|
|
pub matched_term: Option<String>,
|
|
/// Gets or sets the index number.
|
|
#[serde(rename = "IndexNumber")]
|
|
pub index_number: Option<i32>,
|
|
/// Gets or sets the production year.
|
|
#[serde(rename = "ProductionYear")]
|
|
pub production_year: Option<i32>,
|
|
/// Gets or sets the parent index number.
|
|
#[serde(rename = "ParentIndexNumber")]
|
|
pub parent_index_number: Option<i32>,
|
|
/// Gets or sets the image tag.
|
|
#[serde(rename = "PrimaryImageTag")]
|
|
pub primary_image_tag: Option<String>,
|
|
/// Gets or sets the thumb image tag.
|
|
#[serde(rename = "ThumbImageTag")]
|
|
pub thumb_image_tag: Option<String>,
|
|
/// Gets or sets the thumb image item identifier.
|
|
#[serde(rename = "ThumbImageItemId")]
|
|
pub thumb_image_item_id: Option<String>,
|
|
/// Gets or sets the backdrop image tag.
|
|
#[serde(rename = "BackdropImageTag")]
|
|
pub backdrop_image_tag: Option<String>,
|
|
/// Gets or sets the backdrop image item identifier.
|
|
#[serde(rename = "BackdropImageItemId")]
|
|
pub backdrop_image_item_id: Option<String>,
|
|
/// Gets or sets the type.
|
|
#[serde(rename = "Type")]
|
|
pub _type: BaseItemKind,
|
|
/// Gets or sets a value indicating whether this instance is folder.
|
|
#[serde(rename = "IsFolder")]
|
|
pub is_folder: Option<bool>,
|
|
/// Gets or sets the run time ticks.
|
|
#[serde(rename = "RunTimeTicks")]
|
|
pub run_time_ticks: Option<i64>,
|
|
/// Gets or sets the type of the media.
|
|
#[serde(rename = "MediaType")]
|
|
pub media_type: MediaType,
|
|
/// Gets or sets the start date.
|
|
#[serde(rename = "StartDate")]
|
|
pub start_date: Option<jiff::Zoned>,
|
|
/// Gets or sets the end date.
|
|
#[serde(rename = "EndDate")]
|
|
pub end_date: Option<jiff::Zoned>,
|
|
/// Gets or sets the series.
|
|
#[serde(rename = "Series")]
|
|
pub series: Option<String>,
|
|
/// Gets or sets the status.
|
|
#[serde(rename = "Status")]
|
|
pub status: Option<String>,
|
|
/// Gets or sets the album.
|
|
#[serde(rename = "Album")]
|
|
pub album: Option<String>,
|
|
/// Gets or sets the album id.
|
|
#[serde(rename = "AlbumId")]
|
|
pub album_id: Option<uuid::Uuid>,
|
|
/// Gets or sets the album artist.
|
|
#[serde(rename = "AlbumArtist")]
|
|
pub album_artist: Option<String>,
|
|
/// Gets or sets the artists.
|
|
#[serde(rename = "Artists")]
|
|
pub artists: Vec<String>,
|
|
/// Gets or sets the song count.
|
|
#[serde(rename = "SongCount")]
|
|
pub song_count: Option<i32>,
|
|
/// Gets or sets the episode count.
|
|
#[serde(rename = "EpisodeCount")]
|
|
pub episode_count: Option<i32>,
|
|
/// Gets or sets the channel identifier.
|
|
#[serde(rename = "ChannelId")]
|
|
pub channel_id: Option<uuid::Uuid>,
|
|
/// Gets or sets the name of the channel.
|
|
#[serde(rename = "ChannelName")]
|
|
pub channel_name: Option<String>,
|
|
/// Gets or sets the primary image aspect ratio.
|
|
#[serde(rename = "PrimaryImageAspectRatio")]
|
|
pub primary_image_aspect_ratio: Option<f64>,
|
|
}
|
|
/// Class SearchHintResult.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct SearchHintResult {
|
|
/// Gets the search hints.
|
|
#[serde(rename = "SearchHints")]
|
|
pub search_hints: Vec<SearchHint>,
|
|
/// Gets the total record count.
|
|
#[serde(rename = "TotalRecordCount")]
|
|
pub total_record_count: i32,
|
|
}
|
|
/// Class SeekRequestDto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct SeekRequestDto {
|
|
/// Gets or sets the position ticks.
|
|
#[serde(rename = "PositionTicks")]
|
|
pub position_ticks: i64,
|
|
}
|
|
/// Class SendCommand.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct SendCommand {
|
|
/// Gets the group identifier.
|
|
#[serde(rename = "GroupId")]
|
|
pub group_id: uuid::Uuid,
|
|
/// Gets the playlist identifier of the playing item.
|
|
#[serde(rename = "PlaylistItemId")]
|
|
pub playlist_item_id: uuid::Uuid,
|
|
/// Gets or sets the UTC time when to execute the command.
|
|
#[serde(rename = "When")]
|
|
pub when: jiff::Zoned,
|
|
/// Gets the position ticks.
|
|
#[serde(rename = "PositionTicks")]
|
|
pub position_ticks: Option<i64>,
|
|
/// Gets the command.
|
|
#[serde(rename = "Command")]
|
|
pub command: SendCommandType,
|
|
/// Gets the UTC time when this command has been emitted.
|
|
#[serde(rename = "EmittedAt")]
|
|
pub emitted_at: jiff::Zoned,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct SeriesInfo {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the original title.
|
|
#[serde(rename = "OriginalTitle")]
|
|
pub original_title: Option<String>,
|
|
/// Gets or sets the path.
|
|
#[serde(rename = "Path")]
|
|
pub path: Option<String>,
|
|
/// Gets or sets the metadata language.
|
|
#[serde(rename = "MetadataLanguage")]
|
|
pub metadata_language: Option<String>,
|
|
/// Gets or sets the metadata country code.
|
|
#[serde(rename = "MetadataCountryCode")]
|
|
pub metadata_country_code: Option<String>,
|
|
/// Gets or sets the provider ids.
|
|
#[serde(rename = "ProviderIds")]
|
|
pub provider_ids: Option<std::collections::HashMap<String, Option<String>>>,
|
|
/// Gets or sets the year.
|
|
#[serde(rename = "Year")]
|
|
pub year: Option<i32>,
|
|
#[serde(rename = "IndexNumber")]
|
|
pub index_number: Option<i32>,
|
|
#[serde(rename = "ParentIndexNumber")]
|
|
pub parent_index_number: Option<i32>,
|
|
#[serde(rename = "PremiereDate")]
|
|
pub premiere_date: Option<jiff::Zoned>,
|
|
#[serde(rename = "IsAutomated")]
|
|
pub is_automated: bool,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct SeriesInfoRemoteSearchQuery {
|
|
#[serde(rename = "SearchInfo")]
|
|
pub search_info: Option<SeriesInfo>,
|
|
#[serde(rename = "ItemId")]
|
|
pub item_id: uuid::Uuid,
|
|
/// Gets or sets the provider name to search within if set.
|
|
#[serde(rename = "SearchProviderName")]
|
|
pub search_provider_name: Option<String>,
|
|
/// Gets or sets a value indicating whether disabled providers should be included.
|
|
#[serde(rename = "IncludeDisabledProviders")]
|
|
pub include_disabled_providers: bool,
|
|
}
|
|
/// Series timer cancelled message.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct SeriesTimerCancelledMessage {
|
|
/// Gets or sets the data.
|
|
#[serde(rename = "Data")]
|
|
pub data: Option<TimerEventInfo>,
|
|
/// Gets or sets the message id.
|
|
#[serde(rename = "MessageId")]
|
|
pub message_id: uuid::Uuid,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Series timer created message.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct SeriesTimerCreatedMessage {
|
|
/// Gets or sets the data.
|
|
#[serde(rename = "Data")]
|
|
pub data: Option<TimerEventInfo>,
|
|
/// Gets or sets the message id.
|
|
#[serde(rename = "MessageId")]
|
|
pub message_id: uuid::Uuid,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Class SeriesTimerInfoDto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct SeriesTimerInfoDto {
|
|
/// Gets or sets the Id of the recording.
|
|
#[serde(rename = "Id")]
|
|
pub id: Option<String>,
|
|
#[serde(rename = "Type")]
|
|
pub _type: Option<String>,
|
|
/// Gets or sets the server identifier.
|
|
#[serde(rename = "ServerId")]
|
|
pub server_id: Option<String>,
|
|
/// Gets or sets the external identifier.
|
|
#[serde(rename = "ExternalId")]
|
|
pub external_id: Option<String>,
|
|
/// Gets or sets the channel id of the recording.
|
|
#[serde(rename = "ChannelId")]
|
|
pub channel_id: uuid::Uuid,
|
|
/// Gets or sets the external channel identifier.
|
|
#[serde(rename = "ExternalChannelId")]
|
|
pub external_channel_id: Option<String>,
|
|
/// Gets or sets the channel name of the recording.
|
|
#[serde(rename = "ChannelName")]
|
|
pub channel_name: Option<String>,
|
|
#[serde(rename = "ChannelPrimaryImageTag")]
|
|
pub channel_primary_image_tag: Option<String>,
|
|
/// Gets or sets the program identifier.
|
|
#[serde(rename = "ProgramId")]
|
|
pub program_id: Option<String>,
|
|
/// Gets or sets the external program identifier.
|
|
#[serde(rename = "ExternalProgramId")]
|
|
pub external_program_id: Option<String>,
|
|
/// Gets or sets the name of the recording.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the description of the recording.
|
|
#[serde(rename = "Overview")]
|
|
pub overview: Option<String>,
|
|
/// Gets or sets the start date of the recording, in UTC.
|
|
#[serde(rename = "StartDate")]
|
|
pub start_date: jiff::Zoned,
|
|
/// Gets or sets the end date of the recording, in UTC.
|
|
#[serde(rename = "EndDate")]
|
|
pub end_date: jiff::Zoned,
|
|
/// Gets or sets the name of the service.
|
|
#[serde(rename = "ServiceName")]
|
|
pub service_name: Option<String>,
|
|
/// Gets or sets the priority.
|
|
#[serde(rename = "Priority")]
|
|
pub priority: i32,
|
|
/// Gets or sets the pre padding seconds.
|
|
#[serde(rename = "PrePaddingSeconds")]
|
|
pub pre_padding_seconds: i32,
|
|
/// Gets or sets the post padding seconds.
|
|
#[serde(rename = "PostPaddingSeconds")]
|
|
pub post_padding_seconds: i32,
|
|
/// Gets or sets a value indicating whether this instance is pre padding required.
|
|
#[serde(rename = "IsPrePaddingRequired")]
|
|
pub is_pre_padding_required: bool,
|
|
/// Gets or sets the Id of the Parent that has a backdrop if the item does not have one.
|
|
#[serde(rename = "ParentBackdropItemId")]
|
|
pub parent_backdrop_item_id: Option<String>,
|
|
/// Gets or sets the parent backdrop image tags.
|
|
#[serde(rename = "ParentBackdropImageTags")]
|
|
pub parent_backdrop_image_tags: Option<Vec<String>>,
|
|
/// Gets or sets a value indicating whether this instance is post padding required.
|
|
#[serde(rename = "IsPostPaddingRequired")]
|
|
pub is_post_padding_required: bool,
|
|
#[serde(rename = "KeepUntil")]
|
|
pub keep_until: KeepUntil,
|
|
/// Gets or sets a value indicating whether [record any time].
|
|
#[serde(rename = "RecordAnyTime")]
|
|
pub record_any_time: bool,
|
|
#[serde(rename = "SkipEpisodesInLibrary")]
|
|
pub skip_episodes_in_library: bool,
|
|
/// Gets or sets a value indicating whether [record any channel].
|
|
#[serde(rename = "RecordAnyChannel")]
|
|
pub record_any_channel: bool,
|
|
#[serde(rename = "KeepUpTo")]
|
|
pub keep_up_to: i32,
|
|
/// Gets or sets a value indicating whether [record new only].
|
|
#[serde(rename = "RecordNewOnly")]
|
|
pub record_new_only: bool,
|
|
/// Gets or sets the days.
|
|
#[serde(rename = "Days")]
|
|
pub days: Option<Vec<DayOfWeek>>,
|
|
/// Gets or sets the day pattern.
|
|
#[serde(rename = "DayPattern")]
|
|
pub day_pattern: Option<DayPattern>,
|
|
/// Gets or sets the image tags.
|
|
#[serde(rename = "ImageTags")]
|
|
pub image_tags: Option<std::collections::HashMap<String, String>>,
|
|
/// Gets or sets the parent thumb item id.
|
|
#[serde(rename = "ParentThumbItemId")]
|
|
pub parent_thumb_item_id: Option<String>,
|
|
/// Gets or sets the parent thumb image tag.
|
|
#[serde(rename = "ParentThumbImageTag")]
|
|
pub parent_thumb_image_tag: Option<String>,
|
|
/// Gets or sets the parent primary image item identifier.
|
|
#[serde(rename = "ParentPrimaryImageItemId")]
|
|
pub parent_primary_image_item_id: Option<String>,
|
|
/// Gets or sets the parent primary image tag.
|
|
#[serde(rename = "ParentPrimaryImageTag")]
|
|
pub parent_primary_image_tag: Option<String>,
|
|
}
|
|
/// Query result container.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct SeriesTimerInfoDtoQueryResult {
|
|
/// Gets or sets the items.
|
|
#[serde(rename = "Items")]
|
|
pub items: Vec<SeriesTimerInfoDto>,
|
|
/// Gets or sets the total number of records available.
|
|
#[serde(rename = "TotalRecordCount")]
|
|
pub total_record_count: i32,
|
|
/// Gets or sets the index of the first record in Items.
|
|
#[serde(rename = "StartIndex")]
|
|
pub start_index: i32,
|
|
}
|
|
/// Represents the server configuration.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ServerConfiguration {
|
|
/// Gets or sets the number of days we should retain log files.
|
|
#[serde(rename = "LogFileRetentionDays")]
|
|
pub log_file_retention_days: i32,
|
|
/// Gets or sets a value indicating whether this instance is first run.
|
|
#[serde(rename = "IsStartupWizardCompleted")]
|
|
pub is_startup_wizard_completed: bool,
|
|
/// Gets or sets the cache path.
|
|
#[serde(rename = "CachePath")]
|
|
pub cache_path: Option<String>,
|
|
/// Gets or sets the last known version that was ran using the configuration.
|
|
#[serde(rename = "PreviousVersion")]
|
|
pub previous_version: Option<String>,
|
|
/** Gets or sets the stringified PreviousVersion to be stored/loaded,
|
|
because System.Version itself isn't xml-serializable.*/
|
|
#[serde(rename = "PreviousVersionStr")]
|
|
pub previous_version_str: Option<String>,
|
|
/// Gets or sets a value indicating whether to enable prometheus metrics exporting.
|
|
#[serde(rename = "EnableMetrics")]
|
|
pub enable_metrics: bool,
|
|
#[serde(rename = "EnableNormalizedItemByNameIds")]
|
|
pub enable_normalized_item_by_name_ids: bool,
|
|
/// Gets or sets a value indicating whether this instance is port authorized.
|
|
#[serde(rename = "IsPortAuthorized")]
|
|
pub is_port_authorized: bool,
|
|
/// Gets or sets a value indicating whether quick connect is available for use on this server.
|
|
#[serde(rename = "QuickConnectAvailable")]
|
|
pub quick_connect_available: bool,
|
|
/// Gets or sets a value indicating whether [enable case sensitive item ids].
|
|
#[serde(rename = "EnableCaseSensitiveItemIds")]
|
|
pub enable_case_sensitive_item_ids: bool,
|
|
#[serde(rename = "DisableLiveTvChannelUserDataName")]
|
|
pub disable_live_tv_channel_user_data_name: bool,
|
|
/// Gets or sets the metadata path.
|
|
#[serde(rename = "MetadataPath")]
|
|
pub metadata_path: String,
|
|
/// Gets or sets the preferred metadata language.
|
|
#[serde(rename = "PreferredMetadataLanguage")]
|
|
pub preferred_metadata_language: String,
|
|
/// Gets or sets the metadata country code.
|
|
#[serde(rename = "MetadataCountryCode")]
|
|
pub metadata_country_code: String,
|
|
/// Gets or sets characters to be replaced with a ' ' in strings to create a sort name.
|
|
#[serde(rename = "SortReplaceCharacters")]
|
|
pub sort_replace_characters: Vec<String>,
|
|
/// Gets or sets characters to be removed from strings to create a sort name.
|
|
#[serde(rename = "SortRemoveCharacters")]
|
|
pub sort_remove_characters: Vec<String>,
|
|
/// Gets or sets words to be removed from strings to create a sort name.
|
|
#[serde(rename = "SortRemoveWords")]
|
|
pub sort_remove_words: Vec<String>,
|
|
/// Gets or sets the minimum percentage of an item that must be played in order for playstate to be updated.
|
|
#[serde(rename = "MinResumePct")]
|
|
pub min_resume_pct: i32,
|
|
/// Gets or sets the maximum percentage of an item that can be played while still saving playstate. If this percentage is crossed playstate will be reset to the beginning and the item will be marked watched.
|
|
#[serde(rename = "MaxResumePct")]
|
|
pub max_resume_pct: i32,
|
|
/// Gets or sets the minimum duration that an item must have in order to be eligible for playstate updates..
|
|
#[serde(rename = "MinResumeDurationSeconds")]
|
|
pub min_resume_duration_seconds: i32,
|
|
/// Gets or sets the minimum minutes of a book that must be played in order for playstate to be updated.
|
|
#[serde(rename = "MinAudiobookResume")]
|
|
pub min_audiobook_resume: i32,
|
|
/// Gets or sets the remaining minutes of a book that can be played while still saving playstate. If this percentage is crossed playstate will be reset to the beginning and the item will be marked watched.
|
|
#[serde(rename = "MaxAudiobookResume")]
|
|
pub max_audiobook_resume: i32,
|
|
/** Gets or sets the threshold in minutes after a inactive session gets closed automatically.
|
|
If set to 0 the check for inactive sessions gets disabled.*/
|
|
#[serde(rename = "InactiveSessionThreshold")]
|
|
pub inactive_session_threshold: i32,
|
|
/** Gets or sets the delay in seconds that we will wait after a file system change to try and discover what has been added/removed
|
|
Some delay is necessary with some items because their creation is not atomic. It involves the creation of several
|
|
different directories and files.*/
|
|
#[serde(rename = "LibraryMonitorDelay")]
|
|
pub library_monitor_delay: i32,
|
|
/// Gets or sets the duration in seconds that we will wait after a library updated event before executing the library changed notification.
|
|
#[serde(rename = "LibraryUpdateDuration")]
|
|
pub library_update_duration: i32,
|
|
/// Gets or sets the image saving convention.
|
|
#[serde(rename = "ImageSavingConvention")]
|
|
pub image_saving_convention: ImageSavingConvention,
|
|
#[serde(rename = "MetadataOptions")]
|
|
pub metadata_options: Vec<MetadataOptions>,
|
|
#[serde(rename = "SkipDeserializationForBasicTypes")]
|
|
pub skip_deserialization_for_basic_types: bool,
|
|
#[serde(rename = "ServerName")]
|
|
pub server_name: String,
|
|
#[serde(rename = "UICulture")]
|
|
pub ui_culture: String,
|
|
#[serde(rename = "SaveMetadataHidden")]
|
|
pub save_metadata_hidden: bool,
|
|
#[serde(rename = "ContentTypes")]
|
|
pub content_types: Vec<NameValuePair>,
|
|
#[serde(rename = "RemoteClientBitrateLimit")]
|
|
pub remote_client_bitrate_limit: i32,
|
|
#[serde(rename = "EnableFolderView")]
|
|
pub enable_folder_view: bool,
|
|
#[serde(rename = "EnableGroupingIntoCollections")]
|
|
pub enable_grouping_into_collections: bool,
|
|
#[serde(rename = "DisplaySpecialsWithinSeasons")]
|
|
pub display_specials_within_seasons: bool,
|
|
#[serde(rename = "CodecsUsed")]
|
|
pub codecs_used: Vec<String>,
|
|
#[serde(rename = "PluginRepositories")]
|
|
pub plugin_repositories: Vec<RepositoryInfo>,
|
|
#[serde(rename = "EnableExternalContentInSuggestions")]
|
|
pub enable_external_content_in_suggestions: bool,
|
|
#[serde(rename = "ImageExtractionTimeoutMs")]
|
|
pub image_extraction_timeout_ms: i32,
|
|
#[serde(rename = "PathSubstitutions")]
|
|
pub path_substitutions: Vec<PathSubstitution>,
|
|
/// Gets or sets a value indicating whether slow server responses should be logged as a warning.
|
|
#[serde(rename = "EnableSlowResponseWarning")]
|
|
pub enable_slow_response_warning: bool,
|
|
/// Gets or sets the threshold for the slow response time warning in ms.
|
|
#[serde(rename = "SlowResponseThresholdMs")]
|
|
pub slow_response_threshold_ms: i64,
|
|
/// Gets or sets the cors hosts.
|
|
#[serde(rename = "CorsHosts")]
|
|
pub cors_hosts: Vec<String>,
|
|
/// Gets or sets the number of days we should retain activity logs.
|
|
#[serde(rename = "ActivityLogRetentionDays")]
|
|
pub activity_log_retention_days: Option<i32>,
|
|
/// Gets or sets the how the library scan fans out.
|
|
#[serde(rename = "LibraryScanFanoutConcurrency")]
|
|
pub library_scan_fanout_concurrency: i32,
|
|
/// Gets or sets the how many metadata refreshes can run concurrently.
|
|
#[serde(rename = "LibraryMetadataRefreshConcurrency")]
|
|
pub library_metadata_refresh_concurrency: i32,
|
|
/// Gets or sets a value indicating whether older plugins should automatically be deleted from the plugin folder.
|
|
#[serde(rename = "RemoveOldPlugins")]
|
|
pub remove_old_plugins: bool,
|
|
/// Gets or sets a value indicating whether clients should be allowed to upload logs.
|
|
#[serde(rename = "AllowClientLogUpload")]
|
|
pub allow_client_log_upload: bool,
|
|
/// Gets or sets the dummy chapter duration in seconds, use 0 (zero) or less to disable generation alltogether.
|
|
#[serde(rename = "DummyChapterDuration")]
|
|
pub dummy_chapter_duration: i32,
|
|
/// Gets or sets the chapter image resolution.
|
|
#[serde(rename = "ChapterImageResolution")]
|
|
pub chapter_image_resolution: ImageResolution,
|
|
/// Gets or sets the limit for parallel image encoding.
|
|
#[serde(rename = "ParallelImageEncodingLimit")]
|
|
pub parallel_image_encoding_limit: i32,
|
|
/// Gets or sets the list of cast receiver applications.
|
|
#[serde(rename = "CastReceiverApplications")]
|
|
pub cast_receiver_applications: Vec<CastReceiverApplication>,
|
|
/// Gets or sets the trickplay options.
|
|
#[serde(rename = "TrickplayOptions")]
|
|
pub trickplay_options: TrickplayOptions,
|
|
}
|
|
/// The server discovery info model.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ServerDiscoveryInfo {
|
|
/// Gets the address.
|
|
#[serde(rename = "Address")]
|
|
pub address: String,
|
|
/// Gets the server identifier.
|
|
#[serde(rename = "Id")]
|
|
pub id: String,
|
|
/// Gets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: String,
|
|
/// Gets the endpoint address.
|
|
#[serde(rename = "EndpointAddress")]
|
|
pub endpoint_address: Option<String>,
|
|
}
|
|
/// Server restarting down message.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ServerRestartingMessage {
|
|
/// Gets or sets the message id.
|
|
#[serde(rename = "MessageId")]
|
|
pub message_id: uuid::Uuid,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Server shutting down message.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ServerShuttingDownMessage {
|
|
/// Gets or sets the message id.
|
|
#[serde(rename = "MessageId")]
|
|
pub message_id: uuid::Uuid,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Session info DTO.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct SessionInfoDto {
|
|
/// Gets or sets the play state.
|
|
#[serde(rename = "PlayState")]
|
|
pub play_state: Option<PlayerStateInfo>,
|
|
/// Gets or sets the additional users.
|
|
#[serde(rename = "AdditionalUsers")]
|
|
pub additional_users: Option<Vec<SessionUserInfo>>,
|
|
/// Gets or sets the client capabilities.
|
|
#[serde(rename = "Capabilities")]
|
|
pub capabilities: Option<ClientCapabilitiesDto>,
|
|
/// Gets or sets the remote end point.
|
|
#[serde(rename = "RemoteEndPoint")]
|
|
pub remote_end_point: Option<String>,
|
|
/// Gets or sets the playable media types.
|
|
#[serde(rename = "PlayableMediaTypes")]
|
|
pub playable_media_types: Vec<MediaType>,
|
|
/// Gets or sets the id.
|
|
#[serde(rename = "Id")]
|
|
pub id: Option<String>,
|
|
/// Gets or sets the user id.
|
|
#[serde(rename = "UserId")]
|
|
pub user_id: uuid::Uuid,
|
|
/// Gets or sets the username.
|
|
#[serde(rename = "UserName")]
|
|
pub user_name: Option<String>,
|
|
/// Gets or sets the type of the client.
|
|
#[serde(rename = "Client")]
|
|
pub client: Option<String>,
|
|
/// Gets or sets the last activity date.
|
|
#[serde(rename = "LastActivityDate")]
|
|
pub last_activity_date: jiff::Zoned,
|
|
/// Gets or sets the last playback check in.
|
|
#[serde(rename = "LastPlaybackCheckIn")]
|
|
pub last_playback_check_in: jiff::Zoned,
|
|
/// Gets or sets the last paused date.
|
|
#[serde(rename = "LastPausedDate")]
|
|
pub last_paused_date: Option<jiff::Zoned>,
|
|
/// Gets or sets the name of the device.
|
|
#[serde(rename = "DeviceName")]
|
|
pub device_name: Option<String>,
|
|
/// Gets or sets the type of the device.
|
|
#[serde(rename = "DeviceType")]
|
|
pub device_type: Option<String>,
|
|
/// Gets or sets the now playing item.
|
|
#[serde(rename = "NowPlayingItem")]
|
|
pub now_playing_item: Option<BaseItemDto>,
|
|
/// Gets or sets the now viewing item.
|
|
#[serde(rename = "NowViewingItem")]
|
|
pub now_viewing_item: Option<BaseItemDto>,
|
|
/// Gets or sets the device id.
|
|
#[serde(rename = "DeviceId")]
|
|
pub device_id: Option<String>,
|
|
/// Gets or sets the application version.
|
|
#[serde(rename = "ApplicationVersion")]
|
|
pub application_version: Option<String>,
|
|
/// Gets or sets the transcoding info.
|
|
#[serde(rename = "TranscodingInfo")]
|
|
pub transcoding_info: Option<TranscodingInfo>,
|
|
/// Gets or sets a value indicating whether this session is active.
|
|
#[serde(rename = "IsActive")]
|
|
pub is_active: bool,
|
|
/// Gets or sets a value indicating whether the session supports media control.
|
|
#[serde(rename = "SupportsMediaControl")]
|
|
pub supports_media_control: bool,
|
|
/// Gets or sets a value indicating whether the session supports remote control.
|
|
#[serde(rename = "SupportsRemoteControl")]
|
|
pub supports_remote_control: bool,
|
|
/// Gets or sets the now playing queue.
|
|
#[serde(rename = "NowPlayingQueue")]
|
|
pub now_playing_queue: Option<Vec<QueueItem>>,
|
|
/// Gets or sets the now playing queue full items.
|
|
#[serde(rename = "NowPlayingQueueFullItems")]
|
|
pub now_playing_queue_full_items: Option<Vec<BaseItemDto>>,
|
|
/// Gets or sets a value indicating whether the session has a custom device name.
|
|
#[serde(rename = "HasCustomDeviceName")]
|
|
pub has_custom_device_name: bool,
|
|
/// Gets or sets the playlist item id.
|
|
#[serde(rename = "PlaylistItemId")]
|
|
pub playlist_item_id: Option<String>,
|
|
/// Gets or sets the server id.
|
|
#[serde(rename = "ServerId")]
|
|
pub server_id: Option<String>,
|
|
/// Gets or sets the user primary image tag.
|
|
#[serde(rename = "UserPrimaryImageTag")]
|
|
pub user_primary_image_tag: Option<String>,
|
|
/// Gets or sets the supported commands.
|
|
#[serde(rename = "SupportedCommands")]
|
|
pub supported_commands: Vec<GeneralCommandType>,
|
|
}
|
|
/// Sessions message.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct SessionsMessage {
|
|
/// Gets or sets the data.
|
|
#[serde(rename = "Data")]
|
|
pub data: Option<Vec<SessionInfoDto>>,
|
|
/// Gets or sets the message id.
|
|
#[serde(rename = "MessageId")]
|
|
pub message_id: uuid::Uuid,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/** Sessions start message.
|
|
Data is the timing data encoded as "$initialDelay,$interval" in ms.*/
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct SessionsStartMessage {
|
|
/// Gets or sets the data.
|
|
#[serde(rename = "Data")]
|
|
pub data: Option<String>,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Sessions stop message.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct SessionsStopMessage {
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Class SessionUserInfo.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct SessionUserInfo {
|
|
/// Gets or sets the user identifier.
|
|
#[serde(rename = "UserId")]
|
|
pub user_id: uuid::Uuid,
|
|
/// Gets or sets the name of the user.
|
|
#[serde(rename = "UserName")]
|
|
pub user_name: Option<String>,
|
|
}
|
|
/// Set channel mapping dto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct SetChannelMappingDto {
|
|
/// Gets or sets the provider id.
|
|
#[serde(rename = "ProviderId")]
|
|
pub provider_id: String,
|
|
/// Gets or sets the tuner channel id.
|
|
#[serde(rename = "TunerChannelId")]
|
|
pub tuner_channel_id: String,
|
|
/// Gets or sets the provider channel id.
|
|
#[serde(rename = "ProviderChannelId")]
|
|
pub provider_channel_id: String,
|
|
}
|
|
/// Class SetPlaylistItemRequestDto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct SetPlaylistItemRequestDto {
|
|
/// Gets or sets the playlist identifier of the playing item.
|
|
#[serde(rename = "PlaylistItemId")]
|
|
pub playlist_item_id: uuid::Uuid,
|
|
}
|
|
/// Class SetRepeatModeRequestDto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct SetRepeatModeRequestDto {
|
|
/// Enum GroupRepeatMode.
|
|
#[serde(rename = "Mode")]
|
|
pub mode: GroupRepeatMode,
|
|
}
|
|
/// Class SetShuffleModeRequestDto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct SetShuffleModeRequestDto {
|
|
/// Enum GroupShuffleMode.
|
|
#[serde(rename = "Mode")]
|
|
pub mode: GroupShuffleMode,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct SongInfo {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the original title.
|
|
#[serde(rename = "OriginalTitle")]
|
|
pub original_title: Option<String>,
|
|
/// Gets or sets the path.
|
|
#[serde(rename = "Path")]
|
|
pub path: Option<String>,
|
|
/// Gets or sets the metadata language.
|
|
#[serde(rename = "MetadataLanguage")]
|
|
pub metadata_language: Option<String>,
|
|
/// Gets or sets the metadata country code.
|
|
#[serde(rename = "MetadataCountryCode")]
|
|
pub metadata_country_code: Option<String>,
|
|
/// Gets or sets the provider ids.
|
|
#[serde(rename = "ProviderIds")]
|
|
pub provider_ids: Option<std::collections::HashMap<String, Option<String>>>,
|
|
/// Gets or sets the year.
|
|
#[serde(rename = "Year")]
|
|
pub year: Option<i32>,
|
|
#[serde(rename = "IndexNumber")]
|
|
pub index_number: Option<i32>,
|
|
#[serde(rename = "ParentIndexNumber")]
|
|
pub parent_index_number: Option<i32>,
|
|
#[serde(rename = "PremiereDate")]
|
|
pub premiere_date: Option<jiff::Zoned>,
|
|
#[serde(rename = "IsAutomated")]
|
|
pub is_automated: bool,
|
|
#[serde(rename = "AlbumArtists")]
|
|
pub album_artists: Option<Vec<String>>,
|
|
#[serde(rename = "Album")]
|
|
pub album: Option<String>,
|
|
#[serde(rename = "Artists")]
|
|
pub artists: Option<Vec<String>>,
|
|
}
|
|
/// Special view option dto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct SpecialViewOptionDto {
|
|
/// Gets or sets view option name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets view option id.
|
|
#[serde(rename = "Id")]
|
|
pub id: Option<String>,
|
|
}
|
|
/// The startup configuration DTO.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct StartupConfigurationDto {
|
|
/// Gets or sets UI language culture.
|
|
#[serde(rename = "UICulture")]
|
|
pub ui_culture: Option<String>,
|
|
/// Gets or sets the metadata country code.
|
|
#[serde(rename = "MetadataCountryCode")]
|
|
pub metadata_country_code: Option<String>,
|
|
/// Gets or sets the preferred language for the metadata.
|
|
#[serde(rename = "PreferredMetadataLanguage")]
|
|
pub preferred_metadata_language: Option<String>,
|
|
}
|
|
/// Startup remote access dto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct StartupRemoteAccessDto {
|
|
/// Gets or sets a value indicating whether enable remote access.
|
|
#[serde(rename = "EnableRemoteAccess")]
|
|
pub enable_remote_access: bool,
|
|
/// Gets or sets a value indicating whether enable automatic port mapping.
|
|
#[serde(rename = "EnableAutomaticPortMapping")]
|
|
pub enable_automatic_port_mapping: bool,
|
|
}
|
|
/// The startup user DTO.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct StartupUserDto {
|
|
/// Gets or sets the username.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the user's password.
|
|
#[serde(rename = "Password")]
|
|
pub password: Option<String>,
|
|
}
|
|
/// Class GroupUpdate.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct StringGroupUpdate {
|
|
/// Gets the group identifier.
|
|
#[serde(rename = "GroupId")]
|
|
pub group_id: uuid::Uuid,
|
|
/// Gets the update type.
|
|
#[serde(rename = "Type")]
|
|
pub _type: GroupUpdateType,
|
|
/// Gets the update data.
|
|
#[serde(rename = "Data")]
|
|
pub data: String,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct SubtitleOptions {
|
|
#[serde(rename = "SkipIfEmbeddedSubtitlesPresent")]
|
|
pub skip_if_embedded_subtitles_present: bool,
|
|
#[serde(rename = "SkipIfAudioTrackMatches")]
|
|
pub skip_if_audio_track_matches: bool,
|
|
#[serde(rename = "DownloadLanguages")]
|
|
pub download_languages: Option<Vec<String>>,
|
|
#[serde(rename = "DownloadMovieSubtitles")]
|
|
pub download_movie_subtitles: bool,
|
|
#[serde(rename = "DownloadEpisodeSubtitles")]
|
|
pub download_episode_subtitles: bool,
|
|
#[serde(rename = "OpenSubtitlesUsername")]
|
|
pub open_subtitles_username: Option<String>,
|
|
#[serde(rename = "OpenSubtitlesPasswordHash")]
|
|
pub open_subtitles_password_hash: Option<String>,
|
|
#[serde(rename = "IsOpenSubtitleVipAccount")]
|
|
pub is_open_subtitle_vip_account: bool,
|
|
#[serde(rename = "RequirePerfectMatch")]
|
|
pub require_perfect_match: bool,
|
|
}
|
|
/// A class for subtitle profile information.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct SubtitleProfile {
|
|
/// Gets or sets the format.
|
|
#[serde(rename = "Format")]
|
|
pub format: Option<String>,
|
|
/// Gets or sets the delivery method.
|
|
#[serde(rename = "Method")]
|
|
pub method: SubtitleDeliveryMethod,
|
|
/// Gets or sets the DIDL mode.
|
|
#[serde(rename = "DidlMode")]
|
|
pub didl_mode: Option<String>,
|
|
/// Gets or sets the language.
|
|
#[serde(rename = "Language")]
|
|
pub language: Option<String>,
|
|
/// Gets or sets the container.
|
|
#[serde(rename = "Container")]
|
|
pub container: Option<String>,
|
|
}
|
|
/// Sync play command.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct SyncPlayCommandMessage {
|
|
/// Class SendCommand.
|
|
#[serde(rename = "Data")]
|
|
pub data: Option<SendCommand>,
|
|
/// Gets or sets the message id.
|
|
#[serde(rename = "MessageId")]
|
|
pub message_id: uuid::Uuid,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Untyped sync play command.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct SyncPlayGroupUpdateCommandMessage {
|
|
/// Group update without data.
|
|
#[serde(rename = "Data")]
|
|
pub data: Option<GroupUpdate>,
|
|
/// Gets or sets the message id.
|
|
#[serde(rename = "MessageId")]
|
|
pub message_id: uuid::Uuid,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Class QueueItem.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct SyncPlayQueueItem {
|
|
/// Gets the item identifier.
|
|
#[serde(rename = "ItemId")]
|
|
pub item_id: uuid::Uuid,
|
|
/// Gets the playlist identifier of the item.
|
|
#[serde(rename = "PlaylistItemId")]
|
|
pub playlist_item_id: uuid::Uuid,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct SyncStats {
|
|
#[serde(rename = "UpdatedFolders")]
|
|
pub updated_folders: i32,
|
|
#[serde(rename = "RemovedFolders")]
|
|
pub removed_folders: i32,
|
|
#[serde(rename = "UpdatedBoxSets")]
|
|
pub updated_box_sets: i32,
|
|
#[serde(rename = "RemovedBoxSets")]
|
|
pub removed_box_sets: i32,
|
|
#[serde(rename = "UpdatedPlaylists")]
|
|
pub updated_playlists: i32,
|
|
#[serde(rename = "RemovedPlaylists")]
|
|
pub removed_playlists: i32,
|
|
#[serde(rename = "UpdatedTvShows")]
|
|
pub updated_tv_shows: i32,
|
|
#[serde(rename = "RemovedTvShows")]
|
|
pub removed_tv_shows: i32,
|
|
#[serde(rename = "UpdatedSeasons")]
|
|
pub updated_seasons: i32,
|
|
#[serde(rename = "RemovedSeasons")]
|
|
pub removed_seasons: i32,
|
|
#[serde(rename = "UpdatedVideos")]
|
|
pub updated_videos: i32,
|
|
#[serde(rename = "RemovedVideos")]
|
|
pub removed_videos: i32,
|
|
#[serde(rename = "UpdatedCollectionFolders")]
|
|
pub updated_collection_folders: i32,
|
|
#[serde(rename = "UpdatedUserData")]
|
|
pub updated_user_data: i32,
|
|
}
|
|
/// Class SystemInfo.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct SystemInfo {
|
|
/// Gets or sets the local address.
|
|
#[serde(rename = "LocalAddress")]
|
|
pub local_address: Option<String>,
|
|
/// Gets or sets the name of the server.
|
|
#[serde(rename = "ServerName")]
|
|
pub server_name: Option<String>,
|
|
/// Gets or sets the server version.
|
|
#[serde(rename = "Version")]
|
|
pub version: Option<String>,
|
|
/// Gets or sets the product name. This is the AssemblyProduct name.
|
|
#[serde(rename = "ProductName")]
|
|
pub product_name: Option<String>,
|
|
/// Gets or sets the operating system.
|
|
#[serde(rename = "OperatingSystem")]
|
|
pub operating_system: Option<String>,
|
|
/// Gets or sets the id.
|
|
#[serde(rename = "Id")]
|
|
pub id: Option<String>,
|
|
/// Gets or sets a value indicating whether the startup wizard is completed.
|
|
#[serde(rename = "StartupWizardCompleted")]
|
|
pub startup_wizard_completed: Option<bool>,
|
|
/// Gets or sets the display name of the operating system.
|
|
#[serde(rename = "OperatingSystemDisplayName")]
|
|
pub operating_system_display_name: Option<String>,
|
|
/// Gets or sets the package name.
|
|
#[serde(rename = "PackageName")]
|
|
pub package_name: Option<String>,
|
|
/// Gets or sets a value indicating whether this instance has pending restart.
|
|
#[serde(rename = "HasPendingRestart")]
|
|
pub has_pending_restart: bool,
|
|
#[serde(rename = "IsShuttingDown")]
|
|
pub is_shutting_down: bool,
|
|
/// Gets or sets a value indicating whether [supports library monitor].
|
|
#[serde(rename = "SupportsLibraryMonitor")]
|
|
pub supports_library_monitor: bool,
|
|
/// Gets or sets the web socket port number.
|
|
#[serde(rename = "WebSocketPortNumber")]
|
|
pub web_socket_port_number: i32,
|
|
/// Gets or sets the completed installations.
|
|
#[serde(rename = "CompletedInstallations")]
|
|
pub completed_installations: Option<Vec<InstallationInfo>>,
|
|
/// Gets or sets a value indicating whether this instance can self restart.
|
|
#[serde(rename = "CanSelfRestart")]
|
|
pub can_self_restart: bool,
|
|
#[serde(rename = "CanLaunchWebBrowser")]
|
|
pub can_launch_web_browser: bool,
|
|
/// Gets or sets the program data path.
|
|
#[serde(rename = "ProgramDataPath")]
|
|
pub program_data_path: Option<String>,
|
|
/// Gets or sets the web UI resources path.
|
|
#[serde(rename = "WebPath")]
|
|
pub web_path: Option<String>,
|
|
/// Gets or sets the items by name path.
|
|
#[serde(rename = "ItemsByNamePath")]
|
|
pub items_by_name_path: Option<String>,
|
|
/// Gets or sets the cache path.
|
|
#[serde(rename = "CachePath")]
|
|
pub cache_path: Option<String>,
|
|
/// Gets or sets the log path.
|
|
#[serde(rename = "LogPath")]
|
|
pub log_path: Option<String>,
|
|
/// Gets or sets the internal metadata path.
|
|
#[serde(rename = "InternalMetadataPath")]
|
|
pub internal_metadata_path: Option<String>,
|
|
/// Gets or sets the transcode path.
|
|
#[serde(rename = "TranscodingTempPath")]
|
|
pub transcoding_temp_path: Option<String>,
|
|
/// Gets or sets the list of cast receiver applications.
|
|
#[serde(rename = "CastReceiverApplications")]
|
|
pub cast_receiver_applications: Option<Vec<CastReceiverApplication>>,
|
|
/// Gets or sets a value indicating whether this instance has update available.
|
|
#[serde(rename = "HasUpdateAvailable")]
|
|
pub has_update_available: bool,
|
|
#[serde(rename = "EncoderLocation")]
|
|
pub encoder_location: Option<String>,
|
|
#[serde(rename = "SystemArchitecture")]
|
|
pub system_architecture: Option<String>,
|
|
}
|
|
/// Class TaskInfo.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct TaskInfo {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the state of the task.
|
|
#[serde(rename = "State")]
|
|
pub state: TaskState,
|
|
/// Gets or sets the progress.
|
|
#[serde(rename = "CurrentProgressPercentage")]
|
|
pub current_progress_percentage: Option<f64>,
|
|
/// Gets or sets the id.
|
|
#[serde(rename = "Id")]
|
|
pub id: Option<String>,
|
|
/// Gets or sets the last execution result.
|
|
#[serde(rename = "LastExecutionResult")]
|
|
pub last_execution_result: Option<TaskResult>,
|
|
/// Gets or sets the triggers.
|
|
#[serde(rename = "Triggers")]
|
|
pub triggers: Option<Vec<TaskTriggerInfo>>,
|
|
/// Gets or sets the description.
|
|
#[serde(rename = "Description")]
|
|
pub description: Option<String>,
|
|
/// Gets or sets the category.
|
|
#[serde(rename = "Category")]
|
|
pub category: Option<String>,
|
|
/// Gets or sets a value indicating whether this instance is hidden.
|
|
#[serde(rename = "IsHidden")]
|
|
pub is_hidden: bool,
|
|
/// Gets or sets the key.
|
|
#[serde(rename = "Key")]
|
|
pub key: Option<String>,
|
|
}
|
|
/// Class TaskExecutionInfo.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct TaskResult {
|
|
/// Gets or sets the start time UTC.
|
|
#[serde(rename = "StartTimeUtc")]
|
|
pub start_time_utc: jiff::Zoned,
|
|
/// Gets or sets the end time UTC.
|
|
#[serde(rename = "EndTimeUtc")]
|
|
pub end_time_utc: jiff::Zoned,
|
|
/// Gets or sets the status.
|
|
#[serde(rename = "Status")]
|
|
pub status: TaskCompletionStatus,
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the key.
|
|
#[serde(rename = "Key")]
|
|
pub key: Option<String>,
|
|
/// Gets or sets the id.
|
|
#[serde(rename = "Id")]
|
|
pub id: Option<String>,
|
|
/// Gets or sets the error message.
|
|
#[serde(rename = "ErrorMessage")]
|
|
pub error_message: Option<String>,
|
|
/// Gets or sets the long error message.
|
|
#[serde(rename = "LongErrorMessage")]
|
|
pub long_error_message: Option<String>,
|
|
}
|
|
/// Class TaskTriggerInfo.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct TaskTriggerInfo {
|
|
/// Gets or sets the type.
|
|
#[serde(rename = "Type")]
|
|
pub _type: Option<String>,
|
|
/// Gets or sets the time of day.
|
|
#[serde(rename = "TimeOfDayTicks")]
|
|
pub time_of_day_ticks: Option<i64>,
|
|
/// Gets or sets the interval.
|
|
#[serde(rename = "IntervalTicks")]
|
|
pub interval_ticks: Option<i64>,
|
|
/// Gets or sets the day of week.
|
|
#[serde(rename = "DayOfWeek")]
|
|
pub day_of_week: Option<DayOfWeek>,
|
|
/// Gets or sets the maximum runtime ticks.
|
|
#[serde(rename = "MaxRuntimeTicks")]
|
|
pub max_runtime_ticks: Option<i64>,
|
|
}
|
|
/// Class ThemeMediaResult.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ThemeMediaResult {
|
|
/// Gets or sets the items.
|
|
#[serde(rename = "Items")]
|
|
pub items: Vec<BaseItemDto>,
|
|
/// Gets or sets the total number of records available.
|
|
#[serde(rename = "TotalRecordCount")]
|
|
pub total_record_count: i32,
|
|
/// Gets or sets the index of the first record in Items.
|
|
#[serde(rename = "StartIndex")]
|
|
pub start_index: i32,
|
|
/// Gets or sets the owner id.
|
|
#[serde(rename = "OwnerId")]
|
|
pub owner_id: uuid::Uuid,
|
|
}
|
|
/// Timer cancelled message.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct TimerCancelledMessage {
|
|
/// Gets or sets the data.
|
|
#[serde(rename = "Data")]
|
|
pub data: Option<TimerEventInfo>,
|
|
/// Gets or sets the message id.
|
|
#[serde(rename = "MessageId")]
|
|
pub message_id: uuid::Uuid,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Timer created message.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct TimerCreatedMessage {
|
|
/// Gets or sets the data.
|
|
#[serde(rename = "Data")]
|
|
pub data: Option<TimerEventInfo>,
|
|
/// Gets or sets the message id.
|
|
#[serde(rename = "MessageId")]
|
|
pub message_id: uuid::Uuid,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct TimerEventInfo {
|
|
#[serde(rename = "Id")]
|
|
pub id: String,
|
|
#[serde(rename = "ProgramId")]
|
|
pub program_id: Option<uuid::Uuid>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct TimerInfoDto {
|
|
/// Gets or sets the Id of the recording.
|
|
#[serde(rename = "Id")]
|
|
pub id: Option<String>,
|
|
#[serde(rename = "Type")]
|
|
pub _type: Option<String>,
|
|
/// Gets or sets the server identifier.
|
|
#[serde(rename = "ServerId")]
|
|
pub server_id: Option<String>,
|
|
/// Gets or sets the external identifier.
|
|
#[serde(rename = "ExternalId")]
|
|
pub external_id: Option<String>,
|
|
/// Gets or sets the channel id of the recording.
|
|
#[serde(rename = "ChannelId")]
|
|
pub channel_id: uuid::Uuid,
|
|
/// Gets or sets the external channel identifier.
|
|
#[serde(rename = "ExternalChannelId")]
|
|
pub external_channel_id: Option<String>,
|
|
/// Gets or sets the channel name of the recording.
|
|
#[serde(rename = "ChannelName")]
|
|
pub channel_name: Option<String>,
|
|
#[serde(rename = "ChannelPrimaryImageTag")]
|
|
pub channel_primary_image_tag: Option<String>,
|
|
/// Gets or sets the program identifier.
|
|
#[serde(rename = "ProgramId")]
|
|
pub program_id: Option<String>,
|
|
/// Gets or sets the external program identifier.
|
|
#[serde(rename = "ExternalProgramId")]
|
|
pub external_program_id: Option<String>,
|
|
/// Gets or sets the name of the recording.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the description of the recording.
|
|
#[serde(rename = "Overview")]
|
|
pub overview: Option<String>,
|
|
/// Gets or sets the start date of the recording, in UTC.
|
|
#[serde(rename = "StartDate")]
|
|
pub start_date: jiff::Zoned,
|
|
/// Gets or sets the end date of the recording, in UTC.
|
|
#[serde(rename = "EndDate")]
|
|
pub end_date: jiff::Zoned,
|
|
/// Gets or sets the name of the service.
|
|
#[serde(rename = "ServiceName")]
|
|
pub service_name: Option<String>,
|
|
/// Gets or sets the priority.
|
|
#[serde(rename = "Priority")]
|
|
pub priority: i32,
|
|
/// Gets or sets the pre padding seconds.
|
|
#[serde(rename = "PrePaddingSeconds")]
|
|
pub pre_padding_seconds: i32,
|
|
/// Gets or sets the post padding seconds.
|
|
#[serde(rename = "PostPaddingSeconds")]
|
|
pub post_padding_seconds: i32,
|
|
/// Gets or sets a value indicating whether this instance is pre padding required.
|
|
#[serde(rename = "IsPrePaddingRequired")]
|
|
pub is_pre_padding_required: bool,
|
|
/// Gets or sets the Id of the Parent that has a backdrop if the item does not have one.
|
|
#[serde(rename = "ParentBackdropItemId")]
|
|
pub parent_backdrop_item_id: Option<String>,
|
|
/// Gets or sets the parent backdrop image tags.
|
|
#[serde(rename = "ParentBackdropImageTags")]
|
|
pub parent_backdrop_image_tags: Option<Vec<String>>,
|
|
/// Gets or sets a value indicating whether this instance is post padding required.
|
|
#[serde(rename = "IsPostPaddingRequired")]
|
|
pub is_post_padding_required: bool,
|
|
#[serde(rename = "KeepUntil")]
|
|
pub keep_until: KeepUntil,
|
|
/// Gets or sets the status.
|
|
#[serde(rename = "Status")]
|
|
pub status: RecordingStatus,
|
|
/// Gets or sets the series timer identifier.
|
|
#[serde(rename = "SeriesTimerId")]
|
|
pub series_timer_id: Option<String>,
|
|
/// Gets or sets the external series timer identifier.
|
|
#[serde(rename = "ExternalSeriesTimerId")]
|
|
pub external_series_timer_id: Option<String>,
|
|
/// Gets or sets the run time ticks.
|
|
#[serde(rename = "RunTimeTicks")]
|
|
pub run_time_ticks: Option<i64>,
|
|
/// Gets or sets the program information.
|
|
#[serde(rename = "ProgramInfo")]
|
|
pub program_info: Option<BaseItemDto>,
|
|
}
|
|
/// Query result container.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct TimerInfoDtoQueryResult {
|
|
/// Gets or sets the items.
|
|
#[serde(rename = "Items")]
|
|
pub items: Vec<TimerInfoDto>,
|
|
/// Gets or sets the total number of records available.
|
|
#[serde(rename = "TotalRecordCount")]
|
|
pub total_record_count: i32,
|
|
/// Gets or sets the index of the first record in Items.
|
|
#[serde(rename = "StartIndex")]
|
|
pub start_index: i32,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct TrailerInfo {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the original title.
|
|
#[serde(rename = "OriginalTitle")]
|
|
pub original_title: Option<String>,
|
|
/// Gets or sets the path.
|
|
#[serde(rename = "Path")]
|
|
pub path: Option<String>,
|
|
/// Gets or sets the metadata language.
|
|
#[serde(rename = "MetadataLanguage")]
|
|
pub metadata_language: Option<String>,
|
|
/// Gets or sets the metadata country code.
|
|
#[serde(rename = "MetadataCountryCode")]
|
|
pub metadata_country_code: Option<String>,
|
|
/// Gets or sets the provider ids.
|
|
#[serde(rename = "ProviderIds")]
|
|
pub provider_ids: Option<std::collections::HashMap<String, Option<String>>>,
|
|
/// Gets or sets the year.
|
|
#[serde(rename = "Year")]
|
|
pub year: Option<i32>,
|
|
#[serde(rename = "IndexNumber")]
|
|
pub index_number: Option<i32>,
|
|
#[serde(rename = "ParentIndexNumber")]
|
|
pub parent_index_number: Option<i32>,
|
|
#[serde(rename = "PremiereDate")]
|
|
pub premiere_date: Option<jiff::Zoned>,
|
|
#[serde(rename = "IsAutomated")]
|
|
pub is_automated: bool,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct TrailerInfoRemoteSearchQuery {
|
|
#[serde(rename = "SearchInfo")]
|
|
pub search_info: Option<TrailerInfo>,
|
|
#[serde(rename = "ItemId")]
|
|
pub item_id: uuid::Uuid,
|
|
/// Gets or sets the provider name to search within if set.
|
|
#[serde(rename = "SearchProviderName")]
|
|
pub search_provider_name: Option<String>,
|
|
/// Gets or sets a value indicating whether disabled providers should be included.
|
|
#[serde(rename = "IncludeDisabledProviders")]
|
|
pub include_disabled_providers: bool,
|
|
}
|
|
/// Class holding information on a runnning transcode.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct TranscodingInfo {
|
|
/// Gets or sets the thread count used for encoding.
|
|
#[serde(rename = "AudioCodec")]
|
|
pub audio_codec: Option<String>,
|
|
/// Gets or sets the thread count used for encoding.
|
|
#[serde(rename = "VideoCodec")]
|
|
pub video_codec: Option<String>,
|
|
/// Gets or sets the thread count used for encoding.
|
|
#[serde(rename = "Container")]
|
|
pub container: Option<String>,
|
|
/// Gets or sets a value indicating whether the video is passed through.
|
|
#[serde(rename = "IsVideoDirect")]
|
|
pub is_video_direct: bool,
|
|
/// Gets or sets a value indicating whether the audio is passed through.
|
|
#[serde(rename = "IsAudioDirect")]
|
|
pub is_audio_direct: bool,
|
|
/// Gets or sets the bitrate.
|
|
#[serde(rename = "Bitrate")]
|
|
pub bitrate: Option<i32>,
|
|
/// Gets or sets the framerate.
|
|
#[serde(rename = "Framerate")]
|
|
pub framerate: Option<f32>,
|
|
/// Gets or sets the completion percentage.
|
|
#[serde(rename = "CompletionPercentage")]
|
|
pub completion_percentage: Option<f64>,
|
|
/// Gets or sets the video width.
|
|
#[serde(rename = "Width")]
|
|
pub width: Option<i32>,
|
|
/// Gets or sets the video height.
|
|
#[serde(rename = "Height")]
|
|
pub height: Option<i32>,
|
|
/// Gets or sets the audio channels.
|
|
#[serde(rename = "AudioChannels")]
|
|
pub audio_channels: Option<i32>,
|
|
/// Gets or sets the hardware acceleration type.
|
|
#[serde(rename = "HardwareAccelerationType")]
|
|
pub hardware_acceleration_type: Option<HardwareAccelerationType>,
|
|
/// Gets or sets the transcode reasons.
|
|
#[serde(rename = "TranscodeReasons")]
|
|
pub transcode_reasons: Vec<TranscodeReason>,
|
|
}
|
|
/** A class for transcoding profile information.
|
|
Note for client developers: Conditions defined in MediaBrowser.Model.Dlna.CodecProfile has higher priority and can override values defined here.*/
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct TranscodingProfile {
|
|
/// Gets or sets the container.
|
|
#[serde(rename = "Container")]
|
|
pub container: String,
|
|
/// Gets or sets the DLNA profile type.
|
|
#[serde(rename = "Type")]
|
|
pub _type: DlnaProfileType,
|
|
/// Gets or sets the video codec.
|
|
#[serde(rename = "VideoCodec")]
|
|
pub video_codec: String,
|
|
/// Gets or sets the audio codec.
|
|
#[serde(rename = "AudioCodec")]
|
|
pub audio_codec: String,
|
|
/// Gets or sets the protocol.
|
|
#[serde(rename = "Protocol")]
|
|
pub protocol: MediaStreamProtocol,
|
|
/// Gets or sets a value indicating whether the content length should be estimated.
|
|
#[serde(rename = "EstimateContentLength")]
|
|
pub estimate_content_length: bool,
|
|
/// Gets or sets a value indicating whether M2TS mode is enabled.
|
|
#[serde(rename = "EnableMpegtsM2TsMode")]
|
|
pub enable_mpegts_m2_ts_mode: bool,
|
|
/// Gets or sets the transcoding seek info mode.
|
|
#[serde(rename = "TranscodeSeekInfo")]
|
|
pub transcode_seek_info: TranscodeSeekInfo,
|
|
/// Gets or sets a value indicating whether timestamps should be copied.
|
|
#[serde(rename = "CopyTimestamps")]
|
|
pub copy_timestamps: bool,
|
|
/// Gets or sets the encoding context.
|
|
#[serde(rename = "Context")]
|
|
pub context: EncodingContext,
|
|
/// Gets or sets a value indicating whether subtitles are allowed in the manifest.
|
|
#[serde(rename = "EnableSubtitlesInManifest")]
|
|
pub enable_subtitles_in_manifest: bool,
|
|
/// Gets or sets the maximum audio channels.
|
|
#[serde(rename = "MaxAudioChannels")]
|
|
pub max_audio_channels: Option<String>,
|
|
/// Gets or sets the minimum amount of segments.
|
|
#[serde(rename = "MinSegments")]
|
|
pub min_segments: i32,
|
|
/// Gets or sets the segment length.
|
|
#[serde(rename = "SegmentLength")]
|
|
pub segment_length: i32,
|
|
/// Gets or sets a value indicating whether breaking the video stream on non-keyframes is supported.
|
|
#[serde(rename = "BreakOnNonKeyFrames")]
|
|
pub break_on_non_key_frames: bool,
|
|
/// Gets or sets the profile conditions.
|
|
#[serde(rename = "Conditions")]
|
|
pub conditions: Vec<ProfileCondition>,
|
|
/// Gets or sets a value indicating whether variable bitrate encoding is supported.
|
|
#[serde(rename = "EnableAudioVbrEncoding")]
|
|
pub enable_audio_vbr_encoding: bool,
|
|
}
|
|
/// An entity representing the metadata for a group of trickplay tiles.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct TrickplayInfo {
|
|
/// Gets or sets width of an individual thumbnail.
|
|
#[serde(rename = "Width")]
|
|
pub width: i32,
|
|
/// Gets or sets height of an individual thumbnail.
|
|
#[serde(rename = "Height")]
|
|
pub height: i32,
|
|
/// Gets or sets amount of thumbnails per row.
|
|
#[serde(rename = "TileWidth")]
|
|
pub tile_width: i32,
|
|
/// Gets or sets amount of thumbnails per column.
|
|
#[serde(rename = "TileHeight")]
|
|
pub tile_height: i32,
|
|
/// Gets or sets total amount of non-black thumbnails.
|
|
#[serde(rename = "ThumbnailCount")]
|
|
pub thumbnail_count: i32,
|
|
/// Gets or sets interval in milliseconds between each trickplay thumbnail.
|
|
#[serde(rename = "Interval")]
|
|
pub interval: i32,
|
|
/// Gets or sets peak bandwith usage in bits per second.
|
|
#[serde(rename = "Bandwidth")]
|
|
pub bandwidth: i32,
|
|
}
|
|
/// Class TrickplayOptions.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct TrickplayOptions {
|
|
/// Gets or sets a value indicating whether or not to use HW acceleration.
|
|
#[serde(rename = "EnableHwAcceleration")]
|
|
pub enable_hw_acceleration: bool,
|
|
/// Gets or sets a value indicating whether or not to use HW accelerated MJPEG encoding.
|
|
#[serde(rename = "EnableHwEncoding")]
|
|
pub enable_hw_encoding: bool,
|
|
/** Gets or sets a value indicating whether to only extract key frames.
|
|
Significantly faster, but is not compatible with all decoders and/or video files.*/
|
|
#[serde(rename = "EnableKeyFrameOnlyExtraction")]
|
|
pub enable_key_frame_only_extraction: bool,
|
|
/// Gets or sets the behavior used by trickplay provider on library scan/update.
|
|
#[serde(rename = "ScanBehavior")]
|
|
pub scan_behavior: TrickplayScanBehavior,
|
|
/// Gets or sets the process priority for the ffmpeg process.
|
|
#[serde(rename = "ProcessPriority")]
|
|
pub process_priority: ProcessPriorityClass,
|
|
/// Gets or sets the interval, in ms, between each new trickplay image.
|
|
#[serde(rename = "Interval")]
|
|
pub interval: i32,
|
|
/// Gets or sets the target width resolutions, in px, to generates preview images for.
|
|
#[serde(rename = "WidthResolutions")]
|
|
pub width_resolutions: Vec<i32>,
|
|
/// Gets or sets number of tile images to allow in X dimension.
|
|
#[serde(rename = "TileWidth")]
|
|
pub tile_width: i32,
|
|
/// Gets or sets number of tile images to allow in Y dimension.
|
|
#[serde(rename = "TileHeight")]
|
|
pub tile_height: i32,
|
|
/// Gets or sets the ffmpeg output quality level.
|
|
#[serde(rename = "Qscale")]
|
|
pub qscale: i32,
|
|
/// Gets or sets the jpeg quality to use for image tiles.
|
|
#[serde(rename = "JpegQuality")]
|
|
pub jpeg_quality: i32,
|
|
/// Gets or sets the number of threads to be used by ffmpeg.
|
|
#[serde(rename = "ProcessThreads")]
|
|
pub process_threads: i32,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct TunerChannelMapping {
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
#[serde(rename = "ProviderChannelName")]
|
|
pub provider_channel_name: Option<String>,
|
|
#[serde(rename = "ProviderChannelId")]
|
|
pub provider_channel_id: Option<String>,
|
|
#[serde(rename = "Id")]
|
|
pub id: Option<String>,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct TunerHostInfo {
|
|
#[serde(rename = "Id")]
|
|
pub id: Option<String>,
|
|
#[serde(rename = "Url")]
|
|
pub url: Option<String>,
|
|
#[serde(rename = "Type")]
|
|
pub _type: Option<String>,
|
|
#[serde(rename = "DeviceId")]
|
|
pub device_id: Option<String>,
|
|
#[serde(rename = "FriendlyName")]
|
|
pub friendly_name: Option<String>,
|
|
#[serde(rename = "ImportFavoritesOnly")]
|
|
pub import_favorites_only: bool,
|
|
#[serde(rename = "AllowHWTranscoding")]
|
|
pub allow_hw_transcoding: bool,
|
|
#[serde(rename = "AllowFmp4TranscodingContainer")]
|
|
pub allow_fmp4_transcoding_container: bool,
|
|
#[serde(rename = "AllowStreamSharing")]
|
|
pub allow_stream_sharing: bool,
|
|
#[serde(rename = "FallbackMaxStreamingBitrate")]
|
|
pub fallback_max_streaming_bitrate: i32,
|
|
#[serde(rename = "EnableStreamLooping")]
|
|
pub enable_stream_looping: bool,
|
|
#[serde(rename = "Source")]
|
|
pub source: Option<String>,
|
|
#[serde(rename = "TunerCount")]
|
|
pub tuner_count: i32,
|
|
#[serde(rename = "UserAgent")]
|
|
pub user_agent: Option<String>,
|
|
#[serde(rename = "IgnoreDts")]
|
|
pub ignore_dts: bool,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct TypeOptions {
|
|
#[serde(rename = "Type")]
|
|
pub _type: Option<String>,
|
|
#[serde(rename = "MetadataFetchers")]
|
|
pub metadata_fetchers: Option<Vec<String>>,
|
|
#[serde(rename = "MetadataFetcherOrder")]
|
|
pub metadata_fetcher_order: Option<Vec<String>>,
|
|
#[serde(rename = "ImageFetchers")]
|
|
pub image_fetchers: Option<Vec<String>>,
|
|
#[serde(rename = "ImageFetcherOrder")]
|
|
pub image_fetcher_order: Option<Vec<String>>,
|
|
#[serde(rename = "ImageOptions")]
|
|
pub image_options: Option<Vec<ImageOption>>,
|
|
}
|
|
/// Update library options dto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct UpdateLibraryOptionsDto {
|
|
/// Gets or sets the library item id.
|
|
#[serde(rename = "Id")]
|
|
pub id: uuid::Uuid,
|
|
/// Gets or sets library options.
|
|
#[serde(rename = "LibraryOptions")]
|
|
pub library_options: Option<LibraryOptions>,
|
|
}
|
|
/// Update library options dto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct UpdateMediaPathRequestDto {
|
|
/// Gets or sets the library name.
|
|
#[serde(rename = "Name")]
|
|
pub name: String,
|
|
/// Gets or sets library folder path information.
|
|
#[serde(rename = "PathInfo")]
|
|
pub path_info: MediaPathInfo,
|
|
}
|
|
/// Update existing playlist dto. Fields set to `null` will not be updated and keep their current values.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct UpdatePlaylistDto {
|
|
/// Gets or sets the name of the new playlist.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets item ids of the playlist.
|
|
#[serde(rename = "Ids")]
|
|
pub ids: Option<Vec<uuid::Uuid>>,
|
|
/// Gets or sets the playlist users.
|
|
#[serde(rename = "Users")]
|
|
pub users: Option<Vec<PlaylistUserPermissions>>,
|
|
/// Gets or sets a value indicating whether the playlist is public.
|
|
#[serde(rename = "IsPublic")]
|
|
pub is_public: Option<bool>,
|
|
}
|
|
/// Update existing playlist user dto. Fields set to `null` will not be updated and keep their current values.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct UpdatePlaylistUserDto {
|
|
/// Gets or sets a value indicating whether the user can edit the playlist.
|
|
#[serde(rename = "CanEdit")]
|
|
pub can_edit: Option<bool>,
|
|
}
|
|
/// This is used by the api to get information about a item user data.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct UpdateUserItemDataDto {
|
|
/// Gets or sets the rating.
|
|
#[serde(rename = "Rating")]
|
|
pub rating: Option<f64>,
|
|
/// Gets or sets the played percentage.
|
|
#[serde(rename = "PlayedPercentage")]
|
|
pub played_percentage: Option<f64>,
|
|
/// Gets or sets the unplayed item count.
|
|
#[serde(rename = "UnplayedItemCount")]
|
|
pub unplayed_item_count: Option<i32>,
|
|
/// Gets or sets the playback position ticks.
|
|
#[serde(rename = "PlaybackPositionTicks")]
|
|
pub playback_position_ticks: Option<i64>,
|
|
/// Gets or sets the play count.
|
|
#[serde(rename = "PlayCount")]
|
|
pub play_count: Option<i32>,
|
|
/// Gets or sets a value indicating whether this instance is favorite.
|
|
#[serde(rename = "IsFavorite")]
|
|
pub is_favorite: Option<bool>,
|
|
/// Gets or sets a value indicating whether this MediaBrowser.Model.Dto.UpdateUserItemDataDto is likes.
|
|
#[serde(rename = "Likes")]
|
|
pub likes: Option<bool>,
|
|
/// Gets or sets the last played date.
|
|
#[serde(rename = "LastPlayedDate")]
|
|
pub last_played_date: Option<jiff::Zoned>,
|
|
/// Gets or sets a value indicating whether this MediaBrowser.Model.Dto.UserItemDataDto is played.
|
|
#[serde(rename = "Played")]
|
|
pub played: Option<bool>,
|
|
/// Gets or sets the key.
|
|
#[serde(rename = "Key")]
|
|
pub key: Option<String>,
|
|
/// Gets or sets the item identifier.
|
|
#[serde(rename = "ItemId")]
|
|
pub item_id: Option<String>,
|
|
}
|
|
/// The update user password request body.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct UpdateUserPassword {
|
|
/// Gets or sets the current sha1-hashed password.
|
|
#[serde(rename = "CurrentPassword")]
|
|
pub current_password: Option<String>,
|
|
/// Gets or sets the current plain text password.
|
|
#[serde(rename = "CurrentPw")]
|
|
pub current_pw: Option<String>,
|
|
/// Gets or sets the new plain text password.
|
|
#[serde(rename = "NewPw")]
|
|
pub new_pw: Option<String>,
|
|
/// Gets or sets a value indicating whether to reset the password.
|
|
#[serde(rename = "ResetPassword")]
|
|
pub reset_password: bool,
|
|
}
|
|
/// Upload subtitles dto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct UploadSubtitleDto {
|
|
/// Gets or sets the subtitle language.
|
|
#[serde(rename = "Language")]
|
|
pub language: String,
|
|
/// Gets or sets the subtitle format.
|
|
#[serde(rename = "Format")]
|
|
pub format: String,
|
|
/// Gets or sets a value indicating whether the subtitle is forced.
|
|
#[serde(rename = "IsForced")]
|
|
pub is_forced: bool,
|
|
/// Gets or sets a value indicating whether the subtitle is for hearing impaired.
|
|
#[serde(rename = "IsHearingImpaired")]
|
|
pub is_hearing_impaired: bool,
|
|
/// Gets or sets the subtitle data.
|
|
#[serde(rename = "Data")]
|
|
pub data: String,
|
|
}
|
|
/// Class UserConfiguration.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct UserConfiguration {
|
|
/// Gets or sets the audio language preference.
|
|
#[serde(rename = "AudioLanguagePreference")]
|
|
pub audio_language_preference: Option<String>,
|
|
/// Gets or sets a value indicating whether [play default audio track].
|
|
#[serde(rename = "PlayDefaultAudioTrack")]
|
|
pub play_default_audio_track: bool,
|
|
/// Gets or sets the subtitle language preference.
|
|
#[serde(rename = "SubtitleLanguagePreference")]
|
|
pub subtitle_language_preference: Option<String>,
|
|
#[serde(rename = "DisplayMissingEpisodes")]
|
|
pub display_missing_episodes: bool,
|
|
#[serde(rename = "GroupedFolders")]
|
|
pub grouped_folders: Vec<uuid::Uuid>,
|
|
/// An enum representing a subtitle playback mode.
|
|
#[serde(rename = "SubtitleMode")]
|
|
pub subtitle_mode: SubtitlePlaybackMode,
|
|
#[serde(rename = "DisplayCollectionsView")]
|
|
pub display_collections_view: bool,
|
|
#[serde(rename = "EnableLocalPassword")]
|
|
pub enable_local_password: bool,
|
|
#[serde(rename = "OrderedViews")]
|
|
pub ordered_views: Vec<uuid::Uuid>,
|
|
#[serde(rename = "LatestItemsExcludes")]
|
|
pub latest_items_excludes: Vec<uuid::Uuid>,
|
|
#[serde(rename = "MyMediaExcludes")]
|
|
pub my_media_excludes: Vec<uuid::Uuid>,
|
|
#[serde(rename = "HidePlayedInLatest")]
|
|
pub hide_played_in_latest: bool,
|
|
#[serde(rename = "RememberAudioSelections")]
|
|
pub remember_audio_selections: bool,
|
|
#[serde(rename = "RememberSubtitleSelections")]
|
|
pub remember_subtitle_selections: bool,
|
|
#[serde(rename = "EnableNextEpisodeAutoPlay")]
|
|
pub enable_next_episode_auto_play: bool,
|
|
/// Gets or sets the id of the selected cast receiver.
|
|
#[serde(rename = "CastReceiverId")]
|
|
pub cast_receiver_id: Option<String>,
|
|
}
|
|
/// User data changed message.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct UserDataChangedMessage {
|
|
/// Class UserDataChangeInfo.
|
|
#[serde(rename = "Data")]
|
|
pub data: Option<UserDataChangeInfo>,
|
|
/// Gets or sets the message id.
|
|
#[serde(rename = "MessageId")]
|
|
pub message_id: uuid::Uuid,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Class UserDataChangeInfo.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct UserDataChangeInfo {
|
|
/// Gets or sets the user id.
|
|
#[serde(rename = "UserId")]
|
|
pub user_id: uuid::Uuid,
|
|
/// Gets or sets the user data list.
|
|
#[serde(rename = "UserDataList")]
|
|
pub user_data_list: Vec<UserItemDataDto>,
|
|
}
|
|
/// User deleted message.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct UserDeletedMessage {
|
|
/// Gets or sets the data.
|
|
#[serde(rename = "Data")]
|
|
pub data: uuid::Uuid,
|
|
/// Gets or sets the message id.
|
|
#[serde(rename = "MessageId")]
|
|
pub message_id: uuid::Uuid,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Class UserDto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct UserDto {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the server identifier.
|
|
#[serde(rename = "ServerId")]
|
|
pub server_id: Option<String>,
|
|
/** Gets or sets the name of the server.
|
|
This is not used by the server and is for client-side usage only.*/
|
|
#[serde(rename = "ServerName")]
|
|
pub server_name: Option<String>,
|
|
/// Gets or sets the id.
|
|
#[serde(rename = "Id")]
|
|
pub id: uuid::Uuid,
|
|
/// Gets or sets the primary image tag.
|
|
#[serde(rename = "PrimaryImageTag")]
|
|
pub primary_image_tag: Option<String>,
|
|
/// Gets or sets a value indicating whether this instance has password.
|
|
#[serde(rename = "HasPassword")]
|
|
pub has_password: bool,
|
|
/// Gets or sets a value indicating whether this instance has configured password.
|
|
#[serde(rename = "HasConfiguredPassword")]
|
|
pub has_configured_password: bool,
|
|
/// Gets or sets a value indicating whether this instance has configured easy password.
|
|
#[serde(rename = "HasConfiguredEasyPassword")]
|
|
pub has_configured_easy_password: bool,
|
|
/// Gets or sets whether async login is enabled or not.
|
|
#[serde(rename = "EnableAutoLogin")]
|
|
pub enable_auto_login: Option<bool>,
|
|
/// Gets or sets the last login date.
|
|
#[serde(rename = "LastLoginDate")]
|
|
pub last_login_date: Option<jiff::Zoned>,
|
|
/// Gets or sets the last activity date.
|
|
#[serde(rename = "LastActivityDate")]
|
|
pub last_activity_date: Option<jiff::Zoned>,
|
|
/// Gets or sets the configuration.
|
|
#[serde(rename = "Configuration")]
|
|
pub configuration: Option<UserConfiguration>,
|
|
/// Gets or sets the policy.
|
|
#[serde(rename = "Policy")]
|
|
pub policy: Option<UserPolicy>,
|
|
/// Gets or sets the primary image aspect ratio.
|
|
#[serde(rename = "PrimaryImageAspectRatio")]
|
|
pub primary_image_aspect_ratio: Option<f64>,
|
|
}
|
|
/// Class UserItemDataDto.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct UserItemDataDto {
|
|
/// Gets or sets the rating.
|
|
#[serde(rename = "Rating")]
|
|
pub rating: Option<f64>,
|
|
/// Gets or sets the played percentage.
|
|
#[serde(rename = "PlayedPercentage")]
|
|
pub played_percentage: Option<f64>,
|
|
/// Gets or sets the unplayed item count.
|
|
#[serde(rename = "UnplayedItemCount")]
|
|
pub unplayed_item_count: Option<i32>,
|
|
/// Gets or sets the playback position ticks.
|
|
#[serde(rename = "PlaybackPositionTicks")]
|
|
pub playback_position_ticks: i64,
|
|
/// Gets or sets the play count.
|
|
#[serde(rename = "PlayCount")]
|
|
pub play_count: i32,
|
|
/// Gets or sets a value indicating whether this instance is favorite.
|
|
#[serde(rename = "IsFavorite")]
|
|
pub is_favorite: bool,
|
|
/// Gets or sets a value indicating whether this MediaBrowser.Model.Dto.UserItemDataDto is likes.
|
|
#[serde(rename = "Likes")]
|
|
pub likes: Option<bool>,
|
|
/// Gets or sets the last played date.
|
|
#[serde(rename = "LastPlayedDate")]
|
|
pub last_played_date: Option<jiff::Zoned>,
|
|
/// Gets or sets a value indicating whether this MediaBrowser.Model.Dto.UserItemDataDto is played.
|
|
#[serde(rename = "Played")]
|
|
pub played: bool,
|
|
/// Gets or sets the key.
|
|
#[serde(rename = "Key")]
|
|
pub key: String,
|
|
/// Gets or sets the item identifier.
|
|
#[serde(rename = "ItemId")]
|
|
pub item_id: uuid::Uuid,
|
|
}
|
|
/// Query result container.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct UserItemDataDtoQueryResult {
|
|
/// Gets or sets the items.
|
|
#[serde(rename = "Items")]
|
|
pub items: Vec<UserItemDataDto>,
|
|
/// Gets or sets the total number of records available.
|
|
#[serde(rename = "TotalRecordCount")]
|
|
pub total_record_count: i32,
|
|
/// Gets or sets the index of the first record in Items.
|
|
#[serde(rename = "StartIndex")]
|
|
pub start_index: i32,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct UserPolicy {
|
|
/// Gets or sets a value indicating whether this instance is administrator.
|
|
#[serde(rename = "IsAdministrator")]
|
|
pub is_administrator: bool,
|
|
/// Gets or sets a value indicating whether this instance is hidden.
|
|
#[serde(rename = "IsHidden")]
|
|
pub is_hidden: bool,
|
|
/// Gets or sets a value indicating whether this instance can manage collections.
|
|
#[serde(rename = "EnableCollectionManagement")]
|
|
pub enable_collection_management: bool,
|
|
/// Gets or sets a value indicating whether this instance can manage subtitles.
|
|
#[serde(rename = "EnableSubtitleManagement")]
|
|
pub enable_subtitle_management: bool,
|
|
/// Gets or sets a value indicating whether this user can manage lyrics.
|
|
#[serde(rename = "EnableLyricManagement")]
|
|
pub enable_lyric_management: bool,
|
|
/// Gets or sets a value indicating whether this instance is disabled.
|
|
#[serde(rename = "IsDisabled")]
|
|
pub is_disabled: bool,
|
|
/// Gets or sets the max parental rating.
|
|
#[serde(rename = "MaxParentalRating")]
|
|
pub max_parental_rating: Option<i32>,
|
|
#[serde(rename = "BlockedTags")]
|
|
pub blocked_tags: Option<Vec<String>>,
|
|
#[serde(rename = "AllowedTags")]
|
|
pub allowed_tags: Option<Vec<String>>,
|
|
#[serde(rename = "EnableUserPreferenceAccess")]
|
|
pub enable_user_preference_access: bool,
|
|
#[serde(rename = "AccessSchedules")]
|
|
pub access_schedules: Option<Vec<AccessSchedule>>,
|
|
#[serde(rename = "BlockUnratedItems")]
|
|
pub block_unrated_items: Option<Vec<UnratedItem>>,
|
|
#[serde(rename = "EnableRemoteControlOfOtherUsers")]
|
|
pub enable_remote_control_of_other_users: bool,
|
|
#[serde(rename = "EnableSharedDeviceControl")]
|
|
pub enable_shared_device_control: bool,
|
|
#[serde(rename = "EnableRemoteAccess")]
|
|
pub enable_remote_access: bool,
|
|
#[serde(rename = "EnableLiveTvManagement")]
|
|
pub enable_live_tv_management: bool,
|
|
#[serde(rename = "EnableLiveTvAccess")]
|
|
pub enable_live_tv_access: bool,
|
|
#[serde(rename = "EnableMediaPlayback")]
|
|
pub enable_media_playback: bool,
|
|
#[serde(rename = "EnableAudioPlaybackTranscoding")]
|
|
pub enable_audio_playback_transcoding: bool,
|
|
#[serde(rename = "EnableVideoPlaybackTranscoding")]
|
|
pub enable_video_playback_transcoding: bool,
|
|
#[serde(rename = "EnablePlaybackRemuxing")]
|
|
pub enable_playback_remuxing: bool,
|
|
#[serde(rename = "ForceRemoteSourceTranscoding")]
|
|
pub force_remote_source_transcoding: bool,
|
|
#[serde(rename = "EnableContentDeletion")]
|
|
pub enable_content_deletion: bool,
|
|
#[serde(rename = "EnableContentDeletionFromFolders")]
|
|
pub enable_content_deletion_from_folders: Option<Vec<String>>,
|
|
#[serde(rename = "EnableContentDownloading")]
|
|
pub enable_content_downloading: bool,
|
|
/// Gets or sets a value indicating whether [enable synchronize].
|
|
#[serde(rename = "EnableSyncTranscoding")]
|
|
pub enable_sync_transcoding: bool,
|
|
#[serde(rename = "EnableMediaConversion")]
|
|
pub enable_media_conversion: bool,
|
|
#[serde(rename = "EnabledDevices")]
|
|
pub enabled_devices: Option<Vec<String>>,
|
|
#[serde(rename = "EnableAllDevices")]
|
|
pub enable_all_devices: bool,
|
|
#[serde(rename = "EnabledChannels")]
|
|
pub enabled_channels: Option<Vec<uuid::Uuid>>,
|
|
#[serde(rename = "EnableAllChannels")]
|
|
pub enable_all_channels: bool,
|
|
#[serde(rename = "EnabledFolders")]
|
|
pub enabled_folders: Option<Vec<uuid::Uuid>>,
|
|
#[serde(rename = "EnableAllFolders")]
|
|
pub enable_all_folders: bool,
|
|
#[serde(rename = "InvalidLoginAttemptCount")]
|
|
pub invalid_login_attempt_count: i32,
|
|
#[serde(rename = "LoginAttemptsBeforeLockout")]
|
|
pub login_attempts_before_lockout: i32,
|
|
#[serde(rename = "MaxActiveSessions")]
|
|
pub max_active_sessions: i32,
|
|
#[serde(rename = "EnablePublicSharing")]
|
|
pub enable_public_sharing: bool,
|
|
#[serde(rename = "BlockedMediaFolders")]
|
|
pub blocked_media_folders: Option<Vec<uuid::Uuid>>,
|
|
#[serde(rename = "BlockedChannels")]
|
|
pub blocked_channels: Option<Vec<uuid::Uuid>>,
|
|
#[serde(rename = "RemoteClientBitrateLimit")]
|
|
pub remote_client_bitrate_limit: i32,
|
|
#[serde(rename = "AuthenticationProviderId")]
|
|
pub authentication_provider_id: String,
|
|
#[serde(rename = "PasswordResetProviderId")]
|
|
pub password_reset_provider_id: String,
|
|
/// Gets or sets a value indicating what SyncPlay features the user can access.
|
|
#[serde(rename = "SyncPlayAccess")]
|
|
pub sync_play_access: SyncPlayUserAccessType,
|
|
}
|
|
/// User updated message.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct UserUpdatedMessage {
|
|
/// Class UserDto.
|
|
#[serde(rename = "Data")]
|
|
pub data: Option<UserDto>,
|
|
/// Gets or sets the message id.
|
|
#[serde(rename = "MessageId")]
|
|
pub message_id: uuid::Uuid,
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[serde(rename = "MessageType")]
|
|
pub message_type: SessionMessageType,
|
|
}
|
|
/// Class UtcTimeResponse.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct UtcTimeResponse {
|
|
/// Gets the UTC time when request has been received.
|
|
#[serde(rename = "RequestReceptionTime")]
|
|
pub request_reception_time: jiff::Zoned,
|
|
/// Gets the UTC time when response has been sent.
|
|
#[serde(rename = "ResponseTransmissionTime")]
|
|
pub response_transmission_time: jiff::Zoned,
|
|
}
|
|
/// Validate path object.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct ValidatePathDto {
|
|
/// Gets or sets a value indicating whether validate if path is writable.
|
|
#[serde(rename = "ValidateWritable")]
|
|
pub validate_writable: bool,
|
|
/// Gets or sets the path.
|
|
#[serde(rename = "Path")]
|
|
pub path: Option<String>,
|
|
/// Gets or sets is path file.
|
|
#[serde(rename = "IsFile")]
|
|
pub is_file: Option<bool>,
|
|
}
|
|
/// Defines the MediaBrowser.Model.Updates.VersionInfo class.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct VersionInfo {
|
|
/// Gets or sets the version.
|
|
#[serde(rename = "version")]
|
|
pub version: String,
|
|
/// Gets the version as a System.Version.
|
|
#[serde(rename = "VersionNumber")]
|
|
pub version_number: String,
|
|
/// Gets or sets the changelog for this version.
|
|
#[serde(rename = "changelog")]
|
|
pub changelog: Option<String>,
|
|
/// Gets or sets the ABI that this version was built against.
|
|
#[serde(rename = "targetAbi")]
|
|
pub target_abi: Option<String>,
|
|
/// Gets or sets the source URL.
|
|
#[serde(rename = "sourceUrl")]
|
|
pub source_url: Option<String>,
|
|
/// Gets or sets a checksum for the binary.
|
|
#[serde(rename = "checksum")]
|
|
pub checksum: Option<String>,
|
|
/// Gets or sets a timestamp of when the binary was built.
|
|
#[serde(rename = "timestamp")]
|
|
pub timestamp: Option<String>,
|
|
/// Gets or sets the repository name.
|
|
#[serde(rename = "repositoryName")]
|
|
pub repository_name: String,
|
|
/// Gets or sets the repository url.
|
|
#[serde(rename = "repositoryUrl")]
|
|
pub repository_url: String,
|
|
}
|
|
/// Used to hold information about a user's list of configured virtual folders.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct VirtualFolderInfo {
|
|
/// Gets or sets the name.
|
|
#[serde(rename = "Name")]
|
|
pub name: Option<String>,
|
|
/// Gets or sets the locations.
|
|
#[serde(rename = "Locations")]
|
|
pub locations: Option<Vec<String>>,
|
|
/// Gets or sets the type of the collection.
|
|
#[serde(rename = "CollectionType")]
|
|
pub collection_type: Option<CollectionTypeOptions>,
|
|
#[serde(rename = "LibraryOptions")]
|
|
pub library_options: Option<LibraryOptions>,
|
|
/// Gets or sets the item identifier.
|
|
#[serde(rename = "ItemId")]
|
|
pub item_id: Option<String>,
|
|
/// Gets or sets the primary image item identifier.
|
|
#[serde(rename = "PrimaryImageItemId")]
|
|
pub primary_image_item_id: Option<String>,
|
|
#[serde(rename = "RefreshProgress")]
|
|
pub refresh_progress: Option<f64>,
|
|
#[serde(rename = "RefreshStatus")]
|
|
pub refresh_status: Option<String>,
|
|
}
|
|
/// Provides the MAC address and port for wake-on-LAN functionality.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct WakeOnLanInfo {
|
|
/// Gets the MAC address of the device.
|
|
#[serde(rename = "MacAddress")]
|
|
pub mac_address: Option<String>,
|
|
/// Gets or sets the wake-on-LAN port.
|
|
#[serde(rename = "Port")]
|
|
pub port: i32,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct XbmcMetadataOptions {
|
|
#[serde(rename = "UserId")]
|
|
pub user_id: Option<String>,
|
|
#[serde(rename = "ReleaseDateFormat")]
|
|
pub release_date_format: String,
|
|
#[serde(rename = "SaveImagePathsInNfo")]
|
|
pub save_image_paths_in_nfo: bool,
|
|
#[serde(rename = "EnablePathSubstitution")]
|
|
pub enable_path_substitution: bool,
|
|
#[serde(rename = "EnableExtraThumbsDuplication")]
|
|
pub enable_extra_thumbs_duplication: bool,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum ApiName {
|
|
#[serde(rename = "Mal")]
|
|
Mal,
|
|
#[serde(rename = "AniList")]
|
|
AniList,
|
|
#[serde(rename = "Kitsu")]
|
|
Kitsu,
|
|
#[serde(rename = "Annict")]
|
|
Annict,
|
|
#[serde(rename = "Shikimori")]
|
|
Shikimori,
|
|
#[serde(rename = "Simkl")]
|
|
Simkl,
|
|
}
|
|
/// An enum representing formats of spatial audio.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum AudioSpatialFormat {
|
|
#[serde(rename = "None")]
|
|
None,
|
|
#[serde(rename = "DolbyAtmos")]
|
|
DolbyAtmos,
|
|
#[serde(rename = "DTSX")]
|
|
Dtsx,
|
|
}
|
|
/// The base item kind.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum BaseItemKind {
|
|
#[serde(rename = "AggregateFolder")]
|
|
AggregateFolder,
|
|
#[serde(rename = "Audio")]
|
|
Audio,
|
|
#[serde(rename = "AudioBook")]
|
|
AudioBook,
|
|
#[serde(rename = "BasePluginFolder")]
|
|
BasePluginFolder,
|
|
#[serde(rename = "Book")]
|
|
Book,
|
|
#[serde(rename = "BoxSet")]
|
|
BoxSet,
|
|
#[serde(rename = "Channel")]
|
|
Channel,
|
|
#[serde(rename = "ChannelFolderItem")]
|
|
ChannelFolderItem,
|
|
#[serde(rename = "CollectionFolder")]
|
|
CollectionFolder,
|
|
#[serde(rename = "Episode")]
|
|
Episode,
|
|
#[serde(rename = "Folder")]
|
|
Folder,
|
|
#[serde(rename = "Genre")]
|
|
Genre,
|
|
#[serde(rename = "ManualPlaylistsFolder")]
|
|
ManualPlaylistsFolder,
|
|
#[serde(rename = "Movie")]
|
|
Movie,
|
|
#[serde(rename = "LiveTvChannel")]
|
|
LiveTvChannel,
|
|
#[serde(rename = "LiveTvProgram")]
|
|
LiveTvProgram,
|
|
#[serde(rename = "MusicAlbum")]
|
|
MusicAlbum,
|
|
#[serde(rename = "MusicArtist")]
|
|
MusicArtist,
|
|
#[serde(rename = "MusicGenre")]
|
|
MusicGenre,
|
|
#[serde(rename = "MusicVideo")]
|
|
MusicVideo,
|
|
#[serde(rename = "Person")]
|
|
Person,
|
|
#[serde(rename = "Photo")]
|
|
Photo,
|
|
#[serde(rename = "PhotoAlbum")]
|
|
PhotoAlbum,
|
|
#[serde(rename = "Playlist")]
|
|
Playlist,
|
|
#[serde(rename = "PlaylistsFolder")]
|
|
PlaylistsFolder,
|
|
#[serde(rename = "Program")]
|
|
Program,
|
|
#[serde(rename = "Recording")]
|
|
Recording,
|
|
#[serde(rename = "Season")]
|
|
Season,
|
|
#[serde(rename = "Series")]
|
|
Series,
|
|
#[serde(rename = "Studio")]
|
|
Studio,
|
|
#[serde(rename = "Trailer")]
|
|
Trailer,
|
|
#[serde(rename = "TvChannel")]
|
|
TvChannel,
|
|
#[serde(rename = "TvProgram")]
|
|
TvProgram,
|
|
#[serde(rename = "UserRootFolder")]
|
|
UserRootFolder,
|
|
#[serde(rename = "UserView")]
|
|
UserView,
|
|
#[serde(rename = "Video")]
|
|
Video,
|
|
#[serde(rename = "Year")]
|
|
Year,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum ChannelItemSortField {
|
|
#[serde(rename = "Name")]
|
|
Name,
|
|
#[serde(rename = "CommunityRating")]
|
|
CommunityRating,
|
|
#[serde(rename = "PremiereDate")]
|
|
PremiereDate,
|
|
#[serde(rename = "DateCreated")]
|
|
DateCreated,
|
|
#[serde(rename = "Runtime")]
|
|
Runtime,
|
|
#[serde(rename = "PlayCount")]
|
|
PlayCount,
|
|
#[serde(rename = "CommunityPlayCount")]
|
|
CommunityPlayCount,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum ChannelMediaContentType {
|
|
#[serde(rename = "Clip")]
|
|
Clip,
|
|
#[serde(rename = "Podcast")]
|
|
Podcast,
|
|
#[serde(rename = "Trailer")]
|
|
Trailer,
|
|
#[serde(rename = "Movie")]
|
|
Movie,
|
|
#[serde(rename = "Episode")]
|
|
Episode,
|
|
#[serde(rename = "Song")]
|
|
Song,
|
|
#[serde(rename = "MovieExtra")]
|
|
MovieExtra,
|
|
#[serde(rename = "TvExtra")]
|
|
TvExtra,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum ChannelMediaType {
|
|
#[serde(rename = "Audio")]
|
|
Audio,
|
|
#[serde(rename = "Video")]
|
|
Video,
|
|
#[serde(rename = "Photo")]
|
|
Photo,
|
|
}
|
|
/// Enum ChannelType.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum ChannelType {
|
|
#[serde(rename = "TV")]
|
|
Tv,
|
|
#[serde(rename = "Radio")]
|
|
Radio,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum CodecType {
|
|
#[serde(rename = "Video")]
|
|
Video,
|
|
#[serde(rename = "VideoAudio")]
|
|
VideoAudio,
|
|
#[serde(rename = "Audio")]
|
|
Audio,
|
|
}
|
|
/// Collection type.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum CollectionType {
|
|
#[serde(rename = "unknown")]
|
|
Unknown,
|
|
#[serde(rename = "movies")]
|
|
Movies,
|
|
#[serde(rename = "tvshows")]
|
|
Tvshows,
|
|
#[serde(rename = "music")]
|
|
Music,
|
|
#[serde(rename = "musicvideos")]
|
|
Musicvideos,
|
|
#[serde(rename = "trailers")]
|
|
Trailers,
|
|
#[serde(rename = "homevideos")]
|
|
Homevideos,
|
|
#[serde(rename = "boxsets")]
|
|
Boxsets,
|
|
#[serde(rename = "books")]
|
|
Books,
|
|
#[serde(rename = "photos")]
|
|
Photos,
|
|
#[serde(rename = "livetv")]
|
|
Livetv,
|
|
#[serde(rename = "playlists")]
|
|
Playlists,
|
|
#[serde(rename = "folders")]
|
|
Folders,
|
|
}
|
|
/// The collection type options.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum CollectionTypeOptions {
|
|
#[serde(rename = "movies")]
|
|
Movies,
|
|
#[serde(rename = "tvshows")]
|
|
Tvshows,
|
|
#[serde(rename = "music")]
|
|
Music,
|
|
#[serde(rename = "musicvideos")]
|
|
Musicvideos,
|
|
#[serde(rename = "homevideos")]
|
|
Homevideos,
|
|
#[serde(rename = "boxsets")]
|
|
Boxsets,
|
|
#[serde(rename = "books")]
|
|
Books,
|
|
#[serde(rename = "mixed")]
|
|
Mixed,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum DayOfWeek {
|
|
#[serde(rename = "Sunday")]
|
|
Sunday,
|
|
#[serde(rename = "Monday")]
|
|
Monday,
|
|
#[serde(rename = "Tuesday")]
|
|
Tuesday,
|
|
#[serde(rename = "Wednesday")]
|
|
Wednesday,
|
|
#[serde(rename = "Thursday")]
|
|
Thursday,
|
|
#[serde(rename = "Friday")]
|
|
Friday,
|
|
#[serde(rename = "Saturday")]
|
|
Saturday,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum DayPattern {
|
|
#[serde(rename = "Daily")]
|
|
Daily,
|
|
#[serde(rename = "Weekdays")]
|
|
Weekdays,
|
|
#[serde(rename = "Weekends")]
|
|
Weekends,
|
|
}
|
|
/// Enum containing deinterlace methods.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum DeinterlaceMethod {
|
|
#[serde(rename = "yadif")]
|
|
Yadif,
|
|
#[serde(rename = "bwdif")]
|
|
Bwdif,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum DlnaProfileType {
|
|
#[serde(rename = "Audio")]
|
|
Audio,
|
|
#[serde(rename = "Video")]
|
|
Video,
|
|
#[serde(rename = "Photo")]
|
|
Photo,
|
|
#[serde(rename = "Subtitle")]
|
|
Subtitle,
|
|
#[serde(rename = "Lyric")]
|
|
Lyric,
|
|
}
|
|
/// An enum representing an algorithm to downmix surround sound to stereo.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum DownMixStereoAlgorithms {
|
|
#[serde(rename = "None")]
|
|
None,
|
|
#[serde(rename = "Dave750")]
|
|
Dave750,
|
|
#[serde(rename = "NightmodeDialogue")]
|
|
NightmodeDialogue,
|
|
#[serde(rename = "Rfc7845")]
|
|
Rfc7845,
|
|
#[serde(rename = "Ac4")]
|
|
Ac4,
|
|
}
|
|
/// An enum that represents a day of the week, weekdays, weekends, or all days.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum DynamicDayOfWeek {
|
|
#[serde(rename = "Sunday")]
|
|
Sunday,
|
|
#[serde(rename = "Monday")]
|
|
Monday,
|
|
#[serde(rename = "Tuesday")]
|
|
Tuesday,
|
|
#[serde(rename = "Wednesday")]
|
|
Wednesday,
|
|
#[serde(rename = "Thursday")]
|
|
Thursday,
|
|
#[serde(rename = "Friday")]
|
|
Friday,
|
|
#[serde(rename = "Saturday")]
|
|
Saturday,
|
|
#[serde(rename = "Everyday")]
|
|
Everyday,
|
|
#[serde(rename = "Weekday")]
|
|
Weekday,
|
|
#[serde(rename = "Weekend")]
|
|
Weekend,
|
|
}
|
|
/// An enum representing the options to disable embedded subs.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum EmbeddedSubtitleOptions {
|
|
#[serde(rename = "AllowAll")]
|
|
AllowAll,
|
|
#[serde(rename = "AllowText")]
|
|
AllowText,
|
|
#[serde(rename = "AllowImage")]
|
|
AllowImage,
|
|
#[serde(rename = "AllowNone")]
|
|
AllowNone,
|
|
}
|
|
/// Enum containing encoder presets.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum EncoderPreset {
|
|
#[serde(rename = "auto")]
|
|
Auto,
|
|
#[serde(rename = "placebo")]
|
|
Placebo,
|
|
#[serde(rename = "veryslow")]
|
|
Veryslow,
|
|
#[serde(rename = "slower")]
|
|
Slower,
|
|
#[serde(rename = "slow")]
|
|
Slow,
|
|
#[serde(rename = "medium")]
|
|
Medium,
|
|
#[serde(rename = "fast")]
|
|
Fast,
|
|
#[serde(rename = "faster")]
|
|
Faster,
|
|
#[serde(rename = "veryfast")]
|
|
Veryfast,
|
|
#[serde(rename = "superfast")]
|
|
Superfast,
|
|
#[serde(rename = "ultrafast")]
|
|
Ultrafast,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum EncodingContext {
|
|
#[serde(rename = "Streaming")]
|
|
Streaming,
|
|
#[serde(rename = "Static")]
|
|
Static,
|
|
}
|
|
/// The specific media type of an MediaBrowser.Model.Providers.ExternalIdInfo.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum ExternalIdMediaType {
|
|
#[serde(rename = "Album")]
|
|
Album,
|
|
#[serde(rename = "AlbumArtist")]
|
|
AlbumArtist,
|
|
#[serde(rename = "Artist")]
|
|
Artist,
|
|
#[serde(rename = "BoxSet")]
|
|
BoxSet,
|
|
#[serde(rename = "Episode")]
|
|
Episode,
|
|
#[serde(rename = "Movie")]
|
|
Movie,
|
|
#[serde(rename = "OtherArtist")]
|
|
OtherArtist,
|
|
#[serde(rename = "Person")]
|
|
Person,
|
|
#[serde(rename = "ReleaseGroup")]
|
|
ReleaseGroup,
|
|
#[serde(rename = "Season")]
|
|
Season,
|
|
#[serde(rename = "Series")]
|
|
Series,
|
|
#[serde(rename = "Track")]
|
|
Track,
|
|
#[serde(rename = "Book")]
|
|
Book,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum ExtraType {
|
|
#[serde(rename = "Unknown")]
|
|
Unknown,
|
|
#[serde(rename = "Clip")]
|
|
Clip,
|
|
#[serde(rename = "Trailer")]
|
|
Trailer,
|
|
#[serde(rename = "BehindTheScenes")]
|
|
BehindTheScenes,
|
|
#[serde(rename = "DeletedScene")]
|
|
DeletedScene,
|
|
#[serde(rename = "Interview")]
|
|
Interview,
|
|
#[serde(rename = "Scene")]
|
|
Scene,
|
|
#[serde(rename = "Sample")]
|
|
Sample,
|
|
#[serde(rename = "ThemeSong")]
|
|
ThemeSong,
|
|
#[serde(rename = "ThemeVideo")]
|
|
ThemeVideo,
|
|
#[serde(rename = "Featurette")]
|
|
Featurette,
|
|
#[serde(rename = "Short")]
|
|
Short,
|
|
}
|
|
/// Enum FileSystemEntryType.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum FileSystemEntryType {
|
|
#[serde(rename = "File")]
|
|
File,
|
|
#[serde(rename = "Directory")]
|
|
Directory,
|
|
#[serde(rename = "NetworkComputer")]
|
|
NetworkComputer,
|
|
#[serde(rename = "NetworkShare")]
|
|
NetworkShare,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum ForgotPasswordAction {
|
|
#[serde(rename = "ContactAdmin")]
|
|
ContactAdmin,
|
|
#[serde(rename = "PinCode")]
|
|
PinCode,
|
|
#[serde(rename = "InNetworkRequired")]
|
|
InNetworkRequired,
|
|
}
|
|
/// This exists simply to identify a set of known commands.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum GeneralCommandType {
|
|
#[serde(rename = "MoveUp")]
|
|
MoveUp,
|
|
#[serde(rename = "MoveDown")]
|
|
MoveDown,
|
|
#[serde(rename = "MoveLeft")]
|
|
MoveLeft,
|
|
#[serde(rename = "MoveRight")]
|
|
MoveRight,
|
|
#[serde(rename = "PageUp")]
|
|
PageUp,
|
|
#[serde(rename = "PageDown")]
|
|
PageDown,
|
|
#[serde(rename = "PreviousLetter")]
|
|
PreviousLetter,
|
|
#[serde(rename = "NextLetter")]
|
|
NextLetter,
|
|
#[serde(rename = "ToggleOsd")]
|
|
ToggleOsd,
|
|
#[serde(rename = "ToggleContextMenu")]
|
|
ToggleContextMenu,
|
|
#[serde(rename = "Select")]
|
|
Select,
|
|
#[serde(rename = "Back")]
|
|
Back,
|
|
#[serde(rename = "TakeScreenshot")]
|
|
TakeScreenshot,
|
|
#[serde(rename = "SendKey")]
|
|
SendKey,
|
|
#[serde(rename = "SendString")]
|
|
SendString,
|
|
#[serde(rename = "GoHome")]
|
|
GoHome,
|
|
#[serde(rename = "GoToSettings")]
|
|
GoToSettings,
|
|
#[serde(rename = "VolumeUp")]
|
|
VolumeUp,
|
|
#[serde(rename = "VolumeDown")]
|
|
VolumeDown,
|
|
#[serde(rename = "Mute")]
|
|
Mute,
|
|
#[serde(rename = "Unmute")]
|
|
Unmute,
|
|
#[serde(rename = "ToggleMute")]
|
|
ToggleMute,
|
|
#[serde(rename = "SetVolume")]
|
|
SetVolume,
|
|
#[serde(rename = "SetAudioStreamIndex")]
|
|
SetAudioStreamIndex,
|
|
#[serde(rename = "SetSubtitleStreamIndex")]
|
|
SetSubtitleStreamIndex,
|
|
#[serde(rename = "ToggleFullscreen")]
|
|
ToggleFullscreen,
|
|
#[serde(rename = "DisplayContent")]
|
|
DisplayContent,
|
|
#[serde(rename = "GoToSearch")]
|
|
GoToSearch,
|
|
#[serde(rename = "DisplayMessage")]
|
|
DisplayMessage,
|
|
#[serde(rename = "SetRepeatMode")]
|
|
SetRepeatMode,
|
|
#[serde(rename = "ChannelUp")]
|
|
ChannelUp,
|
|
#[serde(rename = "ChannelDown")]
|
|
ChannelDown,
|
|
#[serde(rename = "Guide")]
|
|
Guide,
|
|
#[serde(rename = "ToggleStats")]
|
|
ToggleStats,
|
|
#[serde(rename = "PlayMediaSource")]
|
|
PlayMediaSource,
|
|
#[serde(rename = "PlayTrailers")]
|
|
PlayTrailers,
|
|
#[serde(rename = "SetShuffleQueue")]
|
|
SetShuffleQueue,
|
|
#[serde(rename = "PlayState")]
|
|
PlayState,
|
|
#[serde(rename = "PlayNext")]
|
|
PlayNext,
|
|
#[serde(rename = "ToggleOsdMenu")]
|
|
ToggleOsdMenu,
|
|
#[serde(rename = "Play")]
|
|
Play,
|
|
#[serde(rename = "SetMaxStreamingBitrate")]
|
|
SetMaxStreamingBitrate,
|
|
#[serde(rename = "SetPlaybackOrder")]
|
|
SetPlaybackOrder,
|
|
}
|
|
/// Enum GroupQueueMode.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum GroupQueueMode {
|
|
#[serde(rename = "Queue")]
|
|
Queue,
|
|
#[serde(rename = "QueueNext")]
|
|
QueueNext,
|
|
}
|
|
/// Enum GroupRepeatMode.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum GroupRepeatMode {
|
|
#[serde(rename = "RepeatOne")]
|
|
RepeatOne,
|
|
#[serde(rename = "RepeatAll")]
|
|
RepeatAll,
|
|
#[serde(rename = "RepeatNone")]
|
|
RepeatNone,
|
|
}
|
|
/// Enum GroupShuffleMode.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum GroupShuffleMode {
|
|
#[serde(rename = "Sorted")]
|
|
Sorted,
|
|
#[serde(rename = "Shuffle")]
|
|
Shuffle,
|
|
}
|
|
/// Enum GroupState.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum GroupStateType {
|
|
#[serde(rename = "Idle")]
|
|
Idle,
|
|
#[serde(rename = "Waiting")]
|
|
Waiting,
|
|
#[serde(rename = "Paused")]
|
|
Paused,
|
|
#[serde(rename = "Playing")]
|
|
Playing,
|
|
}
|
|
/// Enum GroupUpdateType.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum GroupUpdateType {
|
|
#[serde(rename = "UserJoined")]
|
|
UserJoined,
|
|
#[serde(rename = "UserLeft")]
|
|
UserLeft,
|
|
#[serde(rename = "GroupJoined")]
|
|
GroupJoined,
|
|
#[serde(rename = "GroupLeft")]
|
|
GroupLeft,
|
|
#[serde(rename = "StateUpdate")]
|
|
StateUpdate,
|
|
#[serde(rename = "PlayQueue")]
|
|
PlayQueue,
|
|
#[serde(rename = "NotInGroup")]
|
|
NotInGroup,
|
|
#[serde(rename = "GroupDoesNotExist")]
|
|
GroupDoesNotExist,
|
|
#[serde(rename = "CreateGroupDenied")]
|
|
CreateGroupDenied,
|
|
#[serde(rename = "JoinGroupDenied")]
|
|
JoinGroupDenied,
|
|
#[serde(rename = "LibraryAccessDenied")]
|
|
LibraryAccessDenied,
|
|
}
|
|
/// Enum containing hardware acceleration types.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum HardwareAccelerationType {
|
|
#[serde(rename = "none")]
|
|
None,
|
|
#[serde(rename = "amf")]
|
|
Amf,
|
|
#[serde(rename = "qsv")]
|
|
Qsv,
|
|
#[serde(rename = "nvenc")]
|
|
Nvenc,
|
|
#[serde(rename = "v4l2m2m")]
|
|
V4l2m2m,
|
|
#[serde(rename = "vaapi")]
|
|
Vaapi,
|
|
#[serde(rename = "videotoolbox")]
|
|
Videotoolbox,
|
|
#[serde(rename = "rkmpp")]
|
|
Rkmpp,
|
|
}
|
|
/// Enum ImageOutputFormat.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum ImageFormat {
|
|
#[serde(rename = "Bmp")]
|
|
Bmp,
|
|
#[serde(rename = "Gif")]
|
|
Gif,
|
|
#[serde(rename = "Jpg")]
|
|
Jpg,
|
|
#[serde(rename = "Png")]
|
|
Png,
|
|
#[serde(rename = "Webp")]
|
|
Webp,
|
|
#[serde(rename = "Svg")]
|
|
Svg,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum ImageOrientation {
|
|
#[serde(rename = "TopLeft")]
|
|
TopLeft,
|
|
#[serde(rename = "TopRight")]
|
|
TopRight,
|
|
#[serde(rename = "BottomRight")]
|
|
BottomRight,
|
|
#[serde(rename = "BottomLeft")]
|
|
BottomLeft,
|
|
#[serde(rename = "LeftTop")]
|
|
LeftTop,
|
|
#[serde(rename = "RightTop")]
|
|
RightTop,
|
|
#[serde(rename = "RightBottom")]
|
|
RightBottom,
|
|
#[serde(rename = "LeftBottom")]
|
|
LeftBottom,
|
|
}
|
|
/// Enum ImageResolution.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum ImageResolution {
|
|
#[serde(rename = "MatchSource")]
|
|
MatchSource,
|
|
#[serde(rename = "P144")]
|
|
P144,
|
|
#[serde(rename = "P240")]
|
|
P240,
|
|
#[serde(rename = "P360")]
|
|
P360,
|
|
#[serde(rename = "P480")]
|
|
P480,
|
|
#[serde(rename = "P720")]
|
|
P720,
|
|
#[serde(rename = "P1080")]
|
|
P1080,
|
|
#[serde(rename = "P1440")]
|
|
P1440,
|
|
#[serde(rename = "P2160")]
|
|
P2160,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum ImageSavingConvention {
|
|
#[serde(rename = "Legacy")]
|
|
Legacy,
|
|
#[serde(rename = "Compatible")]
|
|
Compatible,
|
|
}
|
|
/// Enum ImageType.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum ImageType {
|
|
#[serde(rename = "Primary")]
|
|
Primary,
|
|
#[serde(rename = "Art")]
|
|
Art,
|
|
#[serde(rename = "Backdrop")]
|
|
Backdrop,
|
|
#[serde(rename = "Banner")]
|
|
Banner,
|
|
#[serde(rename = "Logo")]
|
|
Logo,
|
|
#[serde(rename = "Thumb")]
|
|
Thumb,
|
|
#[serde(rename = "Disc")]
|
|
Disc,
|
|
#[serde(rename = "Box")]
|
|
Box,
|
|
#[serde(rename = "Screenshot")]
|
|
Screenshot,
|
|
#[serde(rename = "Menu")]
|
|
Menu,
|
|
#[serde(rename = "Chapter")]
|
|
Chapter,
|
|
#[serde(rename = "BoxRear")]
|
|
BoxRear,
|
|
#[serde(rename = "Profile")]
|
|
Profile,
|
|
}
|
|
/// Enum IsoType.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum IsoType {
|
|
#[serde(rename = "Dvd")]
|
|
Dvd,
|
|
#[serde(rename = "BluRay")]
|
|
BluRay,
|
|
}
|
|
/// Used to control the data that gets attached to DtoBaseItems.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum ItemFields {
|
|
#[serde(rename = "AirTime")]
|
|
AirTime,
|
|
#[serde(rename = "CanDelete")]
|
|
CanDelete,
|
|
#[serde(rename = "CanDownload")]
|
|
CanDownload,
|
|
#[serde(rename = "ChannelInfo")]
|
|
ChannelInfo,
|
|
#[serde(rename = "Chapters")]
|
|
Chapters,
|
|
#[serde(rename = "Trickplay")]
|
|
Trickplay,
|
|
#[serde(rename = "ChildCount")]
|
|
ChildCount,
|
|
#[serde(rename = "CumulativeRunTimeTicks")]
|
|
CumulativeRunTimeTicks,
|
|
#[serde(rename = "CustomRating")]
|
|
CustomRating,
|
|
#[serde(rename = "DateCreated")]
|
|
DateCreated,
|
|
#[serde(rename = "DateLastMediaAdded")]
|
|
DateLastMediaAdded,
|
|
#[serde(rename = "DisplayPreferencesId")]
|
|
DisplayPreferencesId,
|
|
#[serde(rename = "Etag")]
|
|
Etag,
|
|
#[serde(rename = "ExternalUrls")]
|
|
ExternalUrls,
|
|
#[serde(rename = "Genres")]
|
|
Genres,
|
|
#[serde(rename = "HomePageUrl")]
|
|
HomePageUrl,
|
|
#[serde(rename = "ItemCounts")]
|
|
ItemCounts,
|
|
#[serde(rename = "MediaSourceCount")]
|
|
MediaSourceCount,
|
|
#[serde(rename = "MediaSources")]
|
|
MediaSources,
|
|
#[serde(rename = "OriginalTitle")]
|
|
OriginalTitle,
|
|
#[serde(rename = "Overview")]
|
|
Overview,
|
|
#[serde(rename = "ParentId")]
|
|
ParentId,
|
|
#[serde(rename = "Path")]
|
|
Path,
|
|
#[serde(rename = "People")]
|
|
People,
|
|
#[serde(rename = "PlayAccess")]
|
|
PlayAccess,
|
|
#[serde(rename = "ProductionLocations")]
|
|
ProductionLocations,
|
|
#[serde(rename = "ProviderIds")]
|
|
ProviderIds,
|
|
#[serde(rename = "PrimaryImageAspectRatio")]
|
|
PrimaryImageAspectRatio,
|
|
#[serde(rename = "RecursiveItemCount")]
|
|
RecursiveItemCount,
|
|
#[serde(rename = "Settings")]
|
|
Settings,
|
|
#[serde(rename = "ScreenshotImageTags")]
|
|
ScreenshotImageTags,
|
|
#[serde(rename = "SeriesPrimaryImage")]
|
|
SeriesPrimaryImage,
|
|
#[serde(rename = "SeriesStudio")]
|
|
SeriesStudio,
|
|
#[serde(rename = "SortName")]
|
|
SortName,
|
|
#[serde(rename = "SpecialEpisodeNumbers")]
|
|
SpecialEpisodeNumbers,
|
|
#[serde(rename = "Studios")]
|
|
Studios,
|
|
#[serde(rename = "Taglines")]
|
|
Taglines,
|
|
#[serde(rename = "Tags")]
|
|
Tags,
|
|
#[serde(rename = "RemoteTrailers")]
|
|
RemoteTrailers,
|
|
#[serde(rename = "MediaStreams")]
|
|
MediaStreams,
|
|
#[serde(rename = "SeasonUserData")]
|
|
SeasonUserData,
|
|
#[serde(rename = "ServiceName")]
|
|
ServiceName,
|
|
#[serde(rename = "ThemeSongIds")]
|
|
ThemeSongIds,
|
|
#[serde(rename = "ThemeVideoIds")]
|
|
ThemeVideoIds,
|
|
#[serde(rename = "ExternalEtag")]
|
|
ExternalEtag,
|
|
#[serde(rename = "PresentationUniqueKey")]
|
|
PresentationUniqueKey,
|
|
#[serde(rename = "InheritedParentalRatingValue")]
|
|
InheritedParentalRatingValue,
|
|
#[serde(rename = "ExternalSeriesId")]
|
|
ExternalSeriesId,
|
|
#[serde(rename = "SeriesPresentationUniqueKey")]
|
|
SeriesPresentationUniqueKey,
|
|
#[serde(rename = "DateLastRefreshed")]
|
|
DateLastRefreshed,
|
|
#[serde(rename = "DateLastSaved")]
|
|
DateLastSaved,
|
|
#[serde(rename = "RefreshState")]
|
|
RefreshState,
|
|
#[serde(rename = "ChannelImage")]
|
|
ChannelImage,
|
|
#[serde(rename = "EnableMediaSourceDisplay")]
|
|
EnableMediaSourceDisplay,
|
|
#[serde(rename = "Width")]
|
|
Width,
|
|
#[serde(rename = "Height")]
|
|
Height,
|
|
#[serde(rename = "ExtraIds")]
|
|
ExtraIds,
|
|
#[serde(rename = "LocalTrailerCount")]
|
|
LocalTrailerCount,
|
|
#[serde(rename = "IsHD")]
|
|
IsHd,
|
|
#[serde(rename = "SpecialFeatureCount")]
|
|
SpecialFeatureCount,
|
|
}
|
|
/// Enum ItemFilter.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum ItemFilter {
|
|
#[serde(rename = "IsFolder")]
|
|
IsFolder,
|
|
#[serde(rename = "IsNotFolder")]
|
|
IsNotFolder,
|
|
#[serde(rename = "IsUnplayed")]
|
|
IsUnplayed,
|
|
#[serde(rename = "IsPlayed")]
|
|
IsPlayed,
|
|
#[serde(rename = "IsFavorite")]
|
|
IsFavorite,
|
|
#[serde(rename = "IsResumable")]
|
|
IsResumable,
|
|
#[serde(rename = "Likes")]
|
|
Likes,
|
|
#[serde(rename = "Dislikes")]
|
|
Dislikes,
|
|
#[serde(rename = "IsFavoriteOrLikes")]
|
|
IsFavoriteOrLikes,
|
|
}
|
|
/// These represent sort orders.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum ItemSortBy {
|
|
#[serde(rename = "Default")]
|
|
Default,
|
|
#[serde(rename = "AiredEpisodeOrder")]
|
|
AiredEpisodeOrder,
|
|
#[serde(rename = "Album")]
|
|
Album,
|
|
#[serde(rename = "AlbumArtist")]
|
|
AlbumArtist,
|
|
#[serde(rename = "Artist")]
|
|
Artist,
|
|
#[serde(rename = "DateCreated")]
|
|
DateCreated,
|
|
#[serde(rename = "OfficialRating")]
|
|
OfficialRating,
|
|
#[serde(rename = "DatePlayed")]
|
|
DatePlayed,
|
|
#[serde(rename = "PremiereDate")]
|
|
PremiereDate,
|
|
#[serde(rename = "StartDate")]
|
|
StartDate,
|
|
#[serde(rename = "SortName")]
|
|
SortName,
|
|
#[serde(rename = "Name")]
|
|
Name,
|
|
#[serde(rename = "Random")]
|
|
Random,
|
|
#[serde(rename = "Runtime")]
|
|
Runtime,
|
|
#[serde(rename = "CommunityRating")]
|
|
CommunityRating,
|
|
#[serde(rename = "ProductionYear")]
|
|
ProductionYear,
|
|
#[serde(rename = "PlayCount")]
|
|
PlayCount,
|
|
#[serde(rename = "CriticRating")]
|
|
CriticRating,
|
|
#[serde(rename = "IsFolder")]
|
|
IsFolder,
|
|
#[serde(rename = "IsUnplayed")]
|
|
IsUnplayed,
|
|
#[serde(rename = "IsPlayed")]
|
|
IsPlayed,
|
|
#[serde(rename = "SeriesSortName")]
|
|
SeriesSortName,
|
|
#[serde(rename = "VideoBitRate")]
|
|
VideoBitRate,
|
|
#[serde(rename = "AirTime")]
|
|
AirTime,
|
|
#[serde(rename = "Studio")]
|
|
Studio,
|
|
#[serde(rename = "IsFavoriteOrLiked")]
|
|
IsFavoriteOrLiked,
|
|
#[serde(rename = "DateLastContentAdded")]
|
|
DateLastContentAdded,
|
|
#[serde(rename = "SeriesDatePlayed")]
|
|
SeriesDatePlayed,
|
|
#[serde(rename = "ParentIndexNumber")]
|
|
ParentIndexNumber,
|
|
#[serde(rename = "IndexNumber")]
|
|
IndexNumber,
|
|
#[serde(rename = "SimilarityScore")]
|
|
SimilarityScore,
|
|
#[serde(rename = "SearchScore")]
|
|
SearchScore,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum KeepUntil {
|
|
#[serde(rename = "UntilDeleted")]
|
|
UntilDeleted,
|
|
#[serde(rename = "UntilSpaceNeeded")]
|
|
UntilSpaceNeeded,
|
|
#[serde(rename = "UntilWatched")]
|
|
UntilWatched,
|
|
#[serde(rename = "UntilDate")]
|
|
UntilDate,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum LiveTvServiceStatus {
|
|
#[serde(rename = "Ok")]
|
|
Ok,
|
|
#[serde(rename = "Unavailable")]
|
|
Unavailable,
|
|
}
|
|
/// Enum LocationType.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum LocationType {
|
|
#[serde(rename = "FileSystem")]
|
|
FileSystem,
|
|
#[serde(rename = "Remote")]
|
|
Remote,
|
|
#[serde(rename = "Virtual")]
|
|
Virtual,
|
|
#[serde(rename = "Offline")]
|
|
Offline,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum LogLevel {
|
|
#[serde(rename = "Trace")]
|
|
Trace,
|
|
#[serde(rename = "Debug")]
|
|
Debug,
|
|
#[serde(rename = "Information")]
|
|
Information,
|
|
#[serde(rename = "Warning")]
|
|
Warning,
|
|
#[serde(rename = "Error")]
|
|
Error,
|
|
#[serde(rename = "Critical")]
|
|
Critical,
|
|
#[serde(rename = "None")]
|
|
None,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum MediaProtocol {
|
|
#[serde(rename = "File")]
|
|
File,
|
|
#[serde(rename = "Http")]
|
|
Http,
|
|
#[serde(rename = "Rtmp")]
|
|
Rtmp,
|
|
#[serde(rename = "Rtsp")]
|
|
Rtsp,
|
|
#[serde(rename = "Udp")]
|
|
Udp,
|
|
#[serde(rename = "Rtp")]
|
|
Rtp,
|
|
#[serde(rename = "Ftp")]
|
|
Ftp,
|
|
}
|
|
/// Defines the types of content an individual Jellyfin.Data.Entities.MediaSegment represents.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum MediaSegmentType {
|
|
#[serde(rename = "Unknown")]
|
|
Unknown,
|
|
#[serde(rename = "Commercial")]
|
|
Commercial,
|
|
#[serde(rename = "Preview")]
|
|
Preview,
|
|
#[serde(rename = "Recap")]
|
|
Recap,
|
|
#[serde(rename = "Outro")]
|
|
Outro,
|
|
#[serde(rename = "Intro")]
|
|
Intro,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum MediaSourceType {
|
|
#[serde(rename = "Default")]
|
|
Default,
|
|
#[serde(rename = "Grouping")]
|
|
Grouping,
|
|
#[serde(rename = "Placeholder")]
|
|
Placeholder,
|
|
}
|
|
/** Media streaming protocol.
|
|
Lowercase for backwards compatibility.*/
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum MediaStreamProtocol {
|
|
#[serde(rename = "http")]
|
|
Http,
|
|
#[serde(rename = "hls")]
|
|
Hls,
|
|
}
|
|
/// Enum MediaStreamType.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum MediaStreamType {
|
|
#[serde(rename = "Audio")]
|
|
Audio,
|
|
#[serde(rename = "Video")]
|
|
Video,
|
|
#[serde(rename = "Subtitle")]
|
|
Subtitle,
|
|
#[serde(rename = "EmbeddedImage")]
|
|
EmbeddedImage,
|
|
#[serde(rename = "Data")]
|
|
Data,
|
|
#[serde(rename = "Lyric")]
|
|
Lyric,
|
|
}
|
|
/// Media types.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum MediaType {
|
|
#[serde(rename = "Unknown")]
|
|
Unknown,
|
|
#[serde(rename = "Video")]
|
|
Video,
|
|
#[serde(rename = "Audio")]
|
|
Audio,
|
|
#[serde(rename = "Photo")]
|
|
Photo,
|
|
#[serde(rename = "Book")]
|
|
Book,
|
|
}
|
|
/// Enum MetadataFields.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum MetadataField {
|
|
#[serde(rename = "Cast")]
|
|
Cast,
|
|
#[serde(rename = "Genres")]
|
|
Genres,
|
|
#[serde(rename = "ProductionLocations")]
|
|
ProductionLocations,
|
|
#[serde(rename = "Studios")]
|
|
Studios,
|
|
#[serde(rename = "Tags")]
|
|
Tags,
|
|
#[serde(rename = "Name")]
|
|
Name,
|
|
#[serde(rename = "Overview")]
|
|
Overview,
|
|
#[serde(rename = "Runtime")]
|
|
Runtime,
|
|
#[serde(rename = "OfficialRating")]
|
|
OfficialRating,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum MetadataRefreshMode {
|
|
#[serde(rename = "None")]
|
|
None,
|
|
#[serde(rename = "ValidationOnly")]
|
|
ValidationOnly,
|
|
#[serde(rename = "Default")]
|
|
Default,
|
|
#[serde(rename = "FullRefresh")]
|
|
FullRefresh,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum ParameterInclude {
|
|
#[serde(rename = "ProviderList")]
|
|
ProviderList,
|
|
#[serde(rename = "LocalIpAddress")]
|
|
LocalIpAddress,
|
|
#[serde(rename = "LocalPort")]
|
|
LocalPort,
|
|
#[serde(rename = "Https")]
|
|
Https,
|
|
}
|
|
/// The person kind.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum PersonKind {
|
|
#[serde(rename = "Unknown")]
|
|
Unknown,
|
|
#[serde(rename = "Actor")]
|
|
Actor,
|
|
#[serde(rename = "Director")]
|
|
Director,
|
|
#[serde(rename = "Composer")]
|
|
Composer,
|
|
#[serde(rename = "Writer")]
|
|
Writer,
|
|
#[serde(rename = "GuestStar")]
|
|
GuestStar,
|
|
#[serde(rename = "Producer")]
|
|
Producer,
|
|
#[serde(rename = "Conductor")]
|
|
Conductor,
|
|
#[serde(rename = "Lyricist")]
|
|
Lyricist,
|
|
#[serde(rename = "Arranger")]
|
|
Arranger,
|
|
#[serde(rename = "Engineer")]
|
|
Engineer,
|
|
#[serde(rename = "Mixer")]
|
|
Mixer,
|
|
#[serde(rename = "Remixer")]
|
|
Remixer,
|
|
#[serde(rename = "Creator")]
|
|
Creator,
|
|
#[serde(rename = "Artist")]
|
|
Artist,
|
|
#[serde(rename = "AlbumArtist")]
|
|
AlbumArtist,
|
|
#[serde(rename = "Author")]
|
|
Author,
|
|
#[serde(rename = "Illustrator")]
|
|
Illustrator,
|
|
#[serde(rename = "Penciller")]
|
|
Penciller,
|
|
#[serde(rename = "Inker")]
|
|
Inker,
|
|
#[serde(rename = "Colorist")]
|
|
Colorist,
|
|
#[serde(rename = "Letterer")]
|
|
Letterer,
|
|
#[serde(rename = "CoverArtist")]
|
|
CoverArtist,
|
|
#[serde(rename = "Editor")]
|
|
Editor,
|
|
#[serde(rename = "Translator")]
|
|
Translator,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum PlayAccess {
|
|
#[serde(rename = "Full")]
|
|
Full,
|
|
#[serde(rename = "None")]
|
|
None,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum PlaybackErrorCode {
|
|
#[serde(rename = "NotAllowed")]
|
|
NotAllowed,
|
|
#[serde(rename = "NoCompatibleStream")]
|
|
NoCompatibleStream,
|
|
#[serde(rename = "RateLimitExceeded")]
|
|
RateLimitExceeded,
|
|
}
|
|
/// Enum PlaybackOrder.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum PlaybackOrder {
|
|
#[serde(rename = "Default")]
|
|
Default,
|
|
#[serde(rename = "Shuffle")]
|
|
Shuffle,
|
|
}
|
|
/// Enum PlaybackRequestType.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum PlaybackRequestType {
|
|
#[serde(rename = "Play")]
|
|
Play,
|
|
#[serde(rename = "SetPlaylistItem")]
|
|
SetPlaylistItem,
|
|
#[serde(rename = "RemoveFromPlaylist")]
|
|
RemoveFromPlaylist,
|
|
#[serde(rename = "MovePlaylistItem")]
|
|
MovePlaylistItem,
|
|
#[serde(rename = "Queue")]
|
|
Queue,
|
|
#[serde(rename = "Unpause")]
|
|
Unpause,
|
|
#[serde(rename = "Pause")]
|
|
Pause,
|
|
#[serde(rename = "Stop")]
|
|
Stop,
|
|
#[serde(rename = "Seek")]
|
|
Seek,
|
|
#[serde(rename = "Buffer")]
|
|
Buffer,
|
|
#[serde(rename = "Ready")]
|
|
Ready,
|
|
#[serde(rename = "NextItem")]
|
|
NextItem,
|
|
#[serde(rename = "PreviousItem")]
|
|
PreviousItem,
|
|
#[serde(rename = "SetRepeatMode")]
|
|
SetRepeatMode,
|
|
#[serde(rename = "SetShuffleMode")]
|
|
SetShuffleMode,
|
|
#[serde(rename = "Ping")]
|
|
Ping,
|
|
#[serde(rename = "IgnoreWait")]
|
|
IgnoreWait,
|
|
}
|
|
/// Enum PlayCommand.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum PlayCommand {
|
|
#[serde(rename = "PlayNow")]
|
|
PlayNow,
|
|
#[serde(rename = "PlayNext")]
|
|
PlayNext,
|
|
#[serde(rename = "PlayLast")]
|
|
PlayLast,
|
|
#[serde(rename = "PlayInstantMix")]
|
|
PlayInstantMix,
|
|
#[serde(rename = "PlayShuffle")]
|
|
PlayShuffle,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum PlayMethod {
|
|
#[serde(rename = "Transcode")]
|
|
Transcode,
|
|
#[serde(rename = "DirectStream")]
|
|
DirectStream,
|
|
#[serde(rename = "DirectPlay")]
|
|
DirectPlay,
|
|
}
|
|
/// Enum PlayQueueUpdateReason.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum PlayQueueUpdateReason {
|
|
#[serde(rename = "NewPlaylist")]
|
|
NewPlaylist,
|
|
#[serde(rename = "SetCurrentItem")]
|
|
SetCurrentItem,
|
|
#[serde(rename = "RemoveItems")]
|
|
RemoveItems,
|
|
#[serde(rename = "MoveItem")]
|
|
MoveItem,
|
|
#[serde(rename = "Queue")]
|
|
Queue,
|
|
#[serde(rename = "QueueNext")]
|
|
QueueNext,
|
|
#[serde(rename = "NextItem")]
|
|
NextItem,
|
|
#[serde(rename = "PreviousItem")]
|
|
PreviousItem,
|
|
#[serde(rename = "RepeatMode")]
|
|
RepeatMode,
|
|
#[serde(rename = "ShuffleMode")]
|
|
ShuffleMode,
|
|
}
|
|
/// Enum PlaystateCommand.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum PlaystateCommand {
|
|
#[serde(rename = "Stop")]
|
|
Stop,
|
|
#[serde(rename = "Pause")]
|
|
Pause,
|
|
#[serde(rename = "Unpause")]
|
|
Unpause,
|
|
#[serde(rename = "NextTrack")]
|
|
NextTrack,
|
|
#[serde(rename = "PreviousTrack")]
|
|
PreviousTrack,
|
|
#[serde(rename = "Seek")]
|
|
Seek,
|
|
#[serde(rename = "Rewind")]
|
|
Rewind,
|
|
#[serde(rename = "FastForward")]
|
|
FastForward,
|
|
#[serde(rename = "PlayPause")]
|
|
PlayPause,
|
|
}
|
|
/// Plugin load status.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum PluginStatus {
|
|
#[serde(rename = "Active")]
|
|
Active,
|
|
#[serde(rename = "Restart")]
|
|
Restart,
|
|
#[serde(rename = "Deleted")]
|
|
Deleted,
|
|
#[serde(rename = "Superceded")]
|
|
Superceded,
|
|
#[serde(rename = "Malfunctioned")]
|
|
Malfunctioned,
|
|
#[serde(rename = "NotSupported")]
|
|
NotSupported,
|
|
#[serde(rename = "Disabled")]
|
|
Disabled,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum ProcessPriorityClass {
|
|
#[serde(rename = "Normal")]
|
|
Normal,
|
|
#[serde(rename = "Idle")]
|
|
Idle,
|
|
#[serde(rename = "High")]
|
|
High,
|
|
#[serde(rename = "RealTime")]
|
|
RealTime,
|
|
#[serde(rename = "BelowNormal")]
|
|
BelowNormal,
|
|
#[serde(rename = "AboveNormal")]
|
|
AboveNormal,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum ProfileConditionType {
|
|
#[serde(rename = "Equals")]
|
|
Equals,
|
|
#[serde(rename = "NotEquals")]
|
|
NotEquals,
|
|
#[serde(rename = "LessThanEqual")]
|
|
LessThanEqual,
|
|
#[serde(rename = "GreaterThanEqual")]
|
|
GreaterThanEqual,
|
|
#[serde(rename = "EqualsAny")]
|
|
EqualsAny,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum ProfileConditionValue {
|
|
#[serde(rename = "AudioChannels")]
|
|
AudioChannels,
|
|
#[serde(rename = "AudioBitrate")]
|
|
AudioBitrate,
|
|
#[serde(rename = "AudioProfile")]
|
|
AudioProfile,
|
|
#[serde(rename = "Width")]
|
|
Width,
|
|
#[serde(rename = "Height")]
|
|
Height,
|
|
#[serde(rename = "Has64BitOffsets")]
|
|
Has64BitOffsets,
|
|
#[serde(rename = "PacketLength")]
|
|
PacketLength,
|
|
#[serde(rename = "VideoBitDepth")]
|
|
VideoBitDepth,
|
|
#[serde(rename = "VideoBitrate")]
|
|
VideoBitrate,
|
|
#[serde(rename = "VideoFramerate")]
|
|
VideoFramerate,
|
|
#[serde(rename = "VideoLevel")]
|
|
VideoLevel,
|
|
#[serde(rename = "VideoProfile")]
|
|
VideoProfile,
|
|
#[serde(rename = "VideoTimestamp")]
|
|
VideoTimestamp,
|
|
#[serde(rename = "IsAnamorphic")]
|
|
IsAnamorphic,
|
|
#[serde(rename = "RefFrames")]
|
|
RefFrames,
|
|
#[serde(rename = "NumAudioStreams")]
|
|
NumAudioStreams,
|
|
#[serde(rename = "NumVideoStreams")]
|
|
NumVideoStreams,
|
|
#[serde(rename = "IsSecondaryAudio")]
|
|
IsSecondaryAudio,
|
|
#[serde(rename = "VideoCodecTag")]
|
|
VideoCodecTag,
|
|
#[serde(rename = "IsAvc")]
|
|
IsAvc,
|
|
#[serde(rename = "IsInterlaced")]
|
|
IsInterlaced,
|
|
#[serde(rename = "AudioSampleRate")]
|
|
AudioSampleRate,
|
|
#[serde(rename = "AudioBitDepth")]
|
|
AudioBitDepth,
|
|
#[serde(rename = "VideoRangeType")]
|
|
VideoRangeType,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum ProgramAudio {
|
|
#[serde(rename = "Mono")]
|
|
Mono,
|
|
#[serde(rename = "Stereo")]
|
|
Stereo,
|
|
#[serde(rename = "Dolby")]
|
|
Dolby,
|
|
#[serde(rename = "DolbyDigital")]
|
|
DolbyDigital,
|
|
#[serde(rename = "Thx")]
|
|
Thx,
|
|
#[serde(rename = "Atmos")]
|
|
Atmos,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum RatingType {
|
|
#[serde(rename = "Score")]
|
|
Score,
|
|
#[serde(rename = "Likes")]
|
|
Likes,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum RecommendationType {
|
|
#[serde(rename = "SimilarToRecentlyPlayed")]
|
|
SimilarToRecentlyPlayed,
|
|
#[serde(rename = "SimilarToLikedItem")]
|
|
SimilarToLikedItem,
|
|
#[serde(rename = "HasDirectorFromRecentlyPlayed")]
|
|
HasDirectorFromRecentlyPlayed,
|
|
#[serde(rename = "HasActorFromRecentlyPlayed")]
|
|
HasActorFromRecentlyPlayed,
|
|
#[serde(rename = "HasLikedDirector")]
|
|
HasLikedDirector,
|
|
#[serde(rename = "HasLikedActor")]
|
|
HasLikedActor,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum RecordingStatus {
|
|
#[serde(rename = "New")]
|
|
New,
|
|
#[serde(rename = "InProgress")]
|
|
InProgress,
|
|
#[serde(rename = "Completed")]
|
|
Completed,
|
|
#[serde(rename = "Cancelled")]
|
|
Cancelled,
|
|
#[serde(rename = "ConflictedOk")]
|
|
ConflictedOk,
|
|
#[serde(rename = "ConflictedNotOk")]
|
|
ConflictedNotOk,
|
|
#[serde(rename = "Error")]
|
|
Error,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum RepeatMode {
|
|
#[serde(rename = "RepeatNone")]
|
|
RepeatNone,
|
|
#[serde(rename = "RepeatAll")]
|
|
RepeatAll,
|
|
#[serde(rename = "RepeatOne")]
|
|
RepeatOne,
|
|
}
|
|
/// An enum representing the axis that should be scrolled.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum ScrollDirection {
|
|
#[serde(rename = "Horizontal")]
|
|
Horizontal,
|
|
#[serde(rename = "Vertical")]
|
|
Vertical,
|
|
}
|
|
/// Enum SendCommandType.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum SendCommandType {
|
|
#[serde(rename = "Unpause")]
|
|
Unpause,
|
|
#[serde(rename = "Pause")]
|
|
Pause,
|
|
#[serde(rename = "Stop")]
|
|
Stop,
|
|
#[serde(rename = "Seek")]
|
|
Seek,
|
|
}
|
|
/// The status of a series.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum SeriesStatus {
|
|
#[serde(rename = "Continuing")]
|
|
Continuing,
|
|
#[serde(rename = "Ended")]
|
|
Ended,
|
|
#[serde(rename = "Unreleased")]
|
|
Unreleased,
|
|
}
|
|
/// The different kinds of messages that are used in the WebSocket api.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum SessionMessageType {
|
|
#[serde(rename = "ForceKeepAlive")]
|
|
ForceKeepAlive,
|
|
#[serde(rename = "GeneralCommand")]
|
|
GeneralCommand,
|
|
#[serde(rename = "UserDataChanged")]
|
|
UserDataChanged,
|
|
#[serde(rename = "Sessions")]
|
|
Sessions,
|
|
#[serde(rename = "Play")]
|
|
Play,
|
|
#[serde(rename = "SyncPlayCommand")]
|
|
SyncPlayCommand,
|
|
#[serde(rename = "SyncPlayGroupUpdate")]
|
|
SyncPlayGroupUpdate,
|
|
#[serde(rename = "Playstate")]
|
|
Playstate,
|
|
#[serde(rename = "RestartRequired")]
|
|
RestartRequired,
|
|
#[serde(rename = "ServerShuttingDown")]
|
|
ServerShuttingDown,
|
|
#[serde(rename = "ServerRestarting")]
|
|
ServerRestarting,
|
|
#[serde(rename = "LibraryChanged")]
|
|
LibraryChanged,
|
|
#[serde(rename = "UserDeleted")]
|
|
UserDeleted,
|
|
#[serde(rename = "UserUpdated")]
|
|
UserUpdated,
|
|
#[serde(rename = "SeriesTimerCreated")]
|
|
SeriesTimerCreated,
|
|
#[serde(rename = "TimerCreated")]
|
|
TimerCreated,
|
|
#[serde(rename = "SeriesTimerCancelled")]
|
|
SeriesTimerCancelled,
|
|
#[serde(rename = "TimerCancelled")]
|
|
TimerCancelled,
|
|
#[serde(rename = "RefreshProgress")]
|
|
RefreshProgress,
|
|
#[serde(rename = "ScheduledTaskEnded")]
|
|
ScheduledTaskEnded,
|
|
#[serde(rename = "PackageInstallationCancelled")]
|
|
PackageInstallationCancelled,
|
|
#[serde(rename = "PackageInstallationFailed")]
|
|
PackageInstallationFailed,
|
|
#[serde(rename = "PackageInstallationCompleted")]
|
|
PackageInstallationCompleted,
|
|
#[serde(rename = "PackageInstalling")]
|
|
PackageInstalling,
|
|
#[serde(rename = "PackageUninstalled")]
|
|
PackageUninstalled,
|
|
#[serde(rename = "ActivityLogEntry")]
|
|
ActivityLogEntry,
|
|
#[serde(rename = "ScheduledTasksInfo")]
|
|
ScheduledTasksInfo,
|
|
#[serde(rename = "ActivityLogEntryStart")]
|
|
ActivityLogEntryStart,
|
|
#[serde(rename = "ActivityLogEntryStop")]
|
|
ActivityLogEntryStop,
|
|
#[serde(rename = "SessionsStart")]
|
|
SessionsStart,
|
|
#[serde(rename = "SessionsStop")]
|
|
SessionsStop,
|
|
#[serde(rename = "ScheduledTasksInfoStart")]
|
|
ScheduledTasksInfoStart,
|
|
#[serde(rename = "ScheduledTasksInfoStop")]
|
|
ScheduledTasksInfoStop,
|
|
#[serde(rename = "KeepAlive")]
|
|
KeepAlive,
|
|
}
|
|
/// An enum representing the sorting order.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum SortOrder {
|
|
#[serde(rename = "Ascending")]
|
|
Ascending,
|
|
#[serde(rename = "Descending")]
|
|
Descending,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum Status {
|
|
#[serde(rename = "Completed")]
|
|
Completed,
|
|
#[serde(rename = "Watching")]
|
|
Watching,
|
|
#[serde(rename = "Both")]
|
|
Both,
|
|
}
|
|
/// Delivery method to use during playback of a specific subtitle format.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum SubtitleDeliveryMethod {
|
|
#[serde(rename = "Encode")]
|
|
Encode,
|
|
#[serde(rename = "Embed")]
|
|
Embed,
|
|
#[serde(rename = "External")]
|
|
External,
|
|
#[serde(rename = "Hls")]
|
|
Hls,
|
|
#[serde(rename = "Drop")]
|
|
Drop,
|
|
}
|
|
/// An enum representing a subtitle playback mode.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum SubtitlePlaybackMode {
|
|
#[serde(rename = "Default")]
|
|
Default,
|
|
#[serde(rename = "Always")]
|
|
Always,
|
|
#[serde(rename = "OnlyForced")]
|
|
OnlyForced,
|
|
#[serde(rename = "None")]
|
|
None,
|
|
#[serde(rename = "Smart")]
|
|
Smart,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum SyncAction {
|
|
#[serde(rename = "UpdateProvider")]
|
|
UpdateProvider,
|
|
#[serde(rename = "UpdateJellyfin")]
|
|
UpdateJellyfin,
|
|
}
|
|
/// Enum SyncPlayUserAccessType.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum SyncPlayUserAccessType {
|
|
#[serde(rename = "CreateAndJoinGroups")]
|
|
CreateAndJoinGroups,
|
|
#[serde(rename = "JoinGroups")]
|
|
JoinGroups,
|
|
#[serde(rename = "None")]
|
|
None,
|
|
}
|
|
/// Enum TaskCompletionStatus.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum TaskCompletionStatus {
|
|
#[serde(rename = "Completed")]
|
|
Completed,
|
|
#[serde(rename = "Failed")]
|
|
Failed,
|
|
#[serde(rename = "Cancelled")]
|
|
Cancelled,
|
|
#[serde(rename = "Aborted")]
|
|
Aborted,
|
|
}
|
|
/// Enum TaskState.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum TaskState {
|
|
#[serde(rename = "Idle")]
|
|
Idle,
|
|
#[serde(rename = "Cancelling")]
|
|
Cancelling,
|
|
#[serde(rename = "Running")]
|
|
Running,
|
|
}
|
|
/// Enum containing tonemapping algorithms.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum TonemappingAlgorithm {
|
|
#[serde(rename = "none")]
|
|
None,
|
|
#[serde(rename = "clip")]
|
|
Clip,
|
|
#[serde(rename = "linear")]
|
|
Linear,
|
|
#[serde(rename = "gamma")]
|
|
Gamma,
|
|
#[serde(rename = "reinhard")]
|
|
Reinhard,
|
|
#[serde(rename = "hable")]
|
|
Hable,
|
|
#[serde(rename = "mobius")]
|
|
Mobius,
|
|
#[serde(rename = "bt2390")]
|
|
Bt2390,
|
|
}
|
|
/// Enum containing tonemapping modes.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum TonemappingMode {
|
|
#[serde(rename = "auto")]
|
|
Auto,
|
|
#[serde(rename = "max")]
|
|
Max,
|
|
#[serde(rename = "rgb")]
|
|
Rgb,
|
|
#[serde(rename = "lum")]
|
|
Lum,
|
|
#[serde(rename = "itp")]
|
|
Itp,
|
|
}
|
|
/// Enum containing tonemapping ranges.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum TonemappingRange {
|
|
#[serde(rename = "auto")]
|
|
Auto,
|
|
#[serde(rename = "tv")]
|
|
Tv,
|
|
#[serde(rename = "pc")]
|
|
Pc,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum TranscodeReason {
|
|
#[serde(rename = "ContainerNotSupported")]
|
|
ContainerNotSupported,
|
|
#[serde(rename = "VideoCodecNotSupported")]
|
|
VideoCodecNotSupported,
|
|
#[serde(rename = "AudioCodecNotSupported")]
|
|
AudioCodecNotSupported,
|
|
#[serde(rename = "SubtitleCodecNotSupported")]
|
|
SubtitleCodecNotSupported,
|
|
#[serde(rename = "AudioIsExternal")]
|
|
AudioIsExternal,
|
|
#[serde(rename = "SecondaryAudioNotSupported")]
|
|
SecondaryAudioNotSupported,
|
|
#[serde(rename = "VideoProfileNotSupported")]
|
|
VideoProfileNotSupported,
|
|
#[serde(rename = "VideoLevelNotSupported")]
|
|
VideoLevelNotSupported,
|
|
#[serde(rename = "VideoResolutionNotSupported")]
|
|
VideoResolutionNotSupported,
|
|
#[serde(rename = "VideoBitDepthNotSupported")]
|
|
VideoBitDepthNotSupported,
|
|
#[serde(rename = "VideoFramerateNotSupported")]
|
|
VideoFramerateNotSupported,
|
|
#[serde(rename = "RefFramesNotSupported")]
|
|
RefFramesNotSupported,
|
|
#[serde(rename = "AnamorphicVideoNotSupported")]
|
|
AnamorphicVideoNotSupported,
|
|
#[serde(rename = "InterlacedVideoNotSupported")]
|
|
InterlacedVideoNotSupported,
|
|
#[serde(rename = "AudioChannelsNotSupported")]
|
|
AudioChannelsNotSupported,
|
|
#[serde(rename = "AudioProfileNotSupported")]
|
|
AudioProfileNotSupported,
|
|
#[serde(rename = "AudioSampleRateNotSupported")]
|
|
AudioSampleRateNotSupported,
|
|
#[serde(rename = "AudioBitDepthNotSupported")]
|
|
AudioBitDepthNotSupported,
|
|
#[serde(rename = "ContainerBitrateExceedsLimit")]
|
|
ContainerBitrateExceedsLimit,
|
|
#[serde(rename = "VideoBitrateNotSupported")]
|
|
VideoBitrateNotSupported,
|
|
#[serde(rename = "AudioBitrateNotSupported")]
|
|
AudioBitrateNotSupported,
|
|
#[serde(rename = "UnknownVideoStreamInfo")]
|
|
UnknownVideoStreamInfo,
|
|
#[serde(rename = "UnknownAudioStreamInfo")]
|
|
UnknownAudioStreamInfo,
|
|
#[serde(rename = "DirectPlayError")]
|
|
DirectPlayError,
|
|
#[serde(rename = "VideoRangeTypeNotSupported")]
|
|
VideoRangeTypeNotSupported,
|
|
#[serde(rename = "VideoCodecTagNotSupported")]
|
|
VideoCodecTagNotSupported,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum TranscodeSeekInfo {
|
|
#[serde(rename = "Auto")]
|
|
Auto,
|
|
#[serde(rename = "Bytes")]
|
|
Bytes,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum TransportStreamTimestamp {
|
|
#[serde(rename = "None")]
|
|
None,
|
|
#[serde(rename = "Zero")]
|
|
Zero,
|
|
#[serde(rename = "Valid")]
|
|
Valid,
|
|
}
|
|
/// Enum TrickplayScanBehavior.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum TrickplayScanBehavior {
|
|
#[serde(rename = "Blocking")]
|
|
Blocking,
|
|
#[serde(rename = "NonBlocking")]
|
|
NonBlocking,
|
|
}
|
|
/// An enum representing an unrated item.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum UnratedItem {
|
|
#[serde(rename = "Movie")]
|
|
Movie,
|
|
#[serde(rename = "Trailer")]
|
|
Trailer,
|
|
#[serde(rename = "Series")]
|
|
Series,
|
|
#[serde(rename = "Music")]
|
|
Music,
|
|
#[serde(rename = "Book")]
|
|
Book,
|
|
#[serde(rename = "LiveTvChannel")]
|
|
LiveTvChannel,
|
|
#[serde(rename = "LiveTvProgram")]
|
|
LiveTvProgram,
|
|
#[serde(rename = "ChannelContent")]
|
|
ChannelContent,
|
|
#[serde(rename = "Other")]
|
|
Other,
|
|
}
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum Video3DFormat {
|
|
#[serde(rename = "HalfSideBySide")]
|
|
HalfSideBySide,
|
|
#[serde(rename = "FullSideBySide")]
|
|
FullSideBySide,
|
|
#[serde(rename = "FullTopAndBottom")]
|
|
FullTopAndBottom,
|
|
#[serde(rename = "HalfTopAndBottom")]
|
|
HalfTopAndBottom,
|
|
#[serde(rename = "MVC")]
|
|
Mvc,
|
|
}
|
|
/// An enum representing video ranges.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum VideoRange {
|
|
#[serde(rename = "Unknown")]
|
|
Unknown,
|
|
#[serde(rename = "SDR")]
|
|
Sdr,
|
|
#[serde(rename = "HDR")]
|
|
Hdr,
|
|
}
|
|
/// An enum representing types of video ranges.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum VideoRangeType {
|
|
#[serde(rename = "Unknown")]
|
|
Unknown,
|
|
#[serde(rename = "SDR")]
|
|
Sdr,
|
|
#[serde(rename = "HDR10")]
|
|
Hdr10,
|
|
#[serde(rename = "HLG")]
|
|
Hlg,
|
|
#[serde(rename = "DOVI")]
|
|
Dovi,
|
|
#[serde(rename = "DOVIWithHDR10")]
|
|
DoviWithHdr10,
|
|
#[serde(rename = "DOVIWithHLG")]
|
|
DoviWithHlg,
|
|
#[serde(rename = "DOVIWithSDR")]
|
|
DoviWithSdr,
|
|
#[serde(rename = "HDR10Plus")]
|
|
Hdr10Plus,
|
|
}
|
|
/// Enum VideoType.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub enum VideoType {
|
|
#[serde(rename = "VideoFile")]
|
|
VideoFile,
|
|
#[serde(rename = "Iso")]
|
|
Iso,
|
|
#[serde(rename = "Dvd")]
|
|
Dvd,
|
|
#[serde(rename = "BluRay")]
|
|
BluRay,
|
|
}
|