use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct AccessSchedule {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<i32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub day_of_week: Option<DayOfWeek>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub start_hour: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub end_hour: Option<f64>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ActivityLogEntry {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub overview: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub short_overview: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub item_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user_primary_image_tag: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub severity: Option<LogLevel>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ActivityLogEntryMessage {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub data: Option<Vec<ActivityLogEntry>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message_type: Option<SessionMessageType>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ActivityLogEntryQueryResult {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub items: Option<Vec<ActivityLogEntry>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub total_record_count: Option<i32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub start_index: Option<i32>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ActivityLogEntryStartMessage {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub data: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message_type: Option<SessionMessageType>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ActivityLogEntryStopMessage {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message_type: Option<SessionMessageType>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct AddVirtualFolderDto {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub library_options: Option<LibraryOptions>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct AlbumInfo {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub original_title: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata_language: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata_country_code: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub provider_ids: Option<BTreeMap<String, Option<String>>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<i32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub index_number: Option<i32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub parent_index_number: Option<i32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub premiere_date: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_automated: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub album_artists: Option<Vec<String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub artist_provider_ids: Option<BTreeMap<String, Option<String>>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub song_infos: Option<Vec<SongInfo>>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct AlbumInfoRemoteSearchQuery {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub search_info: Option<AlbumInfo>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub item_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub search_provider_name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub include_disabled_providers: Option<bool>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct AllThemeMediaResult {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub theme_videos_result: Option<ThemeMediaResult>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub theme_songs_result: Option<ThemeMediaResult>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub soundtrack_songs_result: Option<ThemeMediaResult>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ApiName(pub String);

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ArtistInfo {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub original_title: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata_language: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata_country_code: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub provider_ids: Option<BTreeMap<String, Option<String>>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<i32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub index_number: Option<i32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub parent_index_number: Option<i32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub premiere_date: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_automated: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub song_infos: Option<Vec<SongInfo>>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ArtistInfoRemoteSearchQuery {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub search_info: Option<ArtistInfo>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub item_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub search_provider_name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub include_disabled_providers: Option<bool>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum AudioSpatialFormat {
    None,
    DolbyAtmos,
    DTSX,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct AuthenticateUserByName {
    pub username: Option<String>,
    pub pw: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct AuthenticationInfo {
    pub id: Option<i64>,
    pub access_token: Option<String>,
    pub device_id: Option<String>,
    pub app_name: Option<String>,
    pub app_version: Option<String>,
    pub device_name: Option<String>,
    pub user_id: Option<String>,
    pub is_active: Option<bool>,
    pub date_created: Option<String>,
    pub date_revoked: Option<String>,
    pub date_last_activity: Option<String>,
    pub user_name: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct AuthenticationInfoQueryResult {
    pub items: Option<Vec<AuthenticationInfo>>,
    pub total_record_count: Option<i32>,
    pub start_index: Option<i32>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct AuthenticationResult {
    pub user: Option<UserDto>,
    pub session_info: Option<SessionInfoDto>,
    pub access_token: Option<String>,
    pub server_id: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct BaseItemDto {
    pub name: Option<String>,
    pub original_title: Option<String>,
    pub server_id: Option<String>,
    pub id: String,
    pub etag: Option<String>,
    pub source_type: Option<String>,
    pub playlist_item_id: Option<String>,
    pub date_created: Option<String>,
    pub date_last_media_added: Option<String>,
    pub extra_type: Option<ExtraType>,
    pub airs_before_season_number: Option<i32>,
    pub airs_after_season_number: Option<i32>,
    pub airs_before_episode_number: Option<i32>,
    pub can_delete: Option<bool>,
    pub can_download: Option<bool>,
    pub has_lyrics: Option<bool>,
    pub has_subtitles: Option<bool>,
    pub preferred_metadata_language: Option<String>,
    pub preferred_metadata_country_code: Option<String>,
    pub container: Option<String>,
    pub sort_name: Option<String>,
    pub forced_sort_name: Option<String>,
    pub video_3_d_format: Option<Video3DFormat>,
    pub premiere_date: Option<String>,
    pub external_urls: Option<Vec<ExternalUrl>>,
    pub media_sources: Option<Vec<MediaSourceInfo>>,
    pub critic_rating: Option<f32>,
    pub production_locations: Option<Vec<String>>,
    pub path: Option<String>,
    pub enable_media_source_display: Option<bool>,
    pub official_rating: Option<String>,
    pub custom_rating: Option<String>,
    pub channel_id: Option<String>,
    pub channel_name: Option<String>,
    pub overview: Option<String>,
    pub taglines: Option<Vec<String>>,
    pub genres: Option<Vec<String>>,
    pub community_rating: Option<f32>,
    pub cumulative_run_time_ticks: Option<i64>,
    pub run_time_ticks: Option<i64>,
    pub play_access: Option<PlayAccess>,
    pub aspect_ratio: Option<String>,
    pub production_year: Option<i32>,
    pub is_placeholder: Option<bool>,
    pub number: Option<String>,
    pub channel_number: Option<String>,
    pub index_number: Option<i32>,
    pub index_number_end: Option<i32>,
    pub parent_index_number: Option<i32>,
    pub remote_trailers: Option<Vec<MediaUrl>>,
    pub provider_ids: Option<BTreeMap<String, Option<String>>>,
    pub is_hd: Option<bool>,
    pub is_folder: Option<bool>,
    pub parent_id: Option<String>,
    pub r#type: Option<BaseItemKind>,
    pub people: Option<Vec<BaseItemPerson>>,
    pub studios: Option<Vec<NameGuidPair>>,
    pub genre_items: Option<Vec<NameGuidPair>>,
    pub parent_logo_item_id: Option<String>,
    pub parent_backdrop_item_id: Option<String>,
    pub parent_backdrop_image_tags: Option<Vec<String>>,
    pub local_trailer_count: Option<i32>,
    pub user_data: Option<UserItemDataDto>,
    pub recursive_item_count: Option<i32>,
    pub child_count: Option<i32>,
    pub series_name: Option<String>,
    pub series_id: Option<String>,
    pub season_id: Option<String>,
    pub special_feature_count: Option<i32>,
    pub display_preferences_id: Option<String>,
    pub status: Option<String>,
    pub air_time: Option<String>,
    pub air_days: Option<Vec<DayOfWeek>>,
    pub tags: Option<Vec<String>>,
    pub primary_image_aspect_ratio: Option<f64>,
    pub artists: Option<Vec<String>>,
    pub artist_items: Option<Vec<NameGuidPair>>,
    pub album: Option<String>,
    pub collection_type: Option<CollectionType>,
    pub display_order: Option<String>,
    pub album_id: Option<String>,
    pub album_primary_image_tag: Option<String>,
    pub series_primary_image_tag: Option<String>,
    pub album_artist: Option<String>,
    pub album_artists: Option<Vec<NameGuidPair>>,
    pub season_name: Option<String>,
    pub media_streams: Option<Vec<MediaStream>>,
    pub video_type: Option<VideoType>,
    pub part_count: Option<i32>,
    pub media_source_count: Option<i32>,
    pub image_tags: Option<BTreeMap<String, String>>,
    pub backdrop_image_tags: Option<Vec<String>>,
    pub screenshot_image_tags: Option<Vec<String>>,
    pub parent_logo_image_tag: Option<String>,
    pub parent_art_item_id: Option<String>,
    pub parent_art_image_tag: Option<String>,
    pub series_thumb_image_tag: Option<String>,
    pub image_blur_hashes: Option<ImageBlurHashes>,
    pub series_studio: Option<String>,
    pub parent_thumb_item_id: Option<String>,
    pub parent_thumb_image_tag: Option<String>,
    pub parent_primary_image_item_id: Option<String>,
    pub parent_primary_image_tag: Option<String>,
    pub chapters: Option<Vec<ChapterInfo>>,
    pub trickplay: Option<BTreeMap<String, BTreeMap<String, TrickplayInfo>>>,
    pub location_type: Option<LocationType>,
    pub iso_type: Option<IsoType>,
    pub media_type: Option<MediaType>,
    pub end_date: Option<String>,
    pub locked_fields: Option<Vec<MetadataField>>,
    pub trailer_count: Option<i32>,
    pub movie_count: Option<i32>,
    pub series_count: Option<i32>,
    pub program_count: Option<i32>,
    pub episode_count: Option<i32>,
    pub song_count: Option<i32>,
    pub album_count: Option<i32>,
    pub artist_count: Option<i32>,
    pub music_video_count: Option<i32>,
    pub lock_data: Option<bool>,
    pub width: Option<i32>,
    pub height: Option<i32>,
    pub camera_make: Option<String>,
    pub camera_model: Option<String>,
    pub software: Option<String>,
    pub exposure_time: Option<f64>,
    pub focal_length: Option<f64>,
    pub image_orientation: Option<ImageOrientation>,
    pub aperture: Option<f64>,
    pub shutter_speed: Option<f64>,
    pub latitude: Option<f64>,
    pub longitude: Option<f64>,
    pub altitude: Option<f64>,
    pub iso_speed_rating: Option<i32>,
    pub series_timer_id: Option<String>,
    pub program_id: Option<String>,
    pub channel_primary_image_tag: Option<String>,
    pub start_date: Option<String>,
    pub completion_percentage: Option<f64>,
    pub is_repeat: Option<bool>,
    pub episode_title: Option<String>,
    pub channel_type: Option<ChannelType>,
    pub audio: Option<ProgramAudio>,
    pub is_movie: Option<bool>,
    pub is_sports: Option<bool>,
    pub is_series: Option<bool>,
    pub is_live: Option<bool>,
    pub is_news: Option<bool>,
    pub is_kids: Option<bool>,
    pub is_premiere: Option<bool>,
    pub timer_id: Option<String>,
    pub normalization_gain: Option<f32>,
    pub current_program: Option<BaseItemDto>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct BaseItemDtoQueryResult {
    pub items: Option<Vec<BaseItemDto>>,
    pub total_record_count: Option<i32>,
    pub start_index: Option<i32>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum BaseItemKind {
    AggregateFolder,
    Audio,
    AudioBook,
    BasePluginFolder,
    Book,
    BoxSet,
    Channel,
    ChannelFolderItem,
    CollectionFolder,
    Episode,
    Folder,
    Genre,
    ManualPlaylistsFolder,
    Movie,
    LiveTvChannel,
    LiveTvProgram,
    MusicAlbum,
    MusicArtist,
    MusicGenre,
    MusicVideo,
    Person,
    Photo,
    PhotoAlbum,
    Playlist,
    PlaylistsFolder,
    Program,
    Recording,
    Season,
    Series,
    Studio,
    Trailer,
    TvChannel,
    TvProgram,
    UserRootFolder,
    UserView,
    Video,
    Year,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct BaseItemPerson {
    pub name: Option<String>,
    pub id: String,
    pub role: Option<String>,
    pub r#type: Option<PersonKind>,
    pub primary_image_tag: Option<String>,
    pub image_blur_hashes: Option<ImageBlurHashes>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct BasePluginConfiguration {
    // no properties
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct BookInfo {
    pub name: Option<String>,
    pub original_title: Option<String>,
    pub path: Option<String>,
    pub metadata_language: Option<String>,
    pub metadata_country_code: Option<String>,
    pub provider_ids: Option<BTreeMap<String, Option<String>>>,
    pub year: Option<i32>,
    pub index_number: Option<i32>,
    pub parent_index_number: Option<i32>,
    pub premiere_date: Option<String>,
    pub is_automated: Option<bool>,
    pub series_name: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct BookInfoRemoteSearchQuery {
    pub search_info: Option<BookInfo>,
    pub item_id: Option<String>,
    pub search_provider_name: Option<String>,
    pub include_disabled_providers: Option<bool>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct BoxSetInfo {
    pub name: Option<String>,
    pub original_title: Option<String>,
    pub path: Option<String>,
    pub metadata_language: Option<String>,
    pub metadata_country_code: Option<String>,
    pub provider_ids: Option<BTreeMap<String, Option<String>>>,
    pub year: Option<i32>,
    pub index_number: Option<i32>,
    pub parent_index_number: Option<i32>,
    pub premiere_date: Option<String>,
    pub is_automated: Option<bool>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct BoxSetInfoRemoteSearchQuery {
    pub search_info: Option<BoxSetInfo>,
    pub item_id: Option<String>,
    pub search_provider_name: Option<String>,
    pub include_disabled_providers: Option<bool>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct BrandingOptions {
    pub login_disclaimer: Option<String>,
    pub custom_css: Option<String>,
    pub splashscreen_enabled: Option<bool>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct BufferRequestDto {
    pub when: Option<String>,
    pub position_ticks: Option<i64>,
    pub is_playing: Option<bool>,
    pub playlist_item_id: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct CastReceiverApplication {
    pub id: String,
    pub name: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ChannelFeatures {
    pub name: String,
    pub id: String,
    pub can_search: Option<bool>,
    pub media_types: Option<Vec<ChannelMediaType>>,
    pub content_types: Option<Vec<ChannelMediaContentType>>,
    pub max_page_size: Option<i32>,
    pub auto_refresh_levels: Option<i32>,
    pub default_sort_fields: Option<Vec<ChannelItemSortField>>,
    pub supports_sort_order_toggle: Option<bool>,
    pub supports_latest_media: Option<bool>,
    pub can_filter: Option<bool>,
    pub supports_content_downloading: Option<bool>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum ChannelItemSortField {
    Name,
    CommunityRating,
    PremiereDate,
    DateCreated,
    Runtime,
    PlayCount,
    CommunityPlayCount,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ChannelMappingOptionsDto {
    pub tuner_channels: Option<Vec<TunerChannelMapping>>,
    pub provider_channels: Option<Vec<NameIdPair>>,
    pub mappings: Option<Vec<NameValuePair>>,
    pub provider_name: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum ChannelMediaContentType {
    Clip,
    Podcast,
    Trailer,
    Movie,
    Episode,
    Song,
    MovieExtra,
    TvExtra,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum ChannelMediaType {
    Audio,
    Video,
    Photo,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum ChannelType {
    TV,
    Radio,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ChapterInfo {
    pub start_position_ticks: Option<i64>,
    pub name: Option<String>,
    pub image_path: Option<String>,
    pub image_date_modified: Option<String>,
    pub image_tag: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct CheckpointId {
    pub id: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ClientCapabilitiesDto {
    pub playable_media_types: Option<Vec<MediaType>>,
    pub supported_commands: Option<Vec<GeneralCommandType>>,
    pub supports_media_control: Option<bool>,
    pub supports_persistent_identifier: Option<bool>,
    pub device_profile: Option<DeviceProfile>,
    pub app_store_url: Option<String>,
    pub icon_url: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ClientLogDocumentResponseDto {
    pub file_name: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct CodecProfile {
    pub r#type: Option<CodecType>,
    pub conditions: Option<Vec<ProfileCondition>>,
    pub apply_conditions: Option<Vec<ProfileCondition>>,
    pub codec: Option<String>,
    pub container: Option<String>,
    pub sub_container: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum CodecType {
    Video,
    VideoAudio,
    Audio,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct CollectionCreationResult {
    pub id: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum CollectionType {
    Unknown,
    Movies,
    Tvshows,
    Music,
    Musicvideos,
    Trailers,
    Homevideos,
    Boxsets,
    Books,
    Photos,
    Livetv,
    Playlists,
    Folders,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum CollectionTypeOptions {
    Movies,
    Tvshows,
    Music,
    Musicvideos,
    Homevideos,
    Boxsets,
    Books,
    Mixed,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ConfigImageTypes {
    pub backdrop_sizes: Option<Vec<String>>,
    pub base_url: Option<String>,
    pub logo_sizes: Option<Vec<String>>,
    pub poster_sizes: Option<Vec<String>>,
    pub profile_sizes: Option<Vec<String>>,
    pub secure_base_url: Option<String>,
    pub still_sizes: Option<Vec<String>>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ConfigurationPageInfo {
    pub name: String,
    pub enable_in_main_menu: Option<bool>,
    pub menu_section: Option<String>,
    pub menu_icon: Option<String>,
    pub display_name: Option<String>,
    pub plugin_id: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ContainerProfile {
    pub r#type: Option<DlnaProfileType>,
    pub conditions: Option<Vec<ProfileCondition>>,
    pub container: Option<String>,
    pub sub_container: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum CountryInfo {
    Name(String),
    DisplayName(String),
    TwoLetterISORegionName(String),
    ThreeLetterISORegionName(String),
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct CreatePlaylistDto {
    pub name: String,
    pub ids: Option<Vec<String>>,
    pub user_id: Option<String>,
    pub media_type: Option<MediaType>,
    pub users: Option<Vec<PlaylistUserPermissions>>,
    pub is_public: Option<bool>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct CreateUserByName {
    pub name: String,
    pub password: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct CultureDto {
    pub name: String,
    pub display_name: String,
    pub two_letter_i_s_o_language_name: String,
    pub three_letter_i_s_o_language_name: Option<String>,
    pub three_letter_i_s_o_language_names: Vec<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum DayOfWeek {
    Sunday,
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum DayPattern {
    Daily,
    Weekdays,
    Weekends,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct DefaultDirectoryBrowserInfoDto {
    pub path: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum DeinterlaceMethod {
    Yadif,
    Bwdif,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum DeviceInfoDto {
    Name: Option<String>,
    CustomName: Option<String>,
    AccessToken: Option<String>,
    Id: Option<String>,
    LastUserName: Option<String>,
    AppName: Option<String>,
    AppVersion: Option<String>,
    LastUserId: Option<String>,
    DateLastActivity: Option<String>,
    Capabilities: Option<ClientCapabilitiesDto>,
    IconUrl: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct DeviceInfoDtoQueryResult {
    pub items: Option<Vec<DeviceInfoDto>>,
    pub total_record_count: Option<i32>,
    pub start_index: Option<i32>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct DeviceOptionsDto {
    pub id: Option<i32>,
    pub device_id: Option<String>,
    pub custom_name: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct DeviceProfile {
    pub name: Option<String>,
    pub id: Option<String>,
    pub max_streaming_bitrate: Option<i32>,
    pub max_static_bitrate: Option<i32>,
    pub music_streaming_transcoding_bitrate: Option<i32>,
    pub max_static_music_bitrate: Option<i32>,
    pub direct_play_profiles: Option<Vec<DirectPlayProfile>>,
    pub transcoding_profiles: Option<Vec<TranscodingProfile>>,
    pub container_profiles: Option<Vec<ContainerProfile>>,
    pub codec_profiles: Option<Vec<CodecProfile>>,
    pub subtitle_profiles: Option<Vec<SubtitleProfile>>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct DirectPlayProfile {
    pub container: Option<String>,
    pub audio_codec: Option<String>,
    pub video_codec: Option<String>,
    pub r#type: Option<DlnaProfileType>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct DisplayPreferencesDto {
    pub id: Option<String>,
    pub view_type: Option<String>,
    pub sort_by: Option<String>,
    pub index_by: Option<String>,
    pub remember_indexing: Option<bool>,
    pub primary_image_height: Option<i32>,
    pub primary_image_width: Option<i32>,
    pub custom_prefs: Option<BTreeMap<String, Option<String>>>,
    pub scroll_direction: Option<ScrollDirection>,
    pub show_backdrop: Option<bool>,
    pub remember_sorting: Option<bool>,
    pub sort_order: Option<SortOrder>,
    pub show_sidebar: Option<bool>,
    pub client: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum DlnaProfileType {
    Audio,
    Video,
    Photo,
    Subtitle,
    Lyric,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum DownMixStereoAlgorithms {
    None,
    Dave750,
    NightmodeDialogue,
    Rfc7845,
    Ac4,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum EmbeddedSubtitleOptions {
    AllowAll,
    AllowText,
    AllowImage,
    AllowNone,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum EncoderPreset {
    Auto,
    Placebo,
    Varieslow,
    Slower,
    Slow,
    Medium,
    Fast,
    Faster,
    Veryfast,
    Superfast,
    Ultrafast,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum EncodingContext {
    Streaming,
    Static,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct EncodingOptions {
    pub encoding_thread_count: Option<i32>,
    pub transcoding_temp_path: Option<String>,
    pub fallback_font_path: Option<String>,
    pub enable_fallback_font: Option<bool>,
    pub enable_audio_vbr: Option<bool>,
    pub down_mix_audio_boost: Option<f64>,
    pub down_mix_stereo_algorithm: Option<DownMixStereoAlgorithms>,
    pub max_muxing_queue_size: Option<i32>,
    pub enable_throttling: Option<bool>,
    pub throttle_delay_seconds: Option<i32>,
    pub enable_segment_deletion: Option<bool>,
    pub segment_keep_seconds: Option<i32>,
    pub hardware_acceleration_type: Option<HardwareAccelerationType>,
    pub encoder_app_path: Option<String>,
    pub encoder_app_path_display: Option<String>,
    pub vaapi_device: Option<String>,
    pub qsv_device: Option<String>,
    pub enable_tonemapping: Option<bool>,
    pub enable_vpp_tonemapping: Option<bool>,
    pub enable_video_toolbox_tonemapping: Option<bool>,
    pub tonemapping_algorithm: Option<TonemappingAlgorithm>,
    pub tonemapping_mode: Option<TonemappingMode>,
    pub tonemapping_range: Option<TonemappingRange>,
    pub tonemapping_desat: Option<f64>,
    pub tonemapping_peak: Option<f64>,
    pub tonemapping_param: Option<f64>,
    pub vpp_tonemapping_brightness: Option<f64>,
    pub vpp_tonemapping_contrast: Option<f64>,
    pub h264_crf: Option<i32>,
    pub h265_crf: Option<i32>,
    pub encoder_preset: Option<EncoderPreset>,
    pub deinterlace_double_rate: Option<bool>,
    pub deinterlace_method: Option<DeinterlaceMethod>,
    pub enable_decoding_color_depth_10_hevc: Option<bool>,
    pub enable_decoding_color_depth_10_vp9: Option<bool>,
    pub enable_decoding_color_depth_10_hevc_rext: Option<bool>,
    pub enable_decoding_color_depth_12_hevc_rext: Option<bool>,
    pub enable_enhanced_nvdec_decoder: Option<bool>,
    pub prefer_system_native_hw_decoder: Option<bool>,
    pub enable_intel_low_power_h264_hw_encoder: Option<bool>,
    pub enable_intel_low_power_hevc_hw_encoder: Option<bool>,
    pub enable_hardware_encoding: Option<bool>,
    pub allow_hevc_encoding: Option<bool>,
    pub allow_av1_encoding: Option<bool>,
    pub enable_subtitle_extraction: Option<bool>,
    pub hardware_decoding_codecs: Option<Vec<String>>,
    pub allow_on_demand_metadata_based_keyframe_extraction_for_extensions: Option<Vec<String>>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum EndPointInfo {
    is_local: Option<bool>,
    is_in_network: Option<bool>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ExternalIdInfo {
    pub name: String,
    pub key: String,
    pub r#type: Option<ExternalIdMediaType>,
    pub url_format_string: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum ExternalIdMediaType {
    Album,
    AlbumArtist,
    Artist,
    BoxSet,
    Episode,
    Movie,
    OtherArtist,
    Person,
    ReleaseGroup,
    Season,
    Series,
    Track,
    Book,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ExternalUrl {
    pub name: Option<String>,
    pub url: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum ExtraType {
    Unknown,
    Clip,
    Trailer,
    BehindTheScenes,
    DeletedScene,
    Interview,
    Scene,
    Sample,
    ThemeSong,
    ThemeVideo,
    Featurette,
    Short,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct FileSystemEntryInfo {
    pub name: String,
    pub path: String,
    pub r#type: Option<FileSystemEntryType>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum FileSystemEntryType {
    File,
    Directory,
    NetworkComputer,
    NetworkShare,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct FontFile {
    pub name: Option<String>,
    pub size: i64,
    pub date_created: String,
    pub date_modified: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum ForceKeepAliveMessage {
    Data: Option<i32>,
    MessageId: String,
    MessageType: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum ForgotPasswordAction {
    ContactAdmin,
    PinCode,
    InNetworkRequired,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ForgotPasswordDto {
    pub entered_username: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ForgotPasswordPinDto {
    pub pin: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ForgotPasswordResult {
    pub action: ForgotPasswordAction,
    pub pin_file: Option<String>,
    pub pin_expiration_date: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct GeneralCommand {
    pub name: GeneralCommandType,
    pub controlling_user_id: Option<String>,
    pub arguments: Option<BTreeMap<String, Option<String>>>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct GeneralCommandMessage {
    pub data: Option<GeneralCommand>,
    pub message_id: String,
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum GeneralCommandType {
    MoveUp,
    MoveDown,
    MoveLeft,
    MoveRight,
    PageUp,
    PageDown,
    PreviousLetter,
    NextLetter,
    ToggleOsd,
    ToggleContextMenu,
    Select,
    Back,
    TakeScreenshot,
    SendKey,
    SendString,
    GoHome,
    GoToSettings,
    VolumeUp,
    VolumeDown,
    Mute,
    Unmute,
    ToggleMute,
    SetVolume,
    SetAudioStreamIndex,
    SetSubtitleStreamIndex,
    ToggleFullscreen,
    DisplayContent,
    GoToSearch,
    DisplayMessage,
    SetRepeatMode,
    ChannelUp,
    ChannelDown,
    Guide,
    ToggleStats,
    PlayMediaSource,
    PlayTrailers,
    SetShuffleQueue,
    PlayState,
    PlayNext,
    ToggleOsdMenu,
    Play,
    SetMaxStreamingBitrate,
    SetPlaybackOrder,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct GetProgramsDto {
    pub channel_ids: Option<Vec<String>>,
    pub user_id: Option<String>,
    pub min_start_date: Option<String>,
    pub has_aired: Option<bool>,
    pub is_airing: Option<bool>,
    pub max_start_date: Option<String>,
    pub min_end_date: Option<String>,
    pub max_end_date: Option<String>,
    pub is_movie: Option<bool>,
    pub is_series: Option<bool>,
    pub is_news: Option<bool>,
    pub is_kids: Option<bool>,
    pub is_sports: Option<bool>,
    pub start_index: Option<i32>,
    pub limit: Option<i32>,
    pub sort_by: Option<Vec<ItemSortBy>>,
    pub sort_order: Option<Vec<SortOrder>>,
    pub genres: Option<Vec<String>>,
    pub genre_ids: Option<Vec<String>>,
    pub enable_images: Option<bool>,
    pub enable_total_record_count: Option<bool>,
    pub image_type_limit: Option<i32>,
    pub enable_image_types: Option<Vec<ImageType>>,
    pub enable_user_data: Option<bool>,
    pub series_timer_id: Option<String>,
    pub library_series_id: Option<String>,
    pub fields: Option<Vec<ItemFields>>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct GroupInfoDto {
    pub group_id: String,
    pub group_name: String,
    pub state: GroupStateType,
    pub participants: Vec<String>,
    pub last_updated_at: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct GroupInfoDtoGroupUpdate {
    pub group_id: String,
    pub r#type: GroupUpdateType,
    pub data: Option<GroupInfoDto>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum GroupQueueMode {
    Queue,
    QueueNext,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum GroupRepeatMode {
    RepeatOne,
    RepeatAll,
    RepeatNone,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum GroupShuffleMode {
    Sorted,
    Shuffle,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum GroupStateType {
    Idle,
    Waiting,
    Paused,
    Playing,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct GroupStateUpdate {
    pub state: GroupStateType,
    pub reason: PlaybackRequestType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct GroupStateUpdateGroupUpdate {
    pub group_id: String,
    pub r#type: GroupUpdateType,
    pub data: Option<GroupStateUpdate>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum GroupUpdateType {
    UserJoined,
    UserLeft,
    GroupJoined,
    GroupLeft,
    StateUpdate,
    PlayQueue,
    NotInGroup,
    GroupDoesNotExist,
    CreateGroupDenied,
    JoinGroupDenied,
    LibraryAccessDenied,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct GuideInfo {
    pub start_date: String,
    pub end_date: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum HardwareAccelerationType {
    None,
    Amf,
    Qsv,
    Nvenc,
    V4l2m2m,
    Vaapi,
    Videotoolbox,
    Rkmpp,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct IgnoreWaitRequestDto {
    pub ignore_wait: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum ImageFormat {
    Bmp,
    Gif,
    Jpg,
    Png,
    Webp,
    Svg,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ImageInfo {
    pub image_type: ImageType,
    pub image_index: Option<i32>,
    pub image_tag: Option<String>,
    pub path: Option<String>,
    pub blur_hash: Option<String>,
    pub height: Option<i32>,
    pub width: Option<i32>,
    pub size: i64,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ImageOption {
    pub r#type: ImageType,
    pub limit: Option<i32>,
    pub min_width: Option<i32>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum ImageOrientation {
    TopLeft,
    TopRight,
    BottomRight,
    BottomLeft,
    LeftTop,
    RightTop,
    RightBottom,
    LeftBottom,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ImageProviderInfo {
    pub name: String,
    pub supported_images: Vec<ImageType>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum ImageResolution {
    MatchSource,
    P144,
    P240,
    P360,
    P480,
    P720,
    P1080,
    P1440,
    P2160,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum ImageSavingConvention {
    Legacy,
    Compatible,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum ImageType {
    Primary,
    Art,
    Backdrop,
    Banner,
    Logo,
    Thumb,
    Disc,
    Box,
    Screenshot,
    Menu,
    Chapter,
    BoxRear,
    Profile,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct InboundKeepAliveMessage {
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct InboundWebSocketMessage {
    #[serde(flatten)]
    pub message: WebSocketMessage,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct InstallationInfo {
    pub guid: String,
    pub name: Option<String>,
    pub version: Option<String>,
    pub changelog: Option<String>,
    pub source_url: Option<String>,
    pub checksum: Option<String>,
    pub package_info: Option<PackageInfo>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct IPlugin {
    pub name: Option<String>,
    pub description: Option<String>,
    pub id: String,
    pub version: Option<String>,
    pub assembly_file_path: Option<String>,
    pub can_uninstall: bool,
    pub data_folder_path: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum IsoType {
    Dvd,
    BluRay,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ItemCounts {
    pub movie_count: i32,
    pub series_count: i32,
    pub episode_count: i32,
    pub artist_count: i32,
    pub program_count: i32,
    pub trailer_count: i32,
    pub song_count: i32,
    pub album_count: i32,
    pub music_video_count: i32,
    pub box_set_count: i32,
    pub book_count: i32,
    pub item_count: i32,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum ItemFields {
    AirTime,
    CanDelete,
    CanDownload,
    ChannelInfo,
    Chapters,
    Trickplay,
    ChildCount,
    CumulativeRunTimeTicks,
    CustomRating,
    DateCreated,
    DateLastMediaAdded,
    DisplayPreferencesId,
    Etag,
    ExternalUrls,
    Genres,
    HomePageUrl,
    ItemCounts,
    MediaSourceCount,
    MediaSources,
    OriginalTitle,
    Overview,
    ParentId,
    Path,
    People,
    PlayAccess,
    ProductionLocations,
    ProviderIds,
    PrimaryImageAspectRatio,
    RecursiveItemCount,
    Settings,
    ScreenshotImageTags,
    SeriesPrimaryImage,
    SeriesStudio,
    SortName,
    SpecialEpisodeNumbers,
    Studios,
    Taglines,
    Tags,
    RemoteTrailers,
    MediaStreams,
    SeasonUserData,
    ServiceName,
    ThemeSongIds,
    ThemeVideoIds,
    ExternalEtag,
    PresentationUniqueKey,
    InheritedParentalRatingValue,
    ExternalSeriesId,
    SeriesPresentationUniqueKey,
    DateLastRefreshed,
    DateLastSaved,
    RefreshState,
    ChannelImage,
    EnableMediaSourceDisplay,
    Width,
    Height,
    ExtraIds,
    LocalTrailerCount,
    IsHD,
    SpecialFeatureCount,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum ItemFilter {
    IsFolder,
    IsNotFolder,
    IsUnplayed,
    IsPlayed,
    IsFavorite,
    IsResumable,
    Likes,
    Dislikes,
    IsFavoriteOrLikes,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum ItemSortBy {
    Default,
    AiredEpisodeOrder,
    Album,
    AlbumArtist,
    Artist,
    DateCreated,
    OfficialRating,
    DatePlayed,
    PremiereDate,
    StartDate,
    SortName,
    Name,
    Random,
    Runtime,
    CommunityRating,
    ProductionYear,
    PlayCount,
    CriticRating,
    IsFolder,
    IsUnplayed,
    IsPlayed,
    SeriesSortName,
    VideoBitRate,
    AirTime,
    Studio,
    IsFavoriteOrLiked,
    DateLastContentAdded,
    SeriesDatePlayed,
    ParentIndexNumber,
    IndexNumber,
    SimilarityScore,
    SearchScore,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct JoinGroupRequestDto {
    pub group_id: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum KeepUntil {
    UntilDeleted,
    UntilSpaceNeeded,
    UntilWatched,
    UntilDate,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct LibraryChangedMessage {
    pub data: Option<LibraryUpdateInfo>,
    pub message_id: String,
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct LibraryOptionInfoDto {
    pub name: Option<String>,
    pub default_enabled: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct LibraryOptions {
    pub enabled: bool,
    pub enable_photos: bool,
    pub enable_realtime_monitor: bool,
    pub enable_lufs_scan: bool,
    pub enable_chapter_image_extraction: bool,
    pub extract_chapter_images_during_library_scan: bool,
    pub enable_trickplay_image_extraction: bool,
    pub extract_trickplay_images_during_library_scan: bool,
    pub path_infos: Option<Vec<MediaPathInfo>>,
    pub save_local_metadata: bool,
    pub enable_internet_providers: bool,
    pub enable_automatic_series_grouping: bool,
    pub enable_embedded_titles: bool,
    pub enable_embedded_extras_titles: bool,
    pub enable_embedded_episode_infos: bool,
    pub automatic_refresh_interval_days: Option<i32>,
    pub preferred_metadata_language: Option<String>,
    pub metadata_country_code: Option<String>,
    pub season_zero_display_name: String,
    pub metadata_savers: Option<Vec<String>>,
    pub disabled_local_metadata_readers: Vec<String>,
    pub local_metadata_reader_order: Option<Vec<String>>,
    pub disabled_subtitle_fetchers: Vec<String>,
    pub subtitle_fetcher_order: Vec<String>,
    pub disabled_media_segment_providers: Vec<String>,
    pub media_segment_provide_order: Vec<String>,
    pub skip_subtitles_if_embedded_subtitles_present: bool,
    pub skip_subtitles_if_audio_track_matches: bool,
    pub subtitle_download_languages: Option<Vec<String>>,
    pub require_perfect_subtitle_match: bool,
    pub save_subtitles_with_media: bool,
    pub save_lyrics_with_media: bool,
    pub save_trickplay_with_media: bool,
    pub disabled_lyric_fetchers: Vec<String>,
    pub lyric_fetcher_order: Vec<String>,
    pub prefer_nonstandard_artists_tag: bool,
    pub use_custom_tag_delimiters: bool,
    pub custom_tag_delimiters: Option<Vec<String>>,
    pub delimiter_whitelist: Option<Vec<String>>,
    pub automatically_add_to_collection: bool,
    pub allow_embedded_subtitles: EmbeddedSubtitleOptions,
    pub type_options: Option<Vec<TypeOptions>>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct LibraryOptionsResultDto {
    pub metadata_savers: Option<Vec<LibraryOptionInfoDto>>,
    pub metadata_readers: Option<Vec<LibraryOptionInfoDto>>,
    pub subtitle_fetchers: Option<Vec<LibraryOptionInfoDto>>,
    pub lyric_fetchers: Option<Vec<LibraryOptionInfoDto>>,
    pub type_options: Option<Vec<LibraryTypeOptionsDto>>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct LibraryTypeOptionsDto {
    pub r#type: Option<String>,
    pub metadata_fetchers: Option<Vec<LibraryOptionInfoDto>>,
    pub image_fetchers: Option<Vec<LibraryOptionInfoDto>>,
    pub supported_image_types: Option<Vec<ImageType>>,
    pub default_image_options: Option<Vec<ImageOption>>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct LibraryUpdateInfo {
    pub folders_added_to: Option<Vec<String>>,
    pub folders_removed_from: Option<Vec<String>>,
    pub items_added: Option<Vec<String>>,
    pub items_removed: Option<Vec<String>>,
    pub items_updated: Option<Vec<String>>,
    pub collection_folders: Option<Vec<String>>,
    pub is_empty: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ListingsProviderInfo {
    pub id: Option<String>,
    pub r#type: Option<String>,
    pub username: Option<String>,
    pub password: Option<String>,
    pub listings_id: Option<String>,
    pub zip_code: Option<String>,
    pub country: Option<String>,
    pub path: Option<String>,
    pub enabled_tuners: Option<Vec<String>>,
    pub enable_all_tuners: bool,
    pub news_categories: Option<Vec<String>>,
    pub sports_categories: Option<Vec<String>>,
    pub kids_categories: Option<Vec<String>>,
    pub movie_categories: Option<Vec<String>>,
    pub channel_mappings: Option<Vec<NameValuePair>>,
    pub movie_prefix: Option<String>,
    pub preferred_language: Option<String>,
    pub user_agent: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct LiveStreamResponse {
    pub media_source: MediaSourceInfo,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct LiveTvInfo {
    pub services: Vec<LiveTvServiceInfo>,
    pub is_enabled: bool,
    pub enabled_users: Vec<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct LiveTvOptions {
    pub guide_days: Option<i32>,
    pub recording_path: Option<String>,
    pub movie_recording_path: Option<String>,
    pub series_recording_path: Option<String>,
    pub enable_recording_subfolders: bool,
    pub enable_original_audio_with_encoded_recordings: bool,
    pub tuner_hosts: Option<Vec<TunerHostInfo>>,
    pub listing_providers: Option<Vec<ListingsProviderInfo>>,
    pub pre_padding_seconds: i32,
    pub post_padding_seconds: i32,
    pub media_locations_created: Option<Vec<String>>,
    pub recording_post_processor: Option<String>,
    pub recording_post_processor_arguments: Option<String>,
    pub save_recording_nfo: bool,
    pub save_recording_images: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct LiveTvServiceInfo {
    pub name: Option<String>,
    pub home_page_url: Option<String>,
    pub status: LiveTvServiceStatus,
    pub status_message: Option<String>,
    pub version: Option<String>,
    pub has_update_available: bool,
    pub is_visible: bool,
    pub tuners: Option<Vec<String>>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum LiveTvServiceStatus {
    Ok,
    Unavailable,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct LocalizationOption {
    pub name: Option<String>,
    pub value: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct LocationType {
    pub r#type: LocationTypeEnum,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum LocationTypeEnum {
    FileSystem,
    Remote,
    Virtual,
    Offline,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct LogFile {
    pub date_created: String,
    pub date_modified: String,
    pub size: i64,
    pub name: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct LoginInfoInput {
    pub username: String,
    pub password: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct LyricDto {
    pub metadata: LyricMetadata,
    pub lyrics: Vec<LyricLine>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct LyricLine {
    pub text: String,
    pub start: Option<i64>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct LyricMetadata {
    pub artist: Option<String>,
    pub album: Option<String>,
    pub title: Option<String>,
    pub author: Option<String>,
    pub length: Option<i64>,
    pub by: Option<String>,
    pub offset: Option<i64>,
    pub creator: Option<String>,
    pub version: Option<String>,
    pub is_synced: Option<bool>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct MediaAttachment {
    pub codec: Option<String>,
    pub codec_tag: Option<String>,
    pub comment: Option<String>,
    pub index: i32,
    pub file_name: Option<String>,
    pub mime_type: Option<String>,
    pub delivery_url: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct MediaPathDto {
    pub name: String,
    pub path: Option<String>,
    pub path_info: Option<MediaPathInfo>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct MediaPathInfo {
    pub path: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum MediaProtocol {
    File,
    Http,
    Rtmp,
    Rtsp,
    Udp,
    Rtp,
    Ftp,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct MediaSegmentDto {
    pub id: String,
    pub item_id: String,
    pub r#type: MediaSegmentType,
    pub start_ticks: i64,
    pub end_ticks: i64,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum MediaSegmentType {
    Unknown,
    Commercial,
    Preview,
    Recap,
    Outro,
    Intro,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct MediaSegmentDtoQueryResult {
    pub items: Option<Vec<MediaSegmentDto>>,
    pub total_record_count: Option<i32>,
    pub start_index: Option<i32>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct MediaSourceInfo {
    pub protocol: MediaProtocol,
    pub id: Option<String>,
    pub path: Option<String>,
    pub encoder_path: Option<String>,
    pub encoder_protocol: Option<MediaProtocol>,
    pub r#type: MediaSourceType,
    pub container: Option<String>,
    pub size: Option<i64>,
    pub name: Option<String>,
    pub is_remote: bool,
    pub etag: Option<String>,
    pub run_time_ticks: Option<i64>,
    pub read_at_native_framerate: bool,
    pub ignore_dts: bool,
    pub ignore_index: bool,
    pub gen_pts_input: bool,
    pub supports_transcoding: bool,
    pub supports_direct_stream: bool,
    pub supports_direct_play: bool,
    pub is_infinite_stream: bool,
    pub use_most_compatible_transcoding_profile: bool,
    pub requires_opening: bool,
    pub open_token: Option<String>,
    pub requires_closing: bool,
    pub live_stream_id: Option<String>,
    pub buffer_ms: Option<i32>,
    pub requires_looping: bool,
    pub supports_probing: bool,
    pub video_type: Option<VideoType>,
    pub iso_type: Option<IsoType>,
    pub video_3_d_format: Option<Video3DFormat>,
    pub media_streams: Option<Vec<MediaStream>>,
    pub media_attachments: Option<Vec<MediaAttachment>>,
    pub formats: Option<Vec<String>>,
    pub bitrate: Option<i32>,
    pub fallback_max_streaming_bitrate: Option<i32>,
    pub timestamp: Option<TransportStreamTimestamp>,
    pub required_http_headers: Option<BTreeMap<String, Option<String>>>,
    pub transcoding_url: Option<String>,
    pub transcoding_sub_protocol: Option<MediaStreamProtocol>,
    pub transcoding_container: Option<String>,
    pub analyze_duration_ms: Option<i32>,
    pub default_audio_stream_index: Option<i32>,
    pub default_subtitle_stream_index: Option<i32>,
    pub has_segments: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum MediaSourceType {
    Default,
    Grouping,
    Placeholder,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct MediaStream {
    pub codec: Option<String>,
    pub codec_tag: Option<String>,
    pub language: Option<String>,
    pub color_range: Option<String>,
    pub color_space: Option<String>,
    pub color_transfer: Option<String>,
    pub color_primaries: Option<String>,
    pub dv_version_major: Option<i32>,
    pub dv_version_minor: Option<i32>,
    pub dv_profile: Option<i32>,
    pub dv_level: Option<i32>,
    pub rpu_present_flag: Option<i32>,
    pub el_present_flag: Option<i32>,
    pub bl_present_flag: Option<i32>,
    pub dv_bl_signal_compatibility_id: Option<i32>,
    pub rotation: Option<i32>,
    pub comment: Option<String>,
    pub time_base: Option<String>,
    pub codec_time_base: Option<String>,
    pub title: Option<String>,
    pub video_range: VideoRange,
    pub video_range_type: VideoRangeType,
    pub video_do_vi_title: Option<String>,
    pub audio_spatial_format: AudioSpatialFormat,
    pub localized_undefined: Option<String>,
    pub localized_default: Option<String>,
    pub localized_forced: Option<String>,
    pub localized_external: Option<String>,
    pub localized_hearing_impaired: Option<String>,
    pub display_title: Option<String>,
    pub nal_length_size: Option<String>,
    pub is_interlaced: bool,
    pub is_avc: Option<bool>,
    pub channel_layout: Option<String>,
    pub bitrate: Option<i32>,
    pub bit_depth: Option<i32>,
    pub ref_frames: Option<i32>,
    pub packet_length: Option<i32>,
    pub channels: Option<i32>,
    pub sample_rate: Option<i32>,
    pub is_default: bool,
    pub is_forced: bool,
    pub is_hearing_impaired: bool,
    pub height: Option<i32>,
    pub width: Option<i32>,
    pub average_framerate: Option<f32>,
    pub real_framerate: Option<f32>,
    pub reference_framerate: Option<f32>,
    pub profile: Option<String>,
    pub r#type: MediaStreamType,
    pub aspect_ratio: Option<String>,
    pub index: i32,
    pub score: Option<i32>,
    pub is_external: bool,
    pub delivery_method: Option<SubtitleDeliveryMethod>,
    pub delivery_url: Option<String>,
    pub is_external_url: Option<bool>,
    pub is_text_subtitle_stream: bool,
    pub supports_external_stream: bool,
    pub path: Option<String>,
    pub pixel_format: Option<String>,
    pub level: Option<f64>,
    pub is_anamorphic: Option<bool>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum MediaStreamProtocol {
    Http,
    Hls,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum MediaStreamType {
    Audio,
    Video,
    Subtitle,
    EmbeddedImage,
    Data,
    Lyric,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum MediaType {
    Unknown,
    Video,
    Audio,
    Photo,
    Book,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct MediaUpdateInfoDto {
    pub updates: Option<Vec<MediaUpdateInfoPathDto>>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct MediaUpdateInfoPathDto {
    pub path: Option<String>,
    pub update_type: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct MediaUrl {
    pub url: Option<String>,
    pub name: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct MessageCommand {
    pub header: Option<String>,
    pub text: String,
    pub timeout_ms: Option<i64>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct MetadataConfiguration {
    pub use_file_creation_time_for_date_added: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct MetadataEditorInfo {
    pub parental_rating_options: Vec<ParentalRating>,
    pub countries: Vec<CountryInfo>,
    pub cultures: Vec<CultureDto>,
    pub external_id_infos: Vec<ExternalIdInfo>,
    pub content_type: Option<CollectionType>,
    pub content_type_options: Vec<NameValuePair>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct MetadataField {
    pub r#type: MetadataFieldEnum,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum MetadataFieldEnum {
    Cast,
    Genres,
    ProductionLocations,
    Studios,
    Tags,
    Name,
    Overview,
    Runtime,
    OfficialRating,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct MetadataOptions {
    pub item_type: Option<String>,
    pub disabled_metadata_savers: Option<Vec<String>>,
    pub local_metadata_reader_order: Option<Vec<String>>,
    pub disabled_metadata_fetchers: Option<Vec<String>>,
    pub metadata_fetcher_order: Option<Vec<String>>,
    pub disabled_image_fetchers: Option<Vec<String>>,
    pub image_fetcher_order: Option<Vec<String>>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum MetadataRefreshMode {
    None,
    ValidationOnly,
    Default,
    FullRefresh,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct MovePlaylistItemRequestDto {
    pub playlist_item_id: String,
    pub new_index: i32,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct MovieInfo {
    pub name: Option<String>,
    pub original_title: Option<String>,
    pub path: Option<String>,
    pub metadata_language: Option<String>,
    pub metadata_country_code: Option<String>,
    pub provider_ids: Option<BTreeMap<String, Option<String>>>,
    pub year: Option<i32>,
    pub index_number: Option<i32>,
    pub parent_index_number: Option<i32>,
    pub premiere_date: Option<String>,
    pub is_automated: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct MovieInfoRemoteSearchQuery {
    pub search_info: Option<MovieInfo>,
    pub item_id: String,
    pub search_provider_name: Option<String>,
    pub include_disabled_providers: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct MusicVideoInfo {
    pub name: Option<String>,
    pub original_title: Option<String>,
    pub path: Option<String>,
    pub metadata_language: Option<String>,
    pub metadata_country_code: Option<String>,
    pub provider_ids: Option<BTreeMap<String, Option<String>>>,
    pub year: Option<i32>,
    pub index_number: Option<i32>,
    pub parent_index_number: Option<i32>,
    pub premiere_date: Option<String>,
    pub is_automated: bool,
    pub artists: Option<Vec<String>>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct MusicVideoInfoRemoteSearchQuery {
    pub search_info: Option<MusicVideoInfo>,
    pub item_id: String,
    pub search_provider_name: Option<String>,
    pub include_disabled_providers: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct NameGuidPair {
    pub name: Option<String>,
    pub id: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct NameIdPair {
    pub name: Option<String>,
    pub id: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct NameValuePair {
    pub name: Option<String>,
    pub value: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct NetworkConfiguration {
    pub base_url: String,
    pub enable_https: bool,
    pub require_https: bool,
    pub certificate_path: String,
    pub certificate_password: String,
    pub internal_http_port: i32,
    pub internal_https_port: i32,
    pub public_http_port: i32,
    pub public_https_port: i32,
    pub auto_discovery: bool,
    pub enable_upnp: bool,
    pub enable_ipv4: bool,
    pub enable_ipv6: bool,
    pub enable_remote_access: bool,
    pub local_network_subnets: Vec<String>,
    pub local_network_addresses: Vec<String>,
    pub known_proxies: Vec<String>,
    pub ignore_virtual_interfaces: bool,
    pub virtual_interface_names: Vec<String>,
    pub enable_published_server_uri_by_request: bool,
    pub published_server_uri_by_subnet: Vec<String>,
    pub remote_ip_filter: Vec<String>,
    pub is_remote_ip_filter_blacklist: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct NewGroupRequestDto {
    pub group_name: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct NextItemRequestDto {
    pub playlist_item_id: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct OpenLiveStreamDto {
    pub open_token: Option<String>,
    pub user_id: Option<String>,
    pub play_session_id: Option<String>,
    pub max_streaming_bitrate: Option<i32>,
    pub start_time_ticks: Option<i64>,
    pub audio_stream_index: Option<i32>,
    pub subtitle_stream_index: Option<i32>,
    pub max_audio_channels: Option<i32>,
    pub item_id: Option<String>,
    pub enable_direct_play: Option<bool>,
    pub enable_direct_stream: Option<bool>,
    pub always_burn_in_subtitle_when_transcoding: Option<bool>,
    pub device_profile: Option<DeviceProfile>,
    pub direct_play_protocols: Option<Vec<MediaProtocol>>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct OutboundKeepAliveMessage {
    pub message_id: String,
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct OutboundWebSocketMessage {
    #[serde(flatten)]
    pub message: WebSocketMessage,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PackageInfo {
    pub name: String,
    pub description: String,
    pub overview: String,
    pub owner: String,
    pub category: String,
    pub guid: String,
    pub versions: Vec<VersionInfo>,
    pub image_url: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ParameterInclude {
    pub r#type: ParameterIncludeEnum,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum ParameterIncludeEnum {
    ProviderList,
    LocalIpAddress,
    LocalPort,
    Https,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ParentalRating {
    pub name: Option<String>,
    pub value: Option<i32>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PathSubstitution {
    pub from: String,
    pub to: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PersonKind {
    pub r#type: PersonKindEnum,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum PersonKindEnum {
    Unknown,
    Actor,
    Director,
    Composer,
    Writer,
    GuestStar,
    Producer,
    Conductor,
    Lyricist,
    Arranger,
    Engineer,
    Mixer,
    Remixer,
    Creator,
    Artist,
    AlbumArtist,
    Author,
    Illustrator,
    Penciller,
    Inker,
    Colorist,
    Letterer,
    CoverArtist,
    Editor,
    Translator,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PersonLookupInfo {
    pub name: Option<String>,
    pub original_title: Option<String>,
    pub path: Option<String>,
    pub metadata_language: Option<String>,
    pub metadata_country_code: Option<String>,
    pub provider_ids: Option<BTreeMap<String, Option<String>>>,
    pub year: Option<i32>,
    pub index_number: Option<i32>,
    pub parent_index_number: Option<i32>,
    pub premiere_date: Option<String>,
    pub is_automated: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PersonLookupInfoRemoteSearchQuery {
    pub search_info: Option<PersonLookupInfo>,
    pub item_id: String,
    pub search_provider_name: Option<String>,
    pub include_disabled_providers: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PingRequestDto {
    pub ping: i64,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PinRedeemResult {
    pub success: bool,
    pub users_reset: Vec<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum PlayAccess {
    Full,
    None,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum PlaybackErrorCode {
    NotAllowed,
    NoCompatibleStream,
    RateLimitExceeded,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PlaybackInfoDto {
    pub user_id: Option<String>,
    pub max_streaming_bitrate: Option<i32>,
    pub start_time_ticks: Option<i64>,
    pub audio_stream_index: Option<i32>,
    pub subtitle_stream_index: Option<i32>,
    pub max_audio_channels: Option<i32>,
    pub media_source_id: Option<String>,
    pub live_stream_id: Option<String>,
    pub device_profile: Option<DeviceProfile>,
    pub enable_direct_play: Option<bool>,
    pub enable_direct_stream: Option<bool>,
    pub enable_transcoding: Option<bool>,
    pub allow_video_stream_copy: Option<bool>,
    pub allow_audio_stream_copy: Option<bool>,
    pub auto_open_live_stream: Option<bool>,
    pub always_burn_in_subtitle_when_transcoding: Option<bool>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PlaybackInfoResponse {
    pub media_sources: Vec<MediaSourceInfo>,
    pub play_session_id: Option<String>,
    pub error_code: Option<PlaybackErrorCode>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum PlaybackOrder {
    Default,
    Shuffle,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PlaybackProgressInfo {
    pub can_seek: bool,
    pub item: Option<BaseItemDto>,
    pub item_id: String,
    pub session_id: Option<String>,
    pub media_source_id: Option<String>,
    pub audio_stream_index: Option<i32>,
    pub subtitle_stream_index: Option<i32>,
    pub is_paused: bool,
    pub is_muted: bool,
    pub position_ticks: Option<i64>,
    pub playback_start_time_ticks: Option<i64>,
    pub volume_level: Option<i32>,
    pub brightness: Option<i32>,
    pub aspect_ratio: Option<String>,
    pub play_method: PlayMethod,
    pub live_stream_id: Option<String>,
    pub play_session_id: Option<String>,
    pub repeat_mode: RepeatMode,
    pub playback_order: PlaybackOrder,
    pub now_playing_queue: Option<Vec<QueueItem>>,
    pub playlist_item_id: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum PlaybackRequestType {
    Play,
    SetPlaylistItem,
    RemoveFromPlaylist,
    MovePlaylistItem,
    Queue,
    Unpause,
    Pause,
    Stop,
    Seek,
    Buffer,
    Ready,
    NextItem,
    PreviousItem,
    SetRepeatMode,
    SetShuffleMode,
    Ping,
    IgnoreWait,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PlaybackStartInfo {
    pub can_seek: bool,
    pub item: Option<BaseItemDto>,
    pub item_id: String,
    pub session_id: Option<String>,
    pub media_source_id: Option<String>,
    pub audio_stream_index: Option<i32>,
    pub subtitle_stream_index: Option<i32>,
    pub is_paused: bool,
    pub is_muted: bool,
    pub position_ticks: Option<i64>,
    pub playback_start_time_ticks: Option<i64>,
    pub volume_level: Option<i32>,
    pub brightness: Option<i32>,
    pub aspect_ratio: Option<String>,
    pub play_method: PlayMethod,
    pub live_stream_id: Option<String>,
    pub play_session_id: Option<String>,
    pub repeat_mode: RepeatMode,
    pub playback_order: PlaybackOrder,
    pub now_playing_queue: Option<Vec<QueueItem>>,
    pub playlist_item_id: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PlaybackStopInfo {
    pub item: Option<BaseItemDto>,
    pub item_id: String,
    pub session_id: Option<String>,
    pub media_source_id: Option<String>,
    pub position_ticks: Option<i64>,
    pub live_stream_id: Option<String>,
    pub play_session_id: Option<String>,
    pub failed: bool,
    pub next_media_type: Option<String>,
    pub playlist_item_id: Option<String>,
    pub now_playing_queue: Option<Vec<QueueItem>>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum PlayCommand {
    PlayNow,
    PlayNext,
    PlayLast,
    PlayInstantMix,
    PlayShuffle,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PlayQueueUpdate {
    pub reason: PlayQueueUpdateReason,
    pub last_update: String,
    pub playlist: Vec<SyncPlayQueueItem>,
    pub playing_item_index: i32,
    pub start_position_ticks: i64,
    pub is_playing: bool,
    pub shuffle_mode: GroupShuffleMode,
    pub repeat_mode: GroupRepeatMode,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PlayQueueUpdateGroupUpdate {
    pub group_id: String,
    pub r#type: GroupUpdateType,
    pub data: Option<PlayQueueUpdate>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum PlayQueueUpdateReason {
    NewPlaylist,
    SetCurrentItem,
    RemoveItems,
    MoveItem,
    Queue,
    QueueNext,
    NextItem,
    PreviousItem,
    RepeatMode,
    ShuffleMode,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PlayRequest {
    pub item_ids: Option<Vec<String>>,
    pub start_position_ticks: Option<i64>,
    pub play_command: Option<PlayCommand>,
    pub controlling_user_id: Option<String>,
    pub subtitle_stream_index: Option<i32>,
    pub audio_stream_index: Option<i32>,
    pub media_source_id: Option<String>,
    pub start_index: Option<i32>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PlayRequestDto {
    pub playing_queue: Vec<String>,
    pub playing_item_position: i32,
    pub start_position_ticks: i64,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum PlaystateCommand {
    Stop,
    Pause,
    Unpause,
    NextTrack,
    PreviousTrack,
    Seek,
    Rewind,
    FastForward,
    PlayPause,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PlaystateRequest {
    pub command: PlaystateCommand,
    pub seek_position_ticks: Option<i64>,
    pub controlling_user_id: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PluginInfo {
    pub name: String,
    pub version: String,
    pub configuration_file_name: Option<String>,
    pub description: String,
    pub id: String,
    pub can_uninstall: bool,
    pub has_image: bool,
    pub status: PluginStatus,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum PluginStatus {
    Active,
    Restart,
    Deleted,
    Superceded,
    Malfunctioned,
    NotSupported,
    Disabled,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PluginInstallationCancelledMessage {
    pub data: Option<InstallationInfo>,
    pub message_id: String,
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PluginInstallationCompletedMessage {
    pub data: Option<InstallationInfo>,
    pub message_id: String,
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PluginInstallationFailedMessage {
    pub data: Option<InstallationInfo>,
    pub message_id: String,
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PluginInstallingMessage {
    pub data: Option<InstallationInfo>,
    pub message_id: String,
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PluginUninstalledMessage {
    pub data: Option<PluginInfo>,
    pub message_id: String,
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PreviousItemRequestDto {
    pub playlist_item_id: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ProblemDetails {
    pub r#type: Option<String>,
    pub title: Option<String>,
    pub status: Option<i32>,
    pub detail: Option<String>,
    pub instance: Option<String>,
    #[serde(flatten)]
    pub additional: BTreeMap<String, serde_json::Value>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum ProcessPriorityClass {
    Normal,
    Idle,
    High,
    RealTime,
    BelowNormal,
    AboveNormal,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ProfileCondition {
    pub condition: ProfileConditionType,
    pub property: ProfileConditionValue,
    pub value: Option<String>,
    pub is_required: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum ProfileConditionType {
    Equals,
    NotEquals,
    LessThanEqual,
    GreaterThanEqual,
    EqualsAny,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum ProfileConditionValue {
    AudioChannels,
    AudioBitrate,
    AudioProfile,
    Width,
    Height,
    Has64BitOffsets,
    PacketLength,
    VideoBitDepth,
    VideoBitrate,
    VideoFramerate,
    VideoLevel,
    VideoProfile,
    VideoTimestamp,
    IsAnamorphic,
    RefFrames,
    NumAudioStreams,
    NumVideoStreams,
    IsSecondaryAudio,
    VideoCodecTag,
    IsAvc,
    IsInterlaced,
    AudioSampleRate,
    AudioBitDepth,
    VideoRangeType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum ProgramAudio {
    Mono,
    Stereo,
    Dolby,
    DolbyDigital,
    Thx,
    Atmos,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PublicSystemInfo {
    pub local_address: Option<String>,
    pub server_name: Option<String>,
    pub version: Option<String>,
    pub product_name: Option<String>,
    pub operating_system: Option<String>,
    pub id: Option<String>,
    pub startup_wizard_completed: Option<bool>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct QueryFilters {
    pub genres: Option<Vec<NameGuidPair>>,
    pub tags: Option<Vec<String>>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct QueryFiltersLegacy {
    pub genres: Option<Vec<String>>,
    pub tags: Option<Vec<String>>,
    pub official_ratings: Option<Vec<String>>,
    pub years: Option<Vec<i32>>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct QueueItem {
    pub id: String,
    pub playlist_item_id: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct QueueRequestDto {
    pub item_ids: Vec<String>,
    pub mode: GroupQueueMode,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct QuickConnectDto {
    pub secret: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct QuickConnectResult {
    pub authenticated: bool,
    pub secret: String,
    pub code: String,
    pub device_id: String,
    pub device_name: String,
    pub app_name: String,
    pub app_version: String,
    pub date_added: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum RatingType {
    Score,
    Likes,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ReadyRequestDto {
    pub when: String,
    pub position_ticks: i64,
    pub is_playing: bool,
    pub playlist_item_id: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct RecommendationDto {
    pub items: Option<Vec<BaseItemDto>>,
    pub recommendation_type: RecommendationType,
    pub baseline_item_name: Option<String>,
    pub category_id: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum RecommendationType {
    SimilarToRecentlyPlayed,
    SimilarToLikedItem,
    HasDirectorFromRecentlyPlayed,
    HasActorFromRecentlyPlayed,
    HasLikedDirector,
    HasLikedActor,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum RecordingStatus {
    New,
    InProgress,
    Completed,
    Cancelled,
    ConflictedOk,
    ConflictedNotOk,
    Error,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct RefreshProgressMessage {
    pub data: Option<BTreeMap<String, Option<String>>>,
    pub message_id: String,
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct RemoteImageInfo {
    pub provider_name: Option<String>,
    pub url: Option<String>,
    pub thumbnail_url: Option<String>,
    pub height: Option<i32>,
    pub width: Option<i32>,
    pub community_rating: Option<f64>,
    pub vote_count: Option<i32>,
    pub language: Option<String>,
    pub r#type: ImageType,
    pub rating_type: RatingType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct RemoteImageResult {
    pub images: Option<Vec<RemoteImageInfo>>,
    pub total_record_count: i32,
    pub providers: Option<Vec<String>>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct RemoteLyricInfoDto {
    pub id: String,
    pub provider_name: String,
    pub lyrics: LyricDto,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct RemoteSearchResult {
    pub name: Option<String>,
    pub provider_ids: Option<BTreeMap<String, Option<String>>>,
    pub production_year: Option<i32>,
    pub index_number: Option<i32>,
    pub index_number_end: Option<i32>,
    pub parent_index_number: Option<i32>,
    pub premiere_date: Option<String>,
    pub image_url: Option<String>,
    pub search_provider_name: Option<String>,
    pub overview: Option<String>,
    pub album_artist: Option<RemoteSearchResult>,
    pub artists: Option<Vec<RemoteSearchResult>>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct RemoteSubtitleInfo {
    pub three_letter_i_s_o_language_name: Option<String>,
    pub id: Option<String>,
    pub provider_name: Option<String>,
    pub name: Option<String>,
    pub format: Option<String>,
    pub author: Option<String>,
    pub comment: Option<String>,
    pub date_created: Option<String>,
    pub community_rating: Option<f32>,
    pub frame_rate: Option<f32>,
    pub download_count: Option<i32>,
    pub is_hash_match: Option<bool>,
    pub ai_translated: Option<bool>,
    pub machine_translated: Option<bool>,
    pub forced: Option<bool>,
    pub hearing_impaired: Option<bool>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct RemovedItem {
    pub item_id: String,
    pub series_id: Option<String>,
    pub season: Option<i32>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct RemovedItemQueryResult {
    pub items: Option<Vec<RemovedItem>>,
    pub total_record_count: i32,
    pub start_index: i32,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct RemoveFromPlaylistRequestDto {
    pub playlist_item_ids: Option<Vec<String>>,
    pub clear_playlist: bool,
    pub clear_playing_item: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum RepeatMode {
    RepeatNone,
    RepeatAll,
    RepeatOne,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct RepositoryInfo {
    pub name: Option<String>,
    pub url: Option<String>,
    pub enabled: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct RestartRequiredMessage {
    pub message_id: String,
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ScheduledTaskEndedMessage {
    pub data: Option<TaskResult>,
    pub message_id: String,
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ScheduledTasksInfoMessage {
    pub data: Option<Vec<TaskInfo>>,
    pub message_id: String,
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ScheduledTasksInfoStartMessage {
    pub data: Option<String>,
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ScheduledTasksInfoStopMessage {
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum ScrollDirection {
    Horizontal,
    Vertical,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SearchHint {
    pub item_id: Option<String>,
    pub id: String,
    pub name: String,
    pub matched_term: Option<String>,
    pub index_number: Option<i32>,
    pub production_year: Option<i32>,
    pub parent_index_number: Option<i32>,
    pub primary_image_tag: Option<String>,
    pub thumb_image_tag: Option<String>,
    pub thumb_image_item_id: Option<String>,
    pub backdrop_image_tag: Option<String>,
    pub backdrop_image_item_id: Option<String>,
    pub r#type: Option<BaseItemKind>,
    pub is_folder: Option<bool>,
    pub run_time_ticks: Option<i64>,
    pub media_type: Option<MediaType>,
    pub start_date: Option<String>,
    pub end_date: Option<String>,
    pub series: Option<String>,
    pub status: Option<String>,
    pub album: Option<String>,
    pub album_id: Option<String>,
    pub album_artist: Option<String>,
    pub artists: Option<Vec<String>>,
    pub song_count: Option<i32>,
    pub episode_count: Option<i32>,
    pub channel_id: Option<String>,
    pub channel_name: Option<String>,
    pub primary_image_aspect_ratio: Option<f64>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SearchHintResult {
    pub search_hints: Vec<SearchHint>,
    pub total_record_count: i32,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SeekRequestDto {
    pub position_ticks: i64,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SendCommand {
    pub group_id: String,
    pub playlist_item_id: String,
    pub when: String,
    pub position_ticks: Option<i64>,
    pub command: SendCommandType,
    pub emitted_at: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum SendCommandType {
    Unpause,
    Pause,
    Stop,
    Seek,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SeriesInfo {
    pub name: Option<String>,
    pub original_title: Option<String>,
    pub path: Option<String>,
    pub metadata_language: Option<String>,
    pub metadata_country_code: Option<String>,
    pub provider_ids: Option<BTreeMap<String, Option<String>>>,
    pub year: Option<i32>,
    pub index_number: Option<i32>,
    pub parent_index_number: Option<i32>,
    pub premiere_date: Option<String>,
    pub is_automated: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SeriesInfoRemoteSearchQuery {
    pub search_info: Option<SeriesInfo>,
    pub item_id: String,
    pub search_provider_name: Option<String>,
    pub include_disabled_providers: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum SeriesStatus {
    Continuing,
    Ended,
    Unreleased,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SeriesTimerCancelledMessage {
    pub data: Option<TimerEventInfo>,
    pub message_id: String,
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SeriesTimerCreatedMessage {
    pub data: Option<TimerEventInfo>,
    pub message_id: String,
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SeriesTimerInfoDto {
    pub id: Option<String>,
    pub r#type: Option<String>,
    pub server_id: Option<String>,
    pub external_id: Option<String>,
    pub channel_id: String,
    pub external_channel_id: Option<String>,
    pub channel_name: Option<String>,
    pub channel_primary_image_tag: Option<String>,
    pub program_id: Option<String>,
    pub external_program_id: Option<String>,
    pub name: Option<String>,
    pub overview: Option<String>,
    pub start_date: String,
    pub end_date: String,
    pub service_name: Option<String>,
    pub priority: i32,
    pub pre_padding_seconds: i32,
    pub post_padding_seconds: i32,
    pub is_pre_padding_required: bool,
    pub parent_backdrop_item_id: Option<String>,
    pub parent_backdrop_image_tags: Option<Vec<String>>,
    pub is_post_padding_required: bool,
    pub keep_until: KeepUntil,
    pub record_any_time: bool,
    pub skip_episodes_in_library: bool,
    pub record_any_channel: bool,
    pub keep_up_to: Option<i32>,
    pub record_new_only: bool,
    pub days: Option<Vec<DayOfWeek>>,
    pub day_pattern: Option<DayPattern>,
    pub image_tags: Option<BTreeMap<String, String>>,
    pub parent_thumb_item_id: Option<String>,
    pub parent_thumb_image_tag: Option<String>,
    pub parent_primary_image_item_id: Option<String>,
    pub parent_primary_image_tag: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SeriesTimerInfoDtoQueryResult {
    pub items: Option<Vec<SeriesTimerInfoDto>>,
    pub total_record_count: i32,
    pub start_index: i32,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ServerConfiguration {
    pub log_file_retention_days: i32,
    pub is_startup_wizard_completed: bool,
    pub cache_path: Option<String>,
    pub previous_version: Option<String>,
    pub previous_version_str: Option<String>,
    pub enable_metrics: bool,
    pub enable_normalized_item_by_name_ids: bool,
    pub is_port_authorized: bool,
    pub quick_connect_available: bool,
    pub enable_case_sensitive_item_ids: bool,
    pub disable_live_tv_channel_user_data_name: bool,
    pub metadata_path: Option<String>,
    pub preferred_metadata_language: Option<String>,
    pub metadata_country_code: Option<String>,
    pub sort_replace_characters: Option<Vec<String>>,
    pub sort_remove_characters: Option<Vec<String>>,
    pub sort_remove_words: Option<Vec<String>>,
    pub min_resume_pct: i32,
    pub max_resume_pct: i32,
    pub min_resume_duration_seconds: i32,
    pub min_audiobook_resume: i32,
    pub max_audiobook_resume: i32,
    pub inactive_session_threshold: i32,
    pub library_monitor_delay: i32,
    pub library_update_duration: i32,
    pub image_saving_convention: ImageSavingConvention,
    pub metadata_options: Option<Vec<MetadataOptions>>,
    pub skip_deserialization_for_basic_types: bool,
    pub server_name: String,
    pub u_i_culture: String,
    pub save_metadata_hidden: bool,
    pub content_types: Option<Vec<NameValuePair>>,
    pub remote_client_bitrate_limit: i32,
    pub enable_folder_view: bool,
    pub enable_grouping_into_collections: bool,
    pub display_specials_within_seasons: bool,
    pub codecs_used: Option<Vec<String>>,
    pub plugin_repositories: Option<Vec<RepositoryInfo>>,
    pub enable_external_content_in_suggestions: bool,
    pub image_extraction_timeout_ms: i32,
    pub path_substitutions: Option<Vec<PathSubstitution>>,
    pub enable_slow_response_warning: bool,
    pub slow_response_threshold_ms: i64,
    pub cors_hosts: Option<Vec<String>>,
    pub activity_log_retention_days: Option<i32>,
    pub library_scan_fanout_concurrency: i32,
    pub library_metadata_refresh_concurrency: i32,
    pub remove_old_plugins: bool,
    pub allow_client_log_upload: bool,
    pub dummy_chapter_duration: i32,
    pub chapter_image_resolution: ImageResolution,
    pub parallel_image_encoding_limit: i32,
    pub cast_receiver_applications: Option<Vec<CastReceiverApplication>>,
    pub trickplay_options: TrickplayOptions,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ServerDiscoveryInfo {
    pub address: String,
    pub id: String,
    pub name: String,
    pub endpoint_address: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ServerRestartingMessage {
    pub message_id: String,
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ServerShuttingDownMessage {
    pub message_id: String,
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SessionInfoDto {
    pub play_state: Option<PlayerStateInfo>,
    pub additional_users: Option<Vec<SessionUserInfo>>,
    pub capabilities: Option<ClientCapabilitiesDto>,
    pub remote_end_point: Option<String>,
    pub playable_media_types: Option<Vec<MediaType>>,
    pub id: Option<String>,
    pub user_id: String,
    pub user_name: Option<String>,
    pub client: Option<String>,
    pub last_activity_date: String,
    pub last_playback_check_in: String,
    pub last_paused_date: Option<String>,
    pub device_name: Option<String>,
    pub device_type: Option<String>,
    pub now_playing_item: Option<BaseItemDto>,
    pub now_viewing_item: Option<BaseItemDto>,
    pub device_id: Option<String>,
    pub application_version: Option<String>,
    pub transcoding_info: Option<TranscodingInfo>,
    pub is_active: bool,
    pub supports_media_control: bool,
    pub supports_remote_control: bool,
    pub now_playing_queue: Option<Vec<QueueItem>>,
    pub now_playing_queue_full_items: Option<Vec<BaseItemDto>>,
    pub has_custom_device_name: bool,
    pub playlist_item_id: Option<String>,
    pub server_id: Option<String>,
    pub user_primary_image_tag: Option<String>,
    pub supported_commands: Option<Vec<GeneralCommandType>>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum SessionMessageType {
    ForceKeepAlive,
    GeneralCommand,
    UserDataChanged,
    Sessions,
    Play,
    SyncPlayCommand,
    SyncPlayGroupUpdate,
    Playstate,
    RestartRequired,
    ServerShuttingDown,
    ServerRestarting,
    LibraryChanged,
    UserDeleted,
    UserUpdated,
    SeriesTimerCreated,
    TimerCreated,
    SeriesTimerCancelled,
    TimerCancelled,
    RefreshProgress,
    ScheduledTaskEnded,
    PackageInstallationCancelled,
    PackageInstallationFailed,
    PackageInstallationCompleted,
    PackageInstalling,
    PackageUninstalled,
    ActivityLogEntry,
    ScheduledTasksInfo,
    ActivityLogEntryStart,
    ActivityLogEntryStop,
    SessionsStart,
    SessionsStop,
    ScheduledTasksInfoStart,
    ScheduledTasksInfoStop,
    KeepAlive,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SessionsMessage {
    pub data: Option<Vec<SessionInfoDto>>,
    pub message_id: String,
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SessionsStartMessage {
    pub data: Option<String>,
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SessionsStopMessage {
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SessionUserInfo {
    pub user_id: String,
    pub user_name: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SetChannelMappingDto {
    pub provider_id: String,
    pub tuner_channel_id: String,
    pub provider_channel_id: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SetPlaylistItemRequestDto {
    pub playlist_item_id: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SetRepeatModeRequestDto {
    pub mode: GroupRepeatMode,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SetShuffleModeRequestDto {
    pub mode: GroupShuffleMode,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SongInfo {
    pub name: Option<String>,
    pub original_title: Option<String>,
    pub path: Option<String>,
    pub metadata_language: Option<String>,
    pub metadata_country_code: Option<String>,
    pub provider_ids: Option<BTreeMap<String, Option<String>>>,
    pub year: Option<i32>,
    pub index_number: Option<i32>,
    pub parent_index_number: Option<i32>,
    pub premiere_date: Option<String>,
    pub is_automated: bool,
    pub album_artists: Option<Vec<String>>,
    pub album: Option<String>,
    pub artists: Option<Vec<String>>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum SortOrder {
    Ascending,
    Descending,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SpecialViewOptionDto {
    pub name: Option<String>,
    pub id: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct StartupConfigurationDto {
    pub u_i_culture: Option<String>,
    pub metadata_country_code: Option<String>,
    pub preferred_metadata_language: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct StartupRemoteAccessDto {
    pub enable_remote_access: bool,
    pub enable_automatic_port_mapping: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct StartupUserDto {
    pub name: Option<String>,
    pub password: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum Status {
    Completed,
    Watching,
    Both,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct StringGroupUpdate {
    pub group_id: String,
    pub r#type: GroupUpdateType,
    pub data: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum SubtitleDeliveryMethod {
    Encode,
    Embed,
    External,
    Hls,
    Drop,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SubtitleOptions {
    pub skip_if_embedded_subtitles_present: bool,
    pub skip_if_audio_track_matches: bool,
    pub download_languages: Option<Vec<String>>,
    pub download_movie_subtitles: bool,
    pub download_episode_subtitles: bool,
    pub open_subtitles_username: Option<String>,
    pub open_subtitles_password_hash: Option<String>,
    pub is_open_subtitle_vip_account: bool,
    pub require_perfect_match: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum SubtitlePlaybackMode {
    Default,
    Always,
    OnlyForced,
    None,
    Smart,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SubtitleProfile {
    pub format: Option<String>,
    pub method: SubtitleDeliveryMethod,
    pub didl_mode: Option<String>,
    pub language: Option<String>,
    pub container: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum SyncAction {
    UpdateProvider,
    UpdateJellyfin,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SyncPlayCommandMessage {
    pub data: Option<SendCommand>,
    pub message_id: String,
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SyncPlayGroupUpdateCommandMessage {
    pub data: Option<GroupUpdate>,
    pub message_id: String,
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SyncPlayQueueItem {
    pub item_id: String,
    pub playlist_item_id: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum SyncPlayUserAccessType {
    CreateAndJoinGroups,
    JoinGroups,
    None,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SyncStats {
    pub updated_folders: i32,
    pub removed_folders: i32,
    pub updated_box_sets: i32,
    pub removed_box_sets: i32,
    pub updated_playlists: i32,
    pub removed_playlists: i32,
    pub updated_tv_shows: i32,
    pub removed_tv_shows: i32,
    pub updated_seasons: i32,
    pub removed_seasons: i32,
    pub updated_videos: i32,
    pub removed_videos: i32,
    pub updated_collection_folders: i32,
    pub updated_user_data: i32,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SystemInfo {
    pub local_address: Option<String>,
    pub server_name: Option<String>,
    pub version: Option<String>,
    pub product_name: Option<String>,
    pub operating_system: Option<String>,
    pub id: Option<String>,
    pub startup_wizard_completed: Option<bool>,
    pub operating_system_display_name: Option<String>,
    pub package_name: Option<String>,
    pub has_pending_restart: bool,
    pub is_shutting_down: bool,
    pub supports_library_monitor: bool,
    pub web_socket_port_number: i32,
    pub completed_installations: Option<Vec<InstallationInfo>>,
    pub can_self_restart: bool,
    pub can_launch_web_browser: bool,
    pub program_data_path: Option<String>,
    pub web_path: Option<String>,
    pub items_by_name_path: Option<String>,
    pub cache_path: Option<String>,
    pub log_path: Option<String>,
    pub internal_metadata_path: Option<String>,
    pub transcoding_temp_path: Option<String>,
    pub cast_receiver_applications: Option<Vec<CastReceiverApplication>>,
    pub has_update_available: bool,
    pub encoder_location: String,
    pub system_architecture: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TaskCompletionStatus {
    pub r#type: TaskCompletionStatusEnum,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum TaskCompletionStatusEnum {
    Completed,
    Failed,
    Cancelled,
    Aborted,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TaskInfo {
    pub name: Option<String>,
    pub state: TaskState,
    pub current_progress_percentage: Option<f64>,
    pub id: Option<String>,
    pub last_execution_result: Option<TaskResult>,
    pub triggers: Option<Vec<TaskTriggerInfo>>,
    pub description: Option<String>,
    pub category: Option<String>,
    pub is_hidden: bool,
    pub key: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TaskResult {
    pub start_time_utc: String,
    pub end_time_utc: String,
    pub status: TaskCompletionStatus,
    pub name: Option<String>,
    pub key: Option<String>,
    pub id: Option<String>,
    pub error_message: Option<String>,
    pub long_error_message: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum TaskState {
    Idle,
    Cancelling,
    Running,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TaskTriggerInfo {
    pub r#type: Option<String>,
    pub time_of_day_ticks: Option<i64>,
    pub interval_ticks: Option<i64>,
    pub day_of_week: Option<DayOfWeek>,
    pub max_runtime_ticks: Option<i64>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ThemeMediaResult {
    pub items: Option<Vec<BaseItemDto>>,
    pub total_record_count: i32,
    pub start_index: i32,
    pub owner_id: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TimerCancelledMessage {
    pub data: Option<TimerEventInfo>,
    pub message_id: String,
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TimerCreatedMessage {
    pub data: Option<TimerEventInfo>,
    pub message_id: String,
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TimerEventInfo {
    pub id: String,
    pub program_id: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TimerInfoDto {
    pub id: Option<String>,
    pub r#type: Option<String>,
    pub server_id: Option<String>,
    pub external_id: Option<String>,
    pub channel_id: String,
    pub external_channel_id: Option<String>,
    pub channel_name: Option<String>,
    pub channel_primary_image_tag: Option<String>,
    pub program_id: Option<String>,
    pub external_program_id: Option<String>,
    pub name: Option<String>,
    pub overview: Option<String>,
    pub start_date: String,
    pub end_date: String,
    pub service_name: Option<String>,
    pub priority: i32,
    pub pre_padding_seconds: i32,
    pub post_padding_seconds: i32,
    pub is_pre_padding_required: bool,
    pub parent_backdrop_item_id: Option<String>,
    pub parent_backdrop_image_tags: Option<Vec<String>>,
    pub is_post_padding_required: bool,
    pub keep_until: KeepUntil,
    pub status: RecordingStatus,
    pub series_timer_id: Option<String>,
    pub external_series_timer_id: Option<String>,
    pub run_time_ticks: Option<i64>,
    pub program_info: Option<BaseItemDto>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TimerInfoDtoQueryResult {
    pub items: Option<Vec<TimerInfoDto>>,
    pub total_record_count: i32,
    pub start_index: i32,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TonemappingAlgorithm {
    pub r#type: TonemappingAlgorithmEnum,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum TonemappingAlgorithmEnum {
    None,
    Clip,
    Linear,
    Gamma,
    Reinhard,
    Hable,
    Mobius,
    Bt2390,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TonemappingMode {
    pub r#type: TonemappingModeEnum,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum TonemappingModeEnum {
    Auto,
    Max,
    Rgb,
    Lum,
    Itp,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TonemappingRange {
    pub r#type: TonemappingRangeEnum,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum TonemappingRangeEnum {
    Auto,
    Tv,
    Pc,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TrailerInfo {
    pub name: Option<String>,
    pub original_title: Option<String>,
    pub path: Option<String>,
    pub metadata_language: Option<String>,
    pub metadata_country_code: Option<String>,
    pub provider_ids: Option<BTreeMap<String, Option<String>>>,
    pub year: Option<i32>,
    pub index_number: Option<i32>,
    pub parent_index_number: Option<i32>,
    pub premiere_date: Option<String>,
    pub is_automated: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TrailerInfoRemoteSearchQuery {
    pub search_info: Option<RemoteSearchResult>,
    pub item_id: String,
    pub search_provider_name: Option<String>,
    pub include_disabled_providers: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TranscodeReason {
    pub r#type: TranscodeReasonEnum,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum TranscodeReasonEnum {
    ContainerNotSupported,
    VideoCodecNotSupported,
    AudioCodecNotSupported,
    SubtitleCodecNotSupported,
    AudioIsExternal,
    SecondaryAudioNotSupported,
    VideoProfileNotSupported,
    VideoLevelNotSupported,
    VideoResolutionNotSupported,
    VideoBitDepthNotSupported,
    VideoFramerateNotSupported,
    RefFramesNotSupported,
    AnamorphicVideoNotSupported,
    InterlacedVideoNotSupported,
    AudioChannelsNotSupported,
    AudioProfileNotSupported,
    AudioSampleRateNotSupported,
    AudioBitDepthNotSupported,
    ContainerBitrateExceedsLimit,
    VideoBitrateNotSupported,
    AudioBitrateNotSupported,
    UnknownVideoStreamInfo,
    UnknownAudioStreamInfo,
    DirectPlayError,
    VideoRangeTypeNotSupported,
    VideoCodecTagNotSupported,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TranscodeSeekInfo {
    pub r#type: TranscodeSeekInfoEnum,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum TranscodeSeekInfoEnum {
    Auto,
    Bytes,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TranscodingInfo {
    pub audio_codec: Option<String>,
    pub video_codec: Option<String>,
    pub container: Option<String>,
    pub is_video_direct: bool,
    pub is_audio_direct: bool,
    pub bitrate: Option<i32>,
    pub framerate: Option<f32>,
    pub completion_percentage: Option<f64>,
    pub width: Option<i32>,
    pub height: Option<i32>,
    pub audio_channels: Option<i32>,
    pub hardware_acceleration_type: Option<HardwareAccelerationType>,
    pub transcoding_reasons: Option<Vec<TranscodeReason>>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TranscodingProfile {
    pub container: Option<String>,
    pub r#type: DlnaProfileType,
    pub video_codec: Option<String>,
    pub audio_codec: Option<String>,
    pub protocol: MediaStreamProtocol,
    pub estimate_content_length: bool,
    pub enable_mpegts_m2_ts_mode: bool,
    pub transcoding_seek_info: TranscodeSeekInfo,
    pub copy_timestamps: bool,
    pub context: EncodingContext,
    pub enable_subtitles_in_manifest: bool,
    pub max_audio_channels: Option<String>,
    pub min_segments: i32,
    pub segment_length: i32,
    pub break_on_non_key_frames: bool,
    pub conditions: Option<Vec<ProfileCondition>>,
    pub enable_audio_vbr_encoding: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TransportStreamTimestamp {
    pub r#type: TransportStreamTimestampEnum,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum TransportStreamTimestampEnum {
    None,
    Zero,
    Valid,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TrickplayInfo {
    pub width: i32,
    pub height: i32,
    pub tile_width: i32,
    pub tile_height: i32,
    pub thumbnail_count: i32,
    pub interval: i32,
    pub bandwidth: i32,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TrickplayOptions {
    pub enable_hw_acceleration: bool,
    pub enable_hw_encoding: bool,
    pub enable_key_frame_only_extraction: bool,
    pub scan_behavior: TrickplayScanBehavior,
    pub process_priority: ProcessPriorityClass,
    pub interval: i32,
    pub width_resolutions: Option<Vec<i32>>,
    pub tile_width: i32,
    pub tile_height: i32,
    pub qscale: i32,
    pub jpeg_quality: i32,
    pub process_threads: i32,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum TrickplayScanBehavior {
    Blocking,
    NonBlocking,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TunerChannelMapping {
    pub name: Option<String>,
    pub provider_channel_name: Option<String>,
    pub provider_channel_id: Option<String>,
    pub id: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TunerHostInfo {
    pub id: Option<String>,
    pub url: Option<String>,
    pub r#type: Option<String>,
    pub device_id: Option<String>,
    pub friendly_name: Option<String>,
    pub import_favorites_only: bool,
    pub allow_hw_transcoding: bool,
    pub allow_fmp4_transcoding_container: bool,
    pub allow_stream_sharing: bool,
    pub fallback_max_streaming_bitrate: i32,
    pub enable_stream_looping: bool,
    pub source: Option<String>,
    pub tuner_count: i32,
    pub user_agent: Option<String>,
    pub ignore_dts: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TypeOptions {
    pub r#type: Option<String>,
    pub metadata_fetchers: Option<Vec<LibraryOptionInfoDto>>,
    pub metadata_fetcher_order: Option<Vec<LibraryOptionInfoDto>>,
    pub image_fetchers: Option<Vec<LibraryOptionInfoDto>>,
    pub image_fetcher_order: Option<Vec<LibraryOptionInfoDto>>,
    pub image_options: Option<Vec<ImageOption>>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct UnratedItem {
    pub r#type: UnratedItemEnum,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum UnratedItemEnum {
    Movie,
    Trailer,
    Series,
    Music,
    Book,
    LiveTvChannel,
    LiveTvProgram,
    ChannelContent,
    Other,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct UpdateLibraryOptionsDto {
    pub id: String,
    pub library_options: Option<LibraryOptions>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct UpdateMediaPathRequestDto {
    pub name: String,
    pub path_info: MediaPathInfo,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct UpdatePlaylistDto {
    pub name: Option<String>,
    pub ids: Option<Vec<String>>,
    pub users: Option<Vec<PlaylistUserPermissions>>,
    pub is_public: Option<bool>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct UpdatePlaylistUserDto {
    pub can_edit: Option<bool>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct UpdateUserItemDataDto {
    pub rating: Option<f64>,
    pub played_percentage: Option<f64>,
    pub unplayed_item_count: Option<i32>,
    pub playback_position_ticks: i64,
    pub play_count: i32,
    pub is_favorite: bool,
    pub likes: Option<bool>,
    pub last_played_date: Option<String>,
    pub played: bool,
    pub key: String,
    pub item_id: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct UpdateUserPassword {
    pub current_password: Option<String>,
    pub current_pw: Option<String>,
    pub new_pw: Option<String>,
    pub reset_password: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct UploadSubtitleDto {
    pub language: String,
    pub format: String,
    pub is_forced: bool,
    pub is_hearing_impaired: bool,
    pub data: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct UserConfiguration {
    pub audio_language_preference: Option<String>,
    pub play_default_audio_track: bool,
    pub subtitle_language_preference: Option<String>,
    pub display_missing_episodes: bool,
    pub grouped_folders: Vec<String>,
    pub subtitle_mode: SubtitlePlaybackMode,
    pub display_collections_view: bool,
    pub enable_local_password: bool,
    pub ordered_views: Vec<String>,
    pub latest_items_excludes: Vec<String>,
    pub my_media_excludes: Vec<String>,
    pub hide_played_in_latest: bool,
    pub remember_audio_selections: bool,
    pub remember_subtitle_selections: bool,
    pub enable_next_episode_auto_play: bool,
    pub cast_receiver_id: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct UserDataChangedMessage {
    pub data: Option<UserDataChangeInfo>,
    pub message_id: String,
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct UserDataChangeInfo {
    pub user_id: String,
    pub user_data_list: Vec<UserItemDataDto>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct UserDeletedMessage {
    pub data: String,
    pub message_id: String,
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct UserDto {
    pub name: Option<String>,
    pub server_id: Option<String>,
    pub server_name: Option<String>,
    pub id: String,
    pub primary_image_tag: Option<String>,
    pub has_password: bool,
    pub has_configured_password: bool,
    pub has_configured_easy_password: bool,
    pub enable_auto_login: Option<bool>,
    pub last_login_date: Option<String>,
    pub last_activity_date: Option<String>,
    pub configuration: Option<UserConfiguration>,
    pub policy: Option<UserPolicy>,
    pub primary_image_aspect_ratio: Option<f64>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct UserItemDataDto {
    pub rating: Option<f64>,
    pub played_percentage: Option<f64>,
    pub unplayed_item_count: i32,
    pub playback_position_ticks: i64,
    pub play_count: i32,
    pub is_favorite: bool,
    pub likes: Option<bool>,
    pub last_played_date: Option<String>,
    pub played: bool,
    pub key: String,
    pub item_id: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct UserPolicy {
    pub is_administrator: bool,
    pub is_hidden: bool,
    pub enable_collection_management: bool,
    pub enable_subtitle_management: bool,
    pub enable_lyric_management: bool,
    pub is_disabled: bool,
    pub max_parental_rating: Option<i32>,
    pub blocked_tags: Option<Vec<String>>,
    pub allowed_tags: Option<Vec<String>>,
    pub enable_user_preference_access: bool,
    pub access_schedules: Option<Vec<AccessSchedule>>,
    pub block_unrated_items: Option<Vec<UnratedItem>>,
    pub enable_remote_control_of_other_users: bool,
    pub enable_shared_device_control: bool,
    pub enable_remote_access: bool,
    pub enable_live_tv_management: bool,
    pub enable_live_tv_access: bool,
    pub enable_media_playback: bool,
    pub enable_audio_playback_transcoding: bool,
    pub enable_video_playback_transcoding: bool,
    pub enable_playback_remuxing: bool,
    pub force_remote_source_transcoding: bool,
    pub enable_content_deletion: bool,
    pub enable_content_deletion_from_folders: Option<Vec<String>>,
    pub enable_content_downloading: bool,
    pub enable_sync_transcoding: bool,
    pub enable_media_conversion: bool,
    pub enabled_devices: Option<Vec<String>>,
    pub enable_all_devices: bool,
    pub enabled_channels: Option<Vec<String>>,
    pub enable_all_channels: bool,
    pub enabled_folders: Option<Vec<String>>,
    pub enable_all_folders: bool,
    pub invalid_login_attempt_count: i32,
    pub login_attempts_before_lockout: i32,
    pub max_active_sessions: i32,
    pub enable_public_sharing: bool,
    pub blocked_media_folders: Option<Vec<String>>,
    pub blocked_channels: Option<Vec<String>>,
    pub remote_client_bitrate_limit: i32,
    pub authentication_provider_id: String,
    pub password_reset_provider_id: String,
    pub sync_play_access: SyncPlayUserAccessType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct UserUpdatedMessage {
    pub data: Option<UserDto>,
    pub message_id: String,
    pub message_type: SessionMessageType,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct UtcTimeResponse {
    pub request_reception_time: String,
    pub response_transmission_time: String,
}