diff --git a/connect/src/spirc.rs b/connect/src/spirc.rs
index 37576a9e..299bae02 100644
--- a/connect/src/spirc.rs
+++ b/connect/src/spirc.rs
@@ -13,14 +13,14 @@ use context::StationContext;
 use librespot_core::config::ConnectConfig;
 use librespot_core::mercury::MercuryError;
 use librespot_core::session::Session;
-use librespot_core::spotify_id::SpotifyId;
+use librespot_core::spotify_id::{SpotifyAudioType, SpotifyId, SpotifyIdError};
 use librespot_core::util::SeqGenerator;
 use librespot_core::version;
 use librespot_core::volume::Volume;
 use playback::mixer::Mixer;
 use playback::player::Player;
 use protocol;
-use protocol::spirc::{DeviceState, Frame, MessageType, PlayStatus, State};
+use protocol::spirc::{DeviceState, Frame, MessageType, PlayStatus, State, TrackRef};
 
 pub struct SpircTask {
     player: Player,
@@ -168,6 +168,7 @@ fn initial_device_state(config: ConnectConfig) -> DeviceState {
                     let repeated = msg.mut_stringValue();
                     repeated.push(::std::convert::Into::into("audio/local"));
                     repeated.push(::std::convert::Into::into("audio/track"));
+                    repeated.push(::std::convert::Into::into("audio/episode"));
                     repeated.push(::std::convert::Into::into("local"));
                     repeated.push(::std::convert::Into::into("track"))
                 };
@@ -796,6 +797,7 @@ impl SpircTask {
     }
 
     fn update_tracks(&mut self, frame: &protocol::spirc::Frame) {
+        debug!("State: {:?}", frame.get_state());
         let index = frame.get_state().get_playing_track_index();
         let context_uri = frame.get_state().get_context_uri().to_owned();
         let tracks = frame.get_state().get_track();
@@ -811,24 +813,50 @@ impl SpircTask {
         self.state.set_shuffle(frame.get_state().get_shuffle());
     }
 
+    // should this be a method of SpotifyId directly?
+    fn get_spotify_id_for_track(&self, track_ref: &TrackRef) -> Result<SpotifyId, SpotifyIdError> {
+        SpotifyId::from_raw(track_ref.get_gid()).or_else(|_| {
+            let uri = track_ref.get_uri();
+            debug!("Malformed or no gid, attempting to parse URI <{}>", uri);
+            SpotifyId::from_uri(uri)
+        })
+    }
+
     fn load_track(&mut self, play: bool) {
+        let context_uri = self.state.get_context_uri().to_owned();
+        let mut index = self.state.get_playing_track_index();
+        let start_index = index;
+        let tracks_len = self.state.get_track().len() as u32;
+        debug!(
+            "Loading context: <{}> index: [{}] of {}",
+            context_uri, index, tracks_len
+        );
+        // Cycle through all tracks, break if we don't find any playable tracks
+        // TODO: This will panic if no playable tracks are found!
+        // tracks in each frame either have a gid or uri (that may or may not be a valid track)
+        // E.g - context based frames sometimes contain tracks with <spotify:meta:page:>
         let track = {
-            let mut index = self.state.get_playing_track_index();
-            // Check for malformed gid
-            let tracks_len = self.state.get_track().len() as u32;
-            let mut track_ref = &self.state.get_track()[index as usize];
-            while track_ref.get_gid().len() != 16 {
+            let mut track_ref = self.state.get_track()[index as usize].clone();
+            let mut track_id = self.get_spotify_id_for_track(&track_ref);
+            while track_id.is_err() || track_id.unwrap().audio_type == SpotifyAudioType::NonPlayable {
                 warn!(
-                    "Skipping track {:?} at position [{}] of {}",
+                    "Skipping track <{:?}> at position [{}] of {}",
                     track_ref.get_uri(),
                     index,
                     tracks_len
                 );
                 index = if index + 1 < tracks_len { index + 1 } else { 0 };
-                track_ref = &self.state.get_track()[index as usize];
+                self.state.set_playing_track_index(index);
+                if index == start_index {
+                    warn!("No playable track found in state: {:?}", self.state);
+                    break;
+                }
+                track_ref = self.state.get_track()[index as usize].clone();
+                track_id = self.get_spotify_id_for_track(&track_ref);
             }
-            SpotifyId::from_raw(track_ref.get_gid()).unwrap()
-        };
+            track_id
+        }
+        .expect("Invalid SpotifyId");
 
         let position = self.state.get_position_ms();
         let end_of_track = self.player.load(track, play, position);
diff --git a/contrib/Dockerfile b/contrib/Dockerfile
index 0fcdafff..74b83d31 100644
--- a/contrib/Dockerfile
+++ b/contrib/Dockerfile
@@ -21,7 +21,7 @@ RUN dpkg --add-architecture armel
 RUN dpkg --add-architecture mipsel
 RUN apt-get update
 
-RUN apt-get install -y curl git build-essential crossbuild-essential-arm64 crossbuild-essential-armel crossbuild-essential-armhf crossbuild-essential-mipsel
+RUN apt-get install -y curl git build-essential crossbuild-essential-arm64 crossbuild-essential-armel crossbuild-essential-armhf crossbuild-essential-mipsel pkg-config
 RUN apt-get install -y libasound2-dev libasound2-dev:arm64 libasound2-dev:armel libasound2-dev:armhf libasound2-dev:mipsel
 
 RUN curl https://sh.rustup.rs -sSf | sh -s -- -y
@@ -43,6 +43,11 @@ RUN mkdir /build && \
 
 ENV CARGO_TARGET_DIR /build
 ENV CARGO_HOME /build/cache
+ENV PKG_CONFIG_ALLOW_CROSS=1
+ENV PKG_CONFIG_PATH_aarch64-unknown-linux-gnu=/usr/lib/aarch64-linux-gnu/pkgconfig/
+ENV PKG_CONFIG_PATH_arm-unknown-linux-gnueabihf=/usr/lib/arm-linux-gnueabihf/pkgconfig/
+ENV PKG_CONFIG_PATH_arm-unknown-linux-gnueabi=/usr/lib/arm-linux-gnueabi/pkgconfig/
+ENV PKG_CONFIG_PATH_mipsel-unknown-linux-gnu=/usr/lib/mipsel-linux-gnu/pkgconfig/
 
 ADD . /src
 WORKDIR /src
diff --git a/core/src/spotify_id.rs b/core/src/spotify_id.rs
index 79414a18..e6f0cdd8 100644
--- a/core/src/spotify_id.rs
+++ b/core/src/spotify_id.rs
@@ -1,8 +1,18 @@
 use std;
 use std::fmt;
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub struct SpotifyId(u128);
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum SpotifyAudioType {
+    Track,
+    Podcast,
+    NonPlayable,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct SpotifyId {
+    pub id: u128,
+    pub audio_type: SpotifyAudioType,
+}
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub struct SpotifyIdError;
@@ -11,6 +21,13 @@ const BASE62_DIGITS: &'static [u8] = b"0123456789abcdefghijklmnopqrstuvwxyzABCDE
 const BASE16_DIGITS: &'static [u8] = b"0123456789abcdef";
 
 impl SpotifyId {
+    fn as_track(n: u128) -> SpotifyId {
+        SpotifyId {
+            id: n.to_owned(),
+            audio_type: SpotifyAudioType::Track,
+        }
+    }
+
     pub fn from_base16(id: &str) -> Result<SpotifyId, SpotifyIdError> {
         let data = id.as_bytes();
 
@@ -24,7 +41,7 @@ impl SpotifyId {
             n = n + d;
         }
 
-        Ok(SpotifyId(n))
+        Ok(SpotifyId::as_track(n))
     }
 
     pub fn from_base62(id: &str) -> Result<SpotifyId, SpotifyIdError> {
@@ -39,8 +56,7 @@ impl SpotifyId {
             n = n * 62;
             n = n + d;
         }
-
-        Ok(SpotifyId(n))
+        Ok(SpotifyId::as_track(n))
     }
 
     pub fn from_raw(data: &[u8]) -> Result<SpotifyId, SpotifyIdError> {
@@ -51,15 +67,32 @@ impl SpotifyId {
         let mut arr: [u8; 16] = Default::default();
         arr.copy_from_slice(&data[0..16]);
 
-        Ok(SpotifyId(u128::from_be_bytes(arr)))
+        Ok(SpotifyId::as_track(u128::from_be_bytes(arr)))
+    }
+
+    pub fn from_uri(uri: &str) -> Result<SpotifyId, SpotifyIdError> {
+        let parts = uri.split(":").collect::<Vec<&str>>();
+        let gid = parts.last().unwrap();
+        if uri.contains(":episode:") {
+            let mut spotify_id = SpotifyId::from_base62(gid).unwrap();
+            let _ = std::mem::replace(&mut spotify_id.audio_type, SpotifyAudioType::Podcast);
+            Ok(spotify_id)
+        } else if uri.contains(":track:") {
+            SpotifyId::from_base62(gid)
+        } else {
+            // show/playlist/artist/album/??
+            let mut spotify_id = SpotifyId::from_base62(gid).unwrap();
+            let _ = std::mem::replace(&mut spotify_id.audio_type, SpotifyAudioType::NonPlayable);
+            Ok(spotify_id)
+        }
     }
 
     pub fn to_base16(&self) -> String {
-        format!("{:032x}", self.0)
+        format!("{:032x}", self.id)
     }
 
     pub fn to_base62(&self) -> String {
-        let &SpotifyId(mut n) = self;
+        let &SpotifyId { id: mut n, .. } = self;
 
         let mut data = [0u8; 22];
         for i in 0..22 {
@@ -71,7 +104,7 @@ impl SpotifyId {
     }
 
     pub fn to_raw(&self) -> [u8; 16] {
-        self.0.to_be_bytes()
+        self.id.to_be_bytes()
     }
 }
 
diff --git a/metadata/src/lib.rs b/metadata/src/lib.rs
index 60ca2738..344a3a54 100644
--- a/metadata/src/lib.rs
+++ b/metadata/src/lib.rs
@@ -8,12 +8,13 @@ extern crate librespot_protocol as protocol;
 
 pub mod cover;
 
+use futures::future;
 use futures::Future;
 use linear_map::LinearMap;
 
 use librespot_core::mercury::MercuryError;
 use librespot_core::session::Session;
-use librespot_core::spotify_id::{FileId, SpotifyId};
+use librespot_core::spotify_id::{FileId, SpotifyAudioType, SpotifyId};
 
 pub use protocol::metadata::AudioFile_Format as FileFormat;
 
@@ -52,13 +53,81 @@ where
         && (!has_allowed || countrylist_contains(allowed.as_str(), country))
 }
 
+// A wrapper with fields the player needs
+#[derive(Debug, Clone)]
+pub struct AudioItem {
+    pub id: SpotifyId,
+    pub uri: String,
+    pub files: LinearMap<FileFormat, FileId>,
+    pub name: String,
+    pub available: bool,
+    pub alternatives: Option<Vec<SpotifyId>>,
+}
+
+impl AudioItem {
+    pub fn get_audio_item(
+        session: &Session,
+        id: SpotifyId,
+    ) -> Box<dyn Future<Item = AudioItem, Error = MercuryError>> {
+        match id.audio_type {
+            SpotifyAudioType::Track => Track::get_audio_item(session, id),
+            SpotifyAudioType::Podcast => Episode::get_audio_item(session, id),
+            SpotifyAudioType::NonPlayable => {
+                Box::new(future::err::<AudioItem, MercuryError>(MercuryError))
+            }
+        }
+    }
+}
+
+trait AudioFiles {
+    fn get_audio_item(
+        session: &Session,
+        id: SpotifyId,
+    ) -> Box<dyn Future<Item = AudioItem, Error = MercuryError>>;
+}
+
+impl AudioFiles for Track {
+    fn get_audio_item(
+        session: &Session,
+        id: SpotifyId,
+    ) -> Box<dyn Future<Item = AudioItem, Error = MercuryError>> {
+        Box::new(Self::get(session, id).and_then(move |item| {
+            Ok(AudioItem {
+                id: id,
+                uri: format!("spotify:track:{}", id.to_base62()),
+                files: item.files,
+                name: item.name,
+                available: item.available,
+                alternatives: Some(item.alternatives),
+            })
+        }))
+    }
+}
+
+impl AudioFiles for Episode {
+    fn get_audio_item(
+        session: &Session,
+        id: SpotifyId,
+    ) -> Box<dyn Future<Item = AudioItem, Error = MercuryError>> {
+        Box::new(Self::get(session, id).and_then(move |item| {
+            Ok(AudioItem {
+                id: id,
+                uri: format!("spotify:episode:{}", id.to_base62()),
+                files: item.files,
+                name: item.name,
+                available: item.available,
+                alternatives: None,
+            })
+        }))
+    }
+}
 pub trait Metadata: Send + Sized + 'static {
     type Message: protobuf::Message;
 
     fn base_url() -> &'static str;
     fn parse(msg: &Self::Message, session: &Session) -> Self;
 
-    fn get(session: &Session, id: SpotifyId) -> Box<Future<Item = Self, Error = MercuryError>> {
+    fn get(session: &Session, id: SpotifyId) -> Box<dyn Future<Item = Self, Error = MercuryError>> {
         let uri = format!("{}/{}", Self::base_url(), id.to_base16());
         let request = session.mercury().get(uri);
 
@@ -93,6 +162,29 @@ pub struct Album {
     pub covers: Vec<FileId>,
 }
 
+#[derive(Debug, Clone)]
+pub struct Episode {
+    pub id: SpotifyId,
+    pub name: String,
+    pub external_url: String,
+    pub duration: i32,
+    pub language: String,
+    pub show: SpotifyId,
+    pub files: LinearMap<FileFormat, FileId>,
+    pub covers: Vec<FileId>,
+    pub available: bool,
+    pub explicit: bool,
+}
+
+#[derive(Debug, Clone)]
+pub struct Show {
+    pub id: SpotifyId,
+    pub name: String,
+    pub publisher: String,
+    pub episodes: Vec<SpotifyId>,
+    pub covers: Vec<FileId>,
+}
+
 #[derive(Debug, Clone)]
 pub struct Artist {
     pub id: SpotifyId,
@@ -222,6 +314,92 @@ impl Metadata for Artist {
     }
 }
 
+// Podcast
+impl Metadata for Episode {
+    type Message = protocol::metadata::Episode;
+
+    fn base_url() -> &'static str {
+        "hm://metadata/3/episode"
+    }
+
+    fn parse(msg: &Self::Message, session: &Session) -> Self {
+        let country = session.country();
+
+        let files = msg
+            .get_file()
+            .iter()
+            .filter(|file| file.has_file_id())
+            .map(|file| {
+                let mut dst = [0u8; 20];
+                dst.clone_from_slice(file.get_file_id());
+                (file.get_format(), FileId(dst))
+            })
+            .collect();
+
+        let covers = msg
+            .get_covers()
+            .get_image()
+            .iter()
+            .filter(|image| image.has_file_id())
+            .map(|image| {
+                let mut dst = [0u8; 20];
+                dst.clone_from_slice(image.get_file_id());
+                FileId(dst)
+            })
+            .collect::<Vec<_>>();
+
+        Episode {
+            id: SpotifyId::from_raw(msg.get_gid()).unwrap(),
+            name: msg.get_name().to_owned(),
+            external_url: msg.get_external_url().to_owned(),
+            duration: msg.get_duration().to_owned(),
+            language: msg.get_language().to_owned(),
+            show: SpotifyId::from_raw(msg.get_show().get_gid()).unwrap(),
+            covers: covers,
+            files: files,
+            available: parse_restrictions(msg.get_restriction(), &country, "premium"),
+            explicit: msg.get_explicit().to_owned(),
+        }
+    }
+}
+
+impl Metadata for Show {
+    type Message = protocol::metadata::Show;
+
+    fn base_url() -> &'static str {
+        "hm://metadata/3/show"
+    }
+
+    fn parse(msg: &Self::Message, _: &Session) -> Self {
+        let episodes = msg
+            .get_episode()
+            .iter()
+            .filter(|episode| episode.has_gid())
+            .map(|episode| SpotifyId::from_raw(episode.get_gid()).unwrap())
+            .collect::<Vec<_>>();
+
+        let covers = msg
+            .get_covers()
+            .get_image()
+            .iter()
+            .filter(|image| image.has_file_id())
+            .map(|image| {
+                let mut dst = [0u8; 20];
+                dst.clone_from_slice(image.get_file_id());
+                FileId(dst)
+            })
+            .collect::<Vec<_>>();
+
+        Show {
+            id: SpotifyId::from_raw(msg.get_gid()).unwrap(),
+            name: msg.get_name().to_owned(),
+            publisher: msg.get_publisher().to_owned(),
+            episodes: episodes,
+            covers: covers,
+        }
+    }
+}
+
 struct StrChunks<'s>(&'s str, usize);
 
 trait StrChunksExt {
diff --git a/playback/src/player.rs b/playback/src/player.rs
index aaa5ec0f..23121785 100644
--- a/playback/src/player.rs
+++ b/playback/src/player.rs
@@ -17,11 +17,9 @@ use librespot_core::spotify_id::SpotifyId;
 use audio::{AudioDecrypt, AudioFile, StreamLoaderController};
 use audio::{VorbisDecoder, VorbisPacket};
 use audio_backend::Sink;
-use metadata::{FileFormat, Metadata, Track};
+use metadata::{AudioItem, FileFormat};
 use mixer::AudioFilter;
 
-
-
 pub struct Player {
     commands: Option<std::sync::mpsc::Sender<PlayerCommand>>,
     thread_handle: Option<thread::JoinHandle<()>>,
@@ -547,17 +545,19 @@ impl PlayerInternal {
         let _ = self.event_sender.unbounded_send(event.clone());
     }
 
-    fn find_available_alternative<'a>(&self, track: &'a Track) -> Option<Cow<'a, Track>> {
-        if track.available {
-            Some(Cow::Borrowed(track))
+    fn find_available_alternative<'a>(&self, audio: &'a AudioItem) -> Option<Cow<'a, AudioItem>> {
+        if audio.available {
+            Some(Cow::Borrowed(audio))
         } else {
-            let alternatives = track
-                .alternatives
-                .iter()
-                .map(|alt_id| Track::get(&self.session, *alt_id));
-            let alternatives = future::join_all(alternatives).wait().unwrap();
-
-            alternatives.into_iter().find(|alt| alt.available).map(Cow::Owned)
+            if let Some(alternatives) = &audio.alternatives {
+                let alternatives = alternatives
+                    .iter()
+                    .map(|alt_id| AudioItem::get_audio_item(&self.session, *alt_id));
+                let alternatives = future::join_all(alternatives).wait().unwrap();
+                alternatives.into_iter().find(|alt| alt.available).map(Cow::Owned)
+            } else {
+                None
+            }
         }
     }
 
@@ -569,60 +569,53 @@ impl PlayerInternal {
         }
     }
 
-    fn load_track(&self, track_id: SpotifyId, position: i64) -> Option<(Decoder, f32, StreamLoaderController)> {
-        let track = Track::get(&self.session, track_id).wait().unwrap();
+    fn load_track(&self, spotify_id: SpotifyId, position: i64) -> Option<(Decoder, f32, StreamLoaderController)> {
+        let audio = AudioItem::get_audio_item(&self.session, spotify_id)
+            .wait()
+            .unwrap();
+        info!("Loading <{}> with Spotify URI <{}>", audio.name, audio.uri);
 
-        info!(
-            "Loading track \"{}\" with Spotify URI \"spotify:track:{}\"",
-            track.name,
-            track_id.to_base62()
-        );
-
-	info!("find_available_alternative");
-
-        let track = match self.find_available_alternative(&track) {
-            Some(track) => track,
+        let audio = match self.find_available_alternative(&audio) {
+            Some(audio) => audio,
             None => {
-                warn!("Track \"{}\" is not available", track.name);
+                warn!("<{}> is not available", audio.uri);
                 return None;
             }
         };
-
-	info!("config.bitrate");
-
-
-        let format = match self.config.bitrate {
-            Bitrate::Bitrate96 => FileFormat::OGG_VORBIS_96,
-            Bitrate::Bitrate160 => FileFormat::OGG_VORBIS_160,
-            Bitrate::Bitrate320 => FileFormat::OGG_VORBIS_320,
+        // (Most) podcasts seem to support only 96 bit Vorbis, so fall back to it
+        let formats = match self.config.bitrate {
+            Bitrate::Bitrate96 => [
+                FileFormat::OGG_VORBIS_96,
+                FileFormat::OGG_VORBIS_160,
+                FileFormat::OGG_VORBIS_320,
+            ],
+            Bitrate::Bitrate160 => [
+                FileFormat::OGG_VORBIS_160,
+                FileFormat::OGG_VORBIS_96,
+                FileFormat::OGG_VORBIS_320,
+            ],
+            Bitrate::Bitrate320 => [
+                FileFormat::OGG_VORBIS_320,
+                FileFormat::OGG_VORBIS_160,
+                FileFormat::OGG_VORBIS_96,
+            ],
         };
+        let format = formats
+            .iter()
+            .find(|format| audio.files.contains_key(format))
+            .unwrap();
 
-	info!("file_id");
-
-        let file_id = match track.files.get(&format) {
+        let file_id = match audio.files.get(&format) {
             Some(&file_id) => file_id,
             None => {
-                warn!("Track \"{}\" is not available in format {:?}", track.name, format);
+                warn!("<{}> in not available in format {:?}", audio.name, format);
                 return None;
             }
         };
 
-	info!("key");
-
-        let key = self
-            .session
-            .audio_key()
-            .request(track.id, file_id);
-            //.wait()
-            //.unwrap()
-
-	info!("encrypted_file");
-
+        let key = self.session.audio_key().request(spotify_id, file_id);
         let encrypted_file = AudioFile::open(&self.session, file_id);
 
-
-	info!("waiting for encrypted_file");
-
         let encrypted_file = encrypted_file.wait().unwrap();
 
         let mut stream_loader_controller = encrypted_file.get_stream_loader_controller();
@@ -639,16 +632,9 @@ impl PlayerInternal {
         }
 
 
-
-	info!("wait for key");
         let key = key.wait().unwrap();
-
-	info!("decrypted_file");
-
         let mut decrypted_file = AudioDecrypt::new(key, encrypted_file);
 
-	info!("normalisation_factor");
-
         let normalisation_factor = match NormalisationData::parse_from_file(&mut decrypted_file) {
             Ok(normalisation_data) => NormalisationData::get_factor(&self.config, normalisation_data),
             Err(_) => {
@@ -657,12 +643,8 @@ impl PlayerInternal {
             }
         };
 
-	info!("new Subfile");
-
         let audio_file = Subfile::new(decrypted_file, 0xa7);
 
-	info!("new VorbisDecoder");
-
         let mut decoder = VorbisDecoder::new(audio_file).unwrap();
 
         if position != 0 {
@@ -672,9 +654,7 @@ impl PlayerInternal {
             }
             stream_loader_controller.set_stream_mode();
         }
-
-        info!("Track \"{}\" loaded", track.name);
-
+        info!("<{}> loaded", audio.name);
         Some((decoder, normalisation_factor, stream_loader_controller))
     }
 }
diff --git a/protocol/proto/metadata.proto b/protocol/proto/metadata.proto
index 1a7a900b..3812f94e 100644
--- a/protocol/proto/metadata.proto
+++ b/protocol/proto/metadata.proto
@@ -39,6 +39,8 @@ message Date {
     optional sint32 year = 0x1;
     optional sint32 month = 0x2;
     optional sint32 day = 0x3;
+    optional sint32 hour = 0x4;
+    optional sint32 minute = 0x5;
 }
 
 message Album {
@@ -124,15 +126,29 @@ message Copyright {
 }
 
 message Restriction {
-    optional string countries_allowed = 0x2;
-    optional string countries_forbidden = 0x3;
-    optional Type typ = 0x4;
+    enum Catalogue {
+      AD = 0;
+      SUBSCRIPTION = 1;
+      CATALOGUE_ALL = 2;
+      SHUFFLE = 3;
+      COMMERCIAL = 4;
+    }
     enum Type {
         STREAMING = 0x0;
     }
+    repeated Catalogue catalogue = 0x1;
+    optional string countries_allowed = 0x2;
+    optional string countries_forbidden = 0x3;
+    optional Type typ = 0x4;
+
     repeated string catalogue_str = 0x5;
 }
 
+message Availability {
+	repeated string catalogue_str = 0x1;
+	optional Date start = 0x2;
+}
+
 message SalePeriod {
     repeated Restriction restriction = 0x1;
     optional Date start = 0x2;
@@ -156,12 +172,95 @@ message AudioFile {
         MP3_160 = 0x5;
         MP3_96 = 0x6;
         MP3_160_ENC = 0x7;
-        OTHER2 = 0x8;
+        // v4 
+        // AAC_24 = 0x8;
+        // AAC_48 = 0x9;
+        MP4_128_DUAL = 0x8;
         OTHER3 = 0x9;
         AAC_160 = 0xa;
         AAC_320 = 0xb;
-        OTHER4 = 0xc;
+        MP4_128 = 0xc;
         OTHER5 = 0xd;
     }
 }
 
+message VideoFile {
+	optional bytes file_id = 1;
+}
+
+// Podcast Protos
+message Show {
+  enum MediaType {
+      MIXED = 0;
+      AUDIO = 1;
+      VIDEO = 2;
+  }
+  enum ConsumptionOrder {
+      SEQUENTIAL = 1;
+      EPISODIC = 2;
+      RECENT = 3;
+    }
+  enum PassthroughEnum {
+      UNKNOWN = 0;
+      NONE = 1;
+      ALLOWED = 2;
+  }
+  optional bytes gid = 0x1;
+  optional string name = 0x2;
+  optional string description = 0x40;
+  optional sint32 deprecated_popularity = 0x41;
+  optional string publisher = 0x42;
+  optional string language = 0x43;
+  optional bool explicit = 0x44;
+  optional ImageGroup covers = 0x45;
+  repeated Episode episode = 0x46;
+  repeated Copyright copyright = 0x47;
+  repeated Restriction restriction = 0x48;
+  repeated string keyword = 0x49;
+  optional MediaType media_type = 0x4A;
+  optional ConsumptionOrder consumption_order = 0x4B;
+  optional bool interpret_restriction_using_geoip = 0x4C;
+  repeated Availability availability = 0x4E;
+  optional string country_of_origin = 0x4F;	
+  repeated Category categories = 0x50;
+  optional PassthroughEnum passthrough = 0x51;
+}
+
+message Episode {
+  optional bytes gid = 0x1;
+  optional string name = 0x2;
+  optional sint32 duration = 0x7;
+  optional sint32 popularity = 0x8;
+  repeated AudioFile file = 0xc;
+  optional string description = 0x40;
+  optional sint32 number = 0x41;
+  optional Date publish_time = 0x42;
+  optional sint32 deprecated_popularity = 0x43;
+  optional ImageGroup covers = 0x44;
+  optional string language = 0x45;
+  optional bool explicit = 0x46;
+  optional Show show = 0x47;
+  repeated VideoFile video = 0x48;
+	repeated VideoFile video_preview = 0x49;
+  repeated AudioFile audio_preview = 0x4A;
+  repeated Restriction restriction = 0x4B;
+  optional ImageGroup freeze_frame = 0x4C;
+  repeated string keyword = 0x4D;
+  // Order of these two flags might be wrong! 
+  optional bool suppress_monetization = 0x4E;
+  optional bool interpret_restriction_using_geoip = 0x4F;
+  
+  optional bool allow_background_playback = 0x51;
+  repeated Availability availability = 0x52;
+  optional string external_url = 0x53;
+  optional OriginalAudio original_audio = 0x54;
+}
+
+message Category {
+  optional string name =  0x1;
+  repeated Category subcategories = 0x2;
+}
+
+message OriginalAudio {
+  optional bytes uuid = 0x1;
+}
diff --git a/protocol/src/metadata.rs b/protocol/src/metadata.rs
index 7cfa964d..386213ab 100644
--- a/protocol/src/metadata.rs
+++ b/protocol/src/metadata.rs
@@ -1626,6 +1626,8 @@ pub struct Date {
     year: ::std::option::Option<i32>,
     month: ::std::option::Option<i32>,
     day: ::std::option::Option<i32>,
+    hour: ::std::option::Option<i32>,
+    minute: ::std::option::Option<i32>,
     // special fields
     pub unknown_fields: ::protobuf::UnknownFields,
     pub cached_size: ::protobuf::CachedSize,
@@ -1698,6 +1700,44 @@ impl Date {
     pub fn set_day(&mut self, v: i32) {
         self.day = ::std::option::Option::Some(v);
     }
+
+    // optional sint32 hour = 4;
+
+
+    pub fn get_hour(&self) -> i32 {
+        self.hour.unwrap_or(0)
+    }
+    pub fn clear_hour(&mut self) {
+        self.hour = ::std::option::Option::None;
+    }
+
+    pub fn has_hour(&self) -> bool {
+        self.hour.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_hour(&mut self, v: i32) {
+        self.hour = ::std::option::Option::Some(v);
+    }
+
+    // optional sint32 minute = 5;
+
+
+    pub fn get_minute(&self) -> i32 {
+        self.minute.unwrap_or(0)
+    }
+    pub fn clear_minute(&mut self) {
+        self.minute = ::std::option::Option::None;
+    }
+
+    pub fn has_minute(&self) -> bool {
+        self.minute.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_minute(&mut self, v: i32) {
+        self.minute = ::std::option::Option::Some(v);
+    }
 }
 
 impl ::protobuf::Message for Date {
@@ -1730,6 +1770,20 @@ impl ::protobuf::Message for Date {
                     let tmp = is.read_sint32()?;
                     self.day = ::std::option::Option::Some(tmp);
                 },
+                4 => {
+                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    }
+                    let tmp = is.read_sint32()?;
+                    self.hour = ::std::option::Option::Some(tmp);
+                },
+                5 => {
+                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    }
+                    let tmp = is.read_sint32()?;
+                    self.minute = ::std::option::Option::Some(tmp);
+                },
                 _ => {
                     ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
@@ -1751,6 +1805,12 @@ impl ::protobuf::Message for Date {
         if let Some(v) = self.day {
             my_size += ::protobuf::rt::value_varint_zigzag_size(3, v);
         }
+        if let Some(v) = self.hour {
+            my_size += ::protobuf::rt::value_varint_zigzag_size(4, v);
+        }
+        if let Some(v) = self.minute {
+            my_size += ::protobuf::rt::value_varint_zigzag_size(5, v);
+        }
         my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
         self.cached_size.set(my_size);
         my_size
@@ -1766,6 +1826,12 @@ impl ::protobuf::Message for Date {
         if let Some(v) = self.day {
             os.write_sint32(3, v)?;
         }
+        if let Some(v) = self.hour {
+            os.write_sint32(4, v)?;
+        }
+        if let Some(v) = self.minute {
+            os.write_sint32(5, v)?;
+        }
         os.write_unknown_fields(self.get_unknown_fields())?;
         ::std::result::Result::Ok(())
     }
@@ -1823,6 +1889,16 @@ impl ::protobuf::Message for Date {
                     |m: &Date| { &m.day },
                     |m: &mut Date| { &mut m.day },
                 ));
+                fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeSint32>(
+                    "hour",
+                    |m: &Date| { &m.hour },
+                    |m: &mut Date| { &mut m.hour },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeSint32>(
+                    "minute",
+                    |m: &Date| { &m.minute },
+                    |m: &mut Date| { &mut m.minute },
+                ));
                 ::protobuf::reflect::MessageDescriptor::new::<Date>(
                     "Date",
                     fields,
@@ -1848,6 +1924,8 @@ impl ::protobuf::Clear for Date {
         self.year = ::std::option::Option::None;
         self.month = ::std::option::Option::None;
         self.day = ::std::option::Option::None;
+        self.hour = ::std::option::Option::None;
+        self.minute = ::std::option::Option::None;
         self.unknown_fields.clear();
     }
 }
@@ -5042,6 +5120,7 @@ impl ::protobuf::reflect::ProtobufValue for Copyright_Type {
 #[derive(PartialEq,Clone,Default)]
 pub struct Restriction {
     // message fields
+    catalogue: ::std::vec::Vec<Restriction_Catalogue>,
     countries_allowed: ::protobuf::SingularField<::std::string::String>,
     countries_forbidden: ::protobuf::SingularField<::std::string::String>,
     typ: ::std::option::Option<Restriction_Type>,
@@ -5062,6 +5141,31 @@ impl Restriction {
         ::std::default::Default::default()
     }
 
+    // repeated .Restriction.Catalogue catalogue = 1;
+
+
+    pub fn get_catalogue(&self) -> &[Restriction_Catalogue] {
+        &self.catalogue
+    }
+    pub fn clear_catalogue(&mut self) {
+        self.catalogue.clear();
+    }
+
+    // Param is passed by value, moved
+    pub fn set_catalogue(&mut self, v: ::std::vec::Vec<Restriction_Catalogue>) {
+        self.catalogue = v;
+    }
+
+    // Mutable pointer to the field.
+    pub fn mut_catalogue(&mut self) -> &mut ::std::vec::Vec<Restriction_Catalogue> {
+        &mut self.catalogue
+    }
+
+    // Take field
+    pub fn take_catalogue(&mut self) -> ::std::vec::Vec<Restriction_Catalogue> {
+        ::std::mem::replace(&mut self.catalogue, ::std::vec::Vec::new())
+    }
+
     // optional string countries_allowed = 2;
 
 
@@ -5188,6 +5292,9 @@ impl ::protobuf::Message for Restriction {
         while !is.eof()? {
             let (field_number, wire_type) = is.read_tag_unpack()?;
             match field_number {
+                1 => {
+                    ::protobuf::rt::read_repeated_enum_with_unknown_fields_into(wire_type, is, &mut self.catalogue, 1, &mut self.unknown_fields)?
+                },
                 2 => {
                     ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.countries_allowed)?;
                 },
@@ -5212,6 +5319,9 @@ impl ::protobuf::Message for Restriction {
     #[allow(unused_variables)]
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
+        for value in &self.catalogue {
+            my_size += ::protobuf::rt::enum_size(1, *value);
+        };
         if let Some(ref v) = self.countries_allowed.as_ref() {
             my_size += ::protobuf::rt::string_size(2, &v);
         }
@@ -5230,6 +5340,9 @@ impl ::protobuf::Message for Restriction {
     }
 
     fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
+        for v in &self.catalogue {
+            os.write_enum(1, v.value())?;
+        };
         if let Some(ref v) = self.countries_allowed.as_ref() {
             os.write_string(2, &v)?;
         }
@@ -5284,6 +5397,11 @@ impl ::protobuf::Message for Restriction {
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
+                fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeEnum<Restriction_Catalogue>>(
+                    "catalogue",
+                    |m: &Restriction| { &m.catalogue },
+                    |m: &mut Restriction| { &mut m.catalogue },
+                ));
                 fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                     "countries_allowed",
                     |m: &Restriction| { &m.countries_allowed },
@@ -5326,6 +5444,7 @@ impl ::protobuf::Message for Restriction {
 
 impl ::protobuf::Clear for Restriction {
     fn clear(&mut self) {
+        self.catalogue.clear();
         self.countries_allowed.clear();
         self.countries_forbidden.clear();
         self.typ = ::std::option::Option::None;
@@ -5346,6 +5465,70 @@ impl ::protobuf::reflect::ProtobufValue for Restriction {
     }
 }
 
+#[derive(Clone,PartialEq,Eq,Debug,Hash)]
+pub enum Restriction_Catalogue {
+    AD = 0,
+    SUBSCRIPTION = 1,
+    CATALOGUE_ALL = 2,
+    SHUFFLE = 3,
+    COMMERCIAL = 4,
+}
+
+impl ::protobuf::ProtobufEnum for Restriction_Catalogue {
+    fn value(&self) -> i32 {
+        *self as i32
+    }
+
+    fn from_i32(value: i32) -> ::std::option::Option<Restriction_Catalogue> {
+        match value {
+            0 => ::std::option::Option::Some(Restriction_Catalogue::AD),
+            1 => ::std::option::Option::Some(Restriction_Catalogue::SUBSCRIPTION),
+            2 => ::std::option::Option::Some(Restriction_Catalogue::CATALOGUE_ALL),
+            3 => ::std::option::Option::Some(Restriction_Catalogue::SHUFFLE),
+            4 => ::std::option::Option::Some(Restriction_Catalogue::COMMERCIAL),
+            _ => ::std::option::Option::None
+        }
+    }
+
+    fn values() -> &'static [Self] {
+        static values: &'static [Restriction_Catalogue] = &[
+            Restriction_Catalogue::AD,
+            Restriction_Catalogue::SUBSCRIPTION,
+            Restriction_Catalogue::CATALOGUE_ALL,
+            Restriction_Catalogue::SHUFFLE,
+            Restriction_Catalogue::COMMERCIAL,
+        ];
+        values
+    }
+
+    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
+            lock: ::protobuf::lazy::ONCE_INIT,
+            ptr: 0 as *const ::protobuf::reflect::EnumDescriptor,
+        };
+        unsafe {
+            descriptor.get(|| {
+                ::protobuf::reflect::EnumDescriptor::new("Restriction_Catalogue", file_descriptor_proto())
+            })
+        }
+    }
+}
+
+impl ::std::marker::Copy for Restriction_Catalogue {
+}
+
+impl ::std::default::Default for Restriction_Catalogue {
+    fn default() -> Self {
+        Restriction_Catalogue::AD
+    }
+}
+
+impl ::protobuf::reflect::ProtobufValue for Restriction_Catalogue {
+    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
+        ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor())
+    }
+}
+
 #[derive(Clone,PartialEq,Eq,Debug,Hash)]
 pub enum Restriction_Type {
     STREAMING = 0,
@@ -5398,6 +5581,231 @@ impl ::protobuf::reflect::ProtobufValue for Restriction_Type {
     }
 }
 
+#[derive(PartialEq,Clone,Default)]
+pub struct Availability {
+    // message fields
+    catalogue_str: ::protobuf::RepeatedField<::std::string::String>,
+    start: ::protobuf::SingularPtrField<Date>,
+    // special fields
+    pub unknown_fields: ::protobuf::UnknownFields,
+    pub cached_size: ::protobuf::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a Availability {
+    fn default() -> &'a Availability {
+        <Availability as ::protobuf::Message>::default_instance()
+    }
+}
+
+impl Availability {
+    pub fn new() -> Availability {
+        ::std::default::Default::default()
+    }
+
+    // repeated string catalogue_str = 1;
+
+
+    pub fn get_catalogue_str(&self) -> &[::std::string::String] {
+        &self.catalogue_str
+    }
+    pub fn clear_catalogue_str(&mut self) {
+        self.catalogue_str.clear();
+    }
+
+    // Param is passed by value, moved
+    pub fn set_catalogue_str(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
+        self.catalogue_str = v;
+    }
+
+    // Mutable pointer to the field.
+    pub fn mut_catalogue_str(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
+        &mut self.catalogue_str
+    }
+
+    // Take field
+    pub fn take_catalogue_str(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
+        ::std::mem::replace(&mut self.catalogue_str, ::protobuf::RepeatedField::new())
+    }
+
+    // optional .Date start = 2;
+
+
+    pub fn get_start(&self) -> &Date {
+        self.start.as_ref().unwrap_or_else(|| Date::default_instance())
+    }
+    pub fn clear_start(&mut self) {
+        self.start.clear();
+    }
+
+    pub fn has_start(&self) -> bool {
+        self.start.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_start(&mut self, v: Date) {
+        self.start = ::protobuf::SingularPtrField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_start(&mut self) -> &mut Date {
+        if self.start.is_none() {
+            self.start.set_default();
+        }
+        self.start.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_start(&mut self) -> Date {
+        self.start.take().unwrap_or_else(|| Date::new())
+    }
+}
+
+impl ::protobuf::Message for Availability {
+    fn is_initialized(&self) -> bool {
+        for v in &self.start {
+            if !v.is_initialized() {
+                return false;
+            }
+        };
+        true
+    }
+
+    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
+        while !is.eof()? {
+            let (field_number, wire_type) = is.read_tag_unpack()?;
+            match field_number {
+                1 => {
+                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.catalogue_str)?;
+                },
+                2 => {
+                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.start)?;
+                },
+                _ => {
+                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                },
+            };
+        }
+        ::std::result::Result::Ok(())
+    }
+
+    // Compute sizes of nested messages
+    #[allow(unused_variables)]
+    fn compute_size(&self) -> u32 {
+        let mut my_size = 0;
+        for value in &self.catalogue_str {
+            my_size += ::protobuf::rt::string_size(1, &value);
+        };
+        if let Some(ref v) = self.start.as_ref() {
+            let len = v.compute_size();
+            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+        }
+        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        self.cached_size.set(my_size);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
+        for v in &self.catalogue_str {
+            os.write_string(1, &v)?;
+        };
+        if let Some(ref v) = self.start.as_ref() {
+            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_raw_varint32(v.get_cached_size())?;
+            v.write_to_with_cached_sizes(os)?;
+        }
+        os.write_unknown_fields(self.get_unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn get_cached_size(&self) -> u32 {
+        self.cached_size.get()
+    }
+
+    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+        &self.unknown_fields
+    }
+
+    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+        &mut self.unknown_fields
+    }
+
+    fn as_any(&self) -> &dyn (::std::any::Any) {
+        self as &dyn (::std::any::Any)
+    }
+    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
+        self as &mut dyn (::std::any::Any)
+    }
+    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+        self
+    }
+
+    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+        Self::descriptor_static()
+    }
+
+    fn new() -> Availability {
+        Availability::new()
+    }
+
+    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
+            lock: ::protobuf::lazy::ONCE_INIT,
+            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
+        };
+        unsafe {
+            descriptor.get(|| {
+                let mut fields = ::std::vec::Vec::new();
+                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+                    "catalogue_str",
+                    |m: &Availability| { &m.catalogue_str },
+                    |m: &mut Availability| { &mut m.catalogue_str },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Date>>(
+                    "start",
+                    |m: &Availability| { &m.start },
+                    |m: &mut Availability| { &mut m.start },
+                ));
+                ::protobuf::reflect::MessageDescriptor::new::<Availability>(
+                    "Availability",
+                    fields,
+                    file_descriptor_proto()
+                )
+            })
+        }
+    }
+
+    fn default_instance() -> &'static Availability {
+        static mut instance: ::protobuf::lazy::Lazy<Availability> = ::protobuf::lazy::Lazy {
+            lock: ::protobuf::lazy::ONCE_INIT,
+            ptr: 0 as *const Availability,
+        };
+        unsafe {
+            instance.get(Availability::new)
+        }
+    }
+}
+
+impl ::protobuf::Clear for Availability {
+    fn clear(&mut self) {
+        self.catalogue_str.clear();
+        self.start.clear();
+        self.unknown_fields.clear();
+    }
+}
+
+impl ::std::fmt::Debug for Availability {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        ::protobuf::text_format::fmt(self, f)
+    }
+}
+
+impl ::protobuf::reflect::ProtobufValue for Availability {
+    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
+        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    }
+}
+
 #[derive(PartialEq,Clone,Default)]
 pub struct SalePeriod {
     // message fields
@@ -6143,11 +6551,11 @@ pub enum AudioFile_Format {
     MP3_160 = 5,
     MP3_96 = 6,
     MP3_160_ENC = 7,
-    OTHER2 = 8,
+    MP4_128_DUAL = 8,
     OTHER3 = 9,
     AAC_160 = 10,
     AAC_320 = 11,
-    OTHER4 = 12,
+    MP4_128 = 12,
     OTHER5 = 13,
 }
 
@@ -6166,11 +6574,11 @@ impl ::protobuf::ProtobufEnum for AudioFile_Format {
             5 => ::std::option::Option::Some(AudioFile_Format::MP3_160),
             6 => ::std::option::Option::Some(AudioFile_Format::MP3_96),
             7 => ::std::option::Option::Some(AudioFile_Format::MP3_160_ENC),
-            8 => ::std::option::Option::Some(AudioFile_Format::OTHER2),
+            8 => ::std::option::Option::Some(AudioFile_Format::MP4_128_DUAL),
             9 => ::std::option::Option::Some(AudioFile_Format::OTHER3),
             10 => ::std::option::Option::Some(AudioFile_Format::AAC_160),
             11 => ::std::option::Option::Some(AudioFile_Format::AAC_320),
-            12 => ::std::option::Option::Some(AudioFile_Format::OTHER4),
+            12 => ::std::option::Option::Some(AudioFile_Format::MP4_128),
             13 => ::std::option::Option::Some(AudioFile_Format::OTHER5),
             _ => ::std::option::Option::None
         }
@@ -6186,11 +6594,11 @@ impl ::protobuf::ProtobufEnum for AudioFile_Format {
             AudioFile_Format::MP3_160,
             AudioFile_Format::MP3_96,
             AudioFile_Format::MP3_160_ENC,
-            AudioFile_Format::OTHER2,
+            AudioFile_Format::MP4_128_DUAL,
             AudioFile_Format::OTHER3,
             AudioFile_Format::AAC_160,
             AudioFile_Format::AAC_320,
-            AudioFile_Format::OTHER4,
+            AudioFile_Format::MP4_128,
             AudioFile_Format::OTHER5,
         ];
         values
@@ -6224,6 +6632,3090 @@ impl ::protobuf::reflect::ProtobufValue for AudioFile_Format {
     }
 }
 
+#[derive(PartialEq,Clone,Default)]
+pub struct VideoFile {
+    // message fields
+    file_id: ::protobuf::SingularField<::std::vec::Vec<u8>>,
+    // special fields
+    pub unknown_fields: ::protobuf::UnknownFields,
+    pub cached_size: ::protobuf::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a VideoFile {
+    fn default() -> &'a VideoFile {
+        <VideoFile as ::protobuf::Message>::default_instance()
+    }
+}
+
+impl VideoFile {
+    pub fn new() -> VideoFile {
+        ::std::default::Default::default()
+    }
+
+    // optional bytes file_id = 1;
+
+
+    pub fn get_file_id(&self) -> &[u8] {
+        match self.file_id.as_ref() {
+            Some(v) => &v,
+            None => &[],
+        }
+    }
+    pub fn clear_file_id(&mut self) {
+        self.file_id.clear();
+    }
+
+    pub fn has_file_id(&self) -> bool {
+        self.file_id.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_file_id(&mut self, v: ::std::vec::Vec<u8>) {
+        self.file_id = ::protobuf::SingularField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_file_id(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.file_id.is_none() {
+            self.file_id.set_default();
+        }
+        self.file_id.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_file_id(&mut self) -> ::std::vec::Vec<u8> {
+        self.file_id.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+}
+
+impl ::protobuf::Message for VideoFile {
+    fn is_initialized(&self) -> bool {
+        true
+    }
+
+    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
+        while !is.eof()? {
+            let (field_number, wire_type) = is.read_tag_unpack()?;
+            match field_number {
+                1 => {
+                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.file_id)?;
+                },
+                _ => {
+                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                },
+            };
+        }
+        ::std::result::Result::Ok(())
+    }
+
+    // Compute sizes of nested messages
+    #[allow(unused_variables)]
+    fn compute_size(&self) -> u32 {
+        let mut my_size = 0;
+        if let Some(ref v) = self.file_id.as_ref() {
+            my_size += ::protobuf::rt::bytes_size(1, &v);
+        }
+        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        self.cached_size.set(my_size);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
+        if let Some(ref v) = self.file_id.as_ref() {
+            os.write_bytes(1, &v)?;
+        }
+        os.write_unknown_fields(self.get_unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn get_cached_size(&self) -> u32 {
+        self.cached_size.get()
+    }
+
+    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+        &self.unknown_fields
+    }
+
+    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+        &mut self.unknown_fields
+    }
+
+    fn as_any(&self) -> &dyn (::std::any::Any) {
+        self as &dyn (::std::any::Any)
+    }
+    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
+        self as &mut dyn (::std::any::Any)
+    }
+    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+        self
+    }
+
+    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+        Self::descriptor_static()
+    }
+
+    fn new() -> VideoFile {
+        VideoFile::new()
+    }
+
+    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
+            lock: ::protobuf::lazy::ONCE_INIT,
+            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
+        };
+        unsafe {
+            descriptor.get(|| {
+                let mut fields = ::std::vec::Vec::new();
+                fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
+                    "file_id",
+                    |m: &VideoFile| { &m.file_id },
+                    |m: &mut VideoFile| { &mut m.file_id },
+                ));
+                ::protobuf::reflect::MessageDescriptor::new::<VideoFile>(
+                    "VideoFile",
+                    fields,
+                    file_descriptor_proto()
+                )
+            })
+        }
+    }
+
+    fn default_instance() -> &'static VideoFile {
+        static mut instance: ::protobuf::lazy::Lazy<VideoFile> = ::protobuf::lazy::Lazy {
+            lock: ::protobuf::lazy::ONCE_INIT,
+            ptr: 0 as *const VideoFile,
+        };
+        unsafe {
+            instance.get(VideoFile::new)
+        }
+    }
+}
+
+impl ::protobuf::Clear for VideoFile {
+    fn clear(&mut self) {
+        self.file_id.clear();
+        self.unknown_fields.clear();
+    }
+}
+
+impl ::std::fmt::Debug for VideoFile {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        ::protobuf::text_format::fmt(self, f)
+    }
+}
+
+impl ::protobuf::reflect::ProtobufValue for VideoFile {
+    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
+        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    }
+}
+
+#[derive(PartialEq,Clone,Default)]
+pub struct Show {
+    // message fields
+    gid: ::protobuf::SingularField<::std::vec::Vec<u8>>,
+    name: ::protobuf::SingularField<::std::string::String>,
+    description: ::protobuf::SingularField<::std::string::String>,
+    deprecated_popularity: ::std::option::Option<i32>,
+    publisher: ::protobuf::SingularField<::std::string::String>,
+    language: ::protobuf::SingularField<::std::string::String>,
+    explicit: ::std::option::Option<bool>,
+    covers: ::protobuf::SingularPtrField<ImageGroup>,
+    episode: ::protobuf::RepeatedField<Episode>,
+    copyright: ::protobuf::RepeatedField<Copyright>,
+    restriction: ::protobuf::RepeatedField<Restriction>,
+    keyword: ::protobuf::RepeatedField<::std::string::String>,
+    media_type: ::std::option::Option<Show_MediaType>,
+    consumption_order: ::std::option::Option<Show_ConsumptionOrder>,
+    interpret_restriction_using_geoip: ::std::option::Option<bool>,
+    availability: ::protobuf::RepeatedField<Availability>,
+    country_of_origin: ::protobuf::SingularField<::std::string::String>,
+    categories: ::protobuf::RepeatedField<Category>,
+    passthrough: ::std::option::Option<Show_PassthroughEnum>,
+    // special fields
+    pub unknown_fields: ::protobuf::UnknownFields,
+    pub cached_size: ::protobuf::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a Show {
+    fn default() -> &'a Show {
+        <Show as ::protobuf::Message>::default_instance()
+    }
+}
+
+impl Show {
+    pub fn new() -> Show {
+        ::std::default::Default::default()
+    }
+
+    // optional bytes gid = 1;
+
+
+    pub fn get_gid(&self) -> &[u8] {
+        match self.gid.as_ref() {
+            Some(v) => &v,
+            None => &[],
+        }
+    }
+    pub fn clear_gid(&mut self) {
+        self.gid.clear();
+    }
+
+    pub fn has_gid(&self) -> bool {
+        self.gid.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_gid(&mut self, v: ::std::vec::Vec<u8>) {
+        self.gid = ::protobuf::SingularField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_gid(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.gid.is_none() {
+            self.gid.set_default();
+        }
+        self.gid.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_gid(&mut self) -> ::std::vec::Vec<u8> {
+        self.gid.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+
+    // optional string name = 2;
+
+
+    pub fn get_name(&self) -> &str {
+        match self.name.as_ref() {
+            Some(v) => &v,
+            None => "",
+        }
+    }
+    pub fn clear_name(&mut self) {
+        self.name.clear();
+    }
+
+    pub fn has_name(&self) -> bool {
+        self.name.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_name(&mut self, v: ::std::string::String) {
+        self.name = ::protobuf::SingularField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_name(&mut self) -> &mut ::std::string::String {
+        if self.name.is_none() {
+            self.name.set_default();
+        }
+        self.name.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_name(&mut self) -> ::std::string::String {
+        self.name.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+
+    // optional string description = 64;
+
+
+    pub fn get_description(&self) -> &str {
+        match self.description.as_ref() {
+            Some(v) => &v,
+            None => "",
+        }
+    }
+    pub fn clear_description(&mut self) {
+        self.description.clear();
+    }
+
+    pub fn has_description(&self) -> bool {
+        self.description.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_description(&mut self, v: ::std::string::String) {
+        self.description = ::protobuf::SingularField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_description(&mut self) -> &mut ::std::string::String {
+        if self.description.is_none() {
+            self.description.set_default();
+        }
+        self.description.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_description(&mut self) -> ::std::string::String {
+        self.description.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+
+    // optional sint32 deprecated_popularity = 65;
+
+
+    pub fn get_deprecated_popularity(&self) -> i32 {
+        self.deprecated_popularity.unwrap_or(0)
+    }
+    pub fn clear_deprecated_popularity(&mut self) {
+        self.deprecated_popularity = ::std::option::Option::None;
+    }
+
+    pub fn has_deprecated_popularity(&self) -> bool {
+        self.deprecated_popularity.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_deprecated_popularity(&mut self, v: i32) {
+        self.deprecated_popularity = ::std::option::Option::Some(v);
+    }
+
+    // optional string publisher = 66;
+
+
+    pub fn get_publisher(&self) -> &str {
+        match self.publisher.as_ref() {
+            Some(v) => &v,
+            None => "",
+        }
+    }
+    pub fn clear_publisher(&mut self) {
+        self.publisher.clear();
+    }
+
+    pub fn has_publisher(&self) -> bool {
+        self.publisher.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_publisher(&mut self, v: ::std::string::String) {
+        self.publisher = ::protobuf::SingularField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_publisher(&mut self) -> &mut ::std::string::String {
+        if self.publisher.is_none() {
+            self.publisher.set_default();
+        }
+        self.publisher.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_publisher(&mut self) -> ::std::string::String {
+        self.publisher.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+
+    // optional string language = 67;
+
+
+    pub fn get_language(&self) -> &str {
+        match self.language.as_ref() {
+            Some(v) => &v,
+            None => "",
+        }
+    }
+    pub fn clear_language(&mut self) {
+        self.language.clear();
+    }
+
+    pub fn has_language(&self) -> bool {
+        self.language.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_language(&mut self, v: ::std::string::String) {
+        self.language = ::protobuf::SingularField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_language(&mut self) -> &mut ::std::string::String {
+        if self.language.is_none() {
+            self.language.set_default();
+        }
+        self.language.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_language(&mut self) -> ::std::string::String {
+        self.language.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+
+    // optional bool explicit = 68;
+
+
+    pub fn get_explicit(&self) -> bool {
+        self.explicit.unwrap_or(false)
+    }
+    pub fn clear_explicit(&mut self) {
+        self.explicit = ::std::option::Option::None;
+    }
+
+    pub fn has_explicit(&self) -> bool {
+        self.explicit.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_explicit(&mut self, v: bool) {
+        self.explicit = ::std::option::Option::Some(v);
+    }
+
+    // optional .ImageGroup covers = 69;
+
+
+    pub fn get_covers(&self) -> &ImageGroup {
+        self.covers.as_ref().unwrap_or_else(|| ImageGroup::default_instance())
+    }
+    pub fn clear_covers(&mut self) {
+        self.covers.clear();
+    }
+
+    pub fn has_covers(&self) -> bool {
+        self.covers.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_covers(&mut self, v: ImageGroup) {
+        self.covers = ::protobuf::SingularPtrField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_covers(&mut self) -> &mut ImageGroup {
+        if self.covers.is_none() {
+            self.covers.set_default();
+        }
+        self.covers.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_covers(&mut self) -> ImageGroup {
+        self.covers.take().unwrap_or_else(|| ImageGroup::new())
+    }
+
+    // repeated .Episode episode = 70;
+
+
+    pub fn get_episode(&self) -> &[Episode] {
+        &self.episode
+    }
+    pub fn clear_episode(&mut self) {
+        self.episode.clear();
+    }
+
+    // Param is passed by value, moved
+    pub fn set_episode(&mut self, v: ::protobuf::RepeatedField<Episode>) {
+        self.episode = v;
+    }
+
+    // Mutable pointer to the field.
+    pub fn mut_episode(&mut self) -> &mut ::protobuf::RepeatedField<Episode> {
+        &mut self.episode
+    }
+
+    // Take field
+    pub fn take_episode(&mut self) -> ::protobuf::RepeatedField<Episode> {
+        ::std::mem::replace(&mut self.episode, ::protobuf::RepeatedField::new())
+    }
+
+    // repeated .Copyright copyright = 71;
+
+
+    pub fn get_copyright(&self) -> &[Copyright] {
+        &self.copyright
+    }
+    pub fn clear_copyright(&mut self) {
+        self.copyright.clear();
+    }
+
+    // Param is passed by value, moved
+    pub fn set_copyright(&mut self, v: ::protobuf::RepeatedField<Copyright>) {
+        self.copyright = v;
+    }
+
+    // Mutable pointer to the field.
+    pub fn mut_copyright(&mut self) -> &mut ::protobuf::RepeatedField<Copyright> {
+        &mut self.copyright
+    }
+
+    // Take field
+    pub fn take_copyright(&mut self) -> ::protobuf::RepeatedField<Copyright> {
+        ::std::mem::replace(&mut self.copyright, ::protobuf::RepeatedField::new())
+    }
+
+    // repeated .Restriction restriction = 72;
+
+
+    pub fn get_restriction(&self) -> &[Restriction] {
+        &self.restriction
+    }
+    pub fn clear_restriction(&mut self) {
+        self.restriction.clear();
+    }
+
+    // Param is passed by value, moved
+    pub fn set_restriction(&mut self, v: ::protobuf::RepeatedField<Restriction>) {
+        self.restriction = v;
+    }
+
+    // Mutable pointer to the field.
+    pub fn mut_restriction(&mut self) -> &mut ::protobuf::RepeatedField<Restriction> {
+        &mut self.restriction
+    }
+
+    // Take field
+    pub fn take_restriction(&mut self) -> ::protobuf::RepeatedField<Restriction> {
+        ::std::mem::replace(&mut self.restriction, ::protobuf::RepeatedField::new())
+    }
+
+    // repeated string keyword = 73;
+
+
+    pub fn get_keyword(&self) -> &[::std::string::String] {
+        &self.keyword
+    }
+    pub fn clear_keyword(&mut self) {
+        self.keyword.clear();
+    }
+
+    // Param is passed by value, moved
+    pub fn set_keyword(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
+        self.keyword = v;
+    }
+
+    // Mutable pointer to the field.
+    pub fn mut_keyword(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
+        &mut self.keyword
+    }
+
+    // Take field
+    pub fn take_keyword(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
+        ::std::mem::replace(&mut self.keyword, ::protobuf::RepeatedField::new())
+    }
+
+    // optional .Show.MediaType media_type = 74;
+
+
+    pub fn get_media_type(&self) -> Show_MediaType {
+        self.media_type.unwrap_or(Show_MediaType::MIXED)
+    }
+    pub fn clear_media_type(&mut self) {
+        self.media_type = ::std::option::Option::None;
+    }
+
+    pub fn has_media_type(&self) -> bool {
+        self.media_type.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_media_type(&mut self, v: Show_MediaType) {
+        self.media_type = ::std::option::Option::Some(v);
+    }
+
+    // optional .Show.ConsumptionOrder consumption_order = 75;
+
+
+    pub fn get_consumption_order(&self) -> Show_ConsumptionOrder {
+        self.consumption_order.unwrap_or(Show_ConsumptionOrder::SEQUENTIAL)
+    }
+    pub fn clear_consumption_order(&mut self) {
+        self.consumption_order = ::std::option::Option::None;
+    }
+
+    pub fn has_consumption_order(&self) -> bool {
+        self.consumption_order.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_consumption_order(&mut self, v: Show_ConsumptionOrder) {
+        self.consumption_order = ::std::option::Option::Some(v);
+    }
+
+    // optional bool interpret_restriction_using_geoip = 76;
+
+
+    pub fn get_interpret_restriction_using_geoip(&self) -> bool {
+        self.interpret_restriction_using_geoip.unwrap_or(false)
+    }
+    pub fn clear_interpret_restriction_using_geoip(&mut self) {
+        self.interpret_restriction_using_geoip = ::std::option::Option::None;
+    }
+
+    pub fn has_interpret_restriction_using_geoip(&self) -> bool {
+        self.interpret_restriction_using_geoip.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_interpret_restriction_using_geoip(&mut self, v: bool) {
+        self.interpret_restriction_using_geoip = ::std::option::Option::Some(v);
+    }
+
+    // repeated .Availability availability = 78;
+
+
+    pub fn get_availability(&self) -> &[Availability] {
+        &self.availability
+    }
+    pub fn clear_availability(&mut self) {
+        self.availability.clear();
+    }
+
+    // Param is passed by value, moved
+    pub fn set_availability(&mut self, v: ::protobuf::RepeatedField<Availability>) {
+        self.availability = v;
+    }
+
+    // Mutable pointer to the field.
+    pub fn mut_availability(&mut self) -> &mut ::protobuf::RepeatedField<Availability> {
+        &mut self.availability
+    }
+
+    // Take field
+    pub fn take_availability(&mut self) -> ::protobuf::RepeatedField<Availability> {
+        ::std::mem::replace(&mut self.availability, ::protobuf::RepeatedField::new())
+    }
+
+    // optional string country_of_origin = 79;
+
+
+    pub fn get_country_of_origin(&self) -> &str {
+        match self.country_of_origin.as_ref() {
+            Some(v) => &v,
+            None => "",
+        }
+    }
+    pub fn clear_country_of_origin(&mut self) {
+        self.country_of_origin.clear();
+    }
+
+    pub fn has_country_of_origin(&self) -> bool {
+        self.country_of_origin.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_country_of_origin(&mut self, v: ::std::string::String) {
+        self.country_of_origin = ::protobuf::SingularField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_country_of_origin(&mut self) -> &mut ::std::string::String {
+        if self.country_of_origin.is_none() {
+            self.country_of_origin.set_default();
+        }
+        self.country_of_origin.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_country_of_origin(&mut self) -> ::std::string::String {
+        self.country_of_origin.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+
+    // repeated .Category categories = 80;
+
+
+    pub fn get_categories(&self) -> &[Category] {
+        &self.categories
+    }
+    pub fn clear_categories(&mut self) {
+        self.categories.clear();
+    }
+
+    // Param is passed by value, moved
+    pub fn set_categories(&mut self, v: ::protobuf::RepeatedField<Category>) {
+        self.categories = v;
+    }
+
+    // Mutable pointer to the field.
+    pub fn mut_categories(&mut self) -> &mut ::protobuf::RepeatedField<Category> {
+        &mut self.categories
+    }
+
+    // Take field
+    pub fn take_categories(&mut self) -> ::protobuf::RepeatedField<Category> {
+        ::std::mem::replace(&mut self.categories, ::protobuf::RepeatedField::new())
+    }
+
+    // optional .Show.PassthroughEnum passthrough = 81;
+
+
+    pub fn get_passthrough(&self) -> Show_PassthroughEnum {
+        self.passthrough.unwrap_or(Show_PassthroughEnum::UNKNOWN)
+    }
+    pub fn clear_passthrough(&mut self) {
+        self.passthrough = ::std::option::Option::None;
+    }
+
+    pub fn has_passthrough(&self) -> bool {
+        self.passthrough.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_passthrough(&mut self, v: Show_PassthroughEnum) {
+        self.passthrough = ::std::option::Option::Some(v);
+    }
+}
+
+impl ::protobuf::Message for Show {
+    fn is_initialized(&self) -> bool {
+        for v in &self.covers {
+            if !v.is_initialized() {
+                return false;
+            }
+        };
+        for v in &self.episode {
+            if !v.is_initialized() {
+                return false;
+            }
+        };
+        for v in &self.copyright {
+            if !v.is_initialized() {
+                return false;
+            }
+        };
+        for v in &self.restriction {
+            if !v.is_initialized() {
+                return false;
+            }
+        };
+        for v in &self.availability {
+            if !v.is_initialized() {
+                return false;
+            }
+        };
+        for v in &self.categories {
+            if !v.is_initialized() {
+                return false;
+            }
+        };
+        true
+    }
+
+    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
+        while !is.eof()? {
+            let (field_number, wire_type) = is.read_tag_unpack()?;
+            match field_number {
+                1 => {
+                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.gid)?;
+                },
+                2 => {
+                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
+                },
+                64 => {
+                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.description)?;
+                },
+                65 => {
+                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    }
+                    let tmp = is.read_sint32()?;
+                    self.deprecated_popularity = ::std::option::Option::Some(tmp);
+                },
+                66 => {
+                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.publisher)?;
+                },
+                67 => {
+                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.language)?;
+                },
+                68 => {
+                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    }
+                    let tmp = is.read_bool()?;
+                    self.explicit = ::std::option::Option::Some(tmp);
+                },
+                69 => {
+                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.covers)?;
+                },
+                70 => {
+                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.episode)?;
+                },
+                71 => {
+                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.copyright)?;
+                },
+                72 => {
+                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.restriction)?;
+                },
+                73 => {
+                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.keyword)?;
+                },
+                74 => {
+                    ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.media_type, 74, &mut self.unknown_fields)?
+                },
+                75 => {
+                    ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.consumption_order, 75, &mut self.unknown_fields)?
+                },
+                76 => {
+                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    }
+                    let tmp = is.read_bool()?;
+                    self.interpret_restriction_using_geoip = ::std::option::Option::Some(tmp);
+                },
+                78 => {
+                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.availability)?;
+                },
+                79 => {
+                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.country_of_origin)?;
+                },
+                80 => {
+                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.categories)?;
+                },
+                81 => {
+                    ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.passthrough, 81, &mut self.unknown_fields)?
+                },
+                _ => {
+                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                },
+            };
+        }
+        ::std::result::Result::Ok(())
+    }
+
+    // Compute sizes of nested messages
+    #[allow(unused_variables)]
+    fn compute_size(&self) -> u32 {
+        let mut my_size = 0;
+        if let Some(ref v) = self.gid.as_ref() {
+            my_size += ::protobuf::rt::bytes_size(1, &v);
+        }
+        if let Some(ref v) = self.name.as_ref() {
+            my_size += ::protobuf::rt::string_size(2, &v);
+        }
+        if let Some(ref v) = self.description.as_ref() {
+            my_size += ::protobuf::rt::string_size(64, &v);
+        }
+        if let Some(v) = self.deprecated_popularity {
+            my_size += ::protobuf::rt::value_varint_zigzag_size(65, v);
+        }
+        if let Some(ref v) = self.publisher.as_ref() {
+            my_size += ::protobuf::rt::string_size(66, &v);
+        }
+        if let Some(ref v) = self.language.as_ref() {
+            my_size += ::protobuf::rt::string_size(67, &v);
+        }
+        if let Some(v) = self.explicit {
+            my_size += 3;
+        }
+        if let Some(ref v) = self.covers.as_ref() {
+            let len = v.compute_size();
+            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+        }
+        for value in &self.episode {
+            let len = value.compute_size();
+            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+        };
+        for value in &self.copyright {
+            let len = value.compute_size();
+            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+        };
+        for value in &self.restriction {
+            let len = value.compute_size();
+            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+        };
+        for value in &self.keyword {
+            my_size += ::protobuf::rt::string_size(73, &value);
+        };
+        if let Some(v) = self.media_type {
+            my_size += ::protobuf::rt::enum_size(74, v);
+        }
+        if let Some(v) = self.consumption_order {
+            my_size += ::protobuf::rt::enum_size(75, v);
+        }
+        if let Some(v) = self.interpret_restriction_using_geoip {
+            my_size += 3;
+        }
+        for value in &self.availability {
+            let len = value.compute_size();
+            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+        };
+        if let Some(ref v) = self.country_of_origin.as_ref() {
+            my_size += ::protobuf::rt::string_size(79, &v);
+        }
+        for value in &self.categories {
+            let len = value.compute_size();
+            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+        };
+        if let Some(v) = self.passthrough {
+            my_size += ::protobuf::rt::enum_size(81, v);
+        }
+        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        self.cached_size.set(my_size);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
+        if let Some(ref v) = self.gid.as_ref() {
+            os.write_bytes(1, &v)?;
+        }
+        if let Some(ref v) = self.name.as_ref() {
+            os.write_string(2, &v)?;
+        }
+        if let Some(ref v) = self.description.as_ref() {
+            os.write_string(64, &v)?;
+        }
+        if let Some(v) = self.deprecated_popularity {
+            os.write_sint32(65, v)?;
+        }
+        if let Some(ref v) = self.publisher.as_ref() {
+            os.write_string(66, &v)?;
+        }
+        if let Some(ref v) = self.language.as_ref() {
+            os.write_string(67, &v)?;
+        }
+        if let Some(v) = self.explicit {
+            os.write_bool(68, v)?;
+        }
+        if let Some(ref v) = self.covers.as_ref() {
+            os.write_tag(69, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_raw_varint32(v.get_cached_size())?;
+            v.write_to_with_cached_sizes(os)?;
+        }
+        for v in &self.episode {
+            os.write_tag(70, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_raw_varint32(v.get_cached_size())?;
+            v.write_to_with_cached_sizes(os)?;
+        };
+        for v in &self.copyright {
+            os.write_tag(71, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_raw_varint32(v.get_cached_size())?;
+            v.write_to_with_cached_sizes(os)?;
+        };
+        for v in &self.restriction {
+            os.write_tag(72, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_raw_varint32(v.get_cached_size())?;
+            v.write_to_with_cached_sizes(os)?;
+        };
+        for v in &self.keyword {
+            os.write_string(73, &v)?;
+        };
+        if let Some(v) = self.media_type {
+            os.write_enum(74, v.value())?;
+        }
+        if let Some(v) = self.consumption_order {
+            os.write_enum(75, v.value())?;
+        }
+        if let Some(v) = self.interpret_restriction_using_geoip {
+            os.write_bool(76, v)?;
+        }
+        for v in &self.availability {
+            os.write_tag(78, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_raw_varint32(v.get_cached_size())?;
+            v.write_to_with_cached_sizes(os)?;
+        };
+        if let Some(ref v) = self.country_of_origin.as_ref() {
+            os.write_string(79, &v)?;
+        }
+        for v in &self.categories {
+            os.write_tag(80, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_raw_varint32(v.get_cached_size())?;
+            v.write_to_with_cached_sizes(os)?;
+        };
+        if let Some(v) = self.passthrough {
+            os.write_enum(81, v.value())?;
+        }
+        os.write_unknown_fields(self.get_unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn get_cached_size(&self) -> u32 {
+        self.cached_size.get()
+    }
+
+    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+        &self.unknown_fields
+    }
+
+    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+        &mut self.unknown_fields
+    }
+
+    fn as_any(&self) -> &dyn (::std::any::Any) {
+        self as &dyn (::std::any::Any)
+    }
+    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
+        self as &mut dyn (::std::any::Any)
+    }
+    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+        self
+    }
+
+    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+        Self::descriptor_static()
+    }
+
+    fn new() -> Show {
+        Show::new()
+    }
+
+    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
+            lock: ::protobuf::lazy::ONCE_INIT,
+            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
+        };
+        unsafe {
+            descriptor.get(|| {
+                let mut fields = ::std::vec::Vec::new();
+                fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
+                    "gid",
+                    |m: &Show| { &m.gid },
+                    |m: &mut Show| { &mut m.gid },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+                    "name",
+                    |m: &Show| { &m.name },
+                    |m: &mut Show| { &mut m.name },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+                    "description",
+                    |m: &Show| { &m.description },
+                    |m: &mut Show| { &mut m.description },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeSint32>(
+                    "deprecated_popularity",
+                    |m: &Show| { &m.deprecated_popularity },
+                    |m: &mut Show| { &mut m.deprecated_popularity },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+                    "publisher",
+                    |m: &Show| { &m.publisher },
+                    |m: &mut Show| { &mut m.publisher },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+                    "language",
+                    |m: &Show| { &m.language },
+                    |m: &mut Show| { &mut m.language },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+                    "explicit",
+                    |m: &Show| { &m.explicit },
+                    |m: &mut Show| { &mut m.explicit },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ImageGroup>>(
+                    "covers",
+                    |m: &Show| { &m.covers },
+                    |m: &mut Show| { &mut m.covers },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Episode>>(
+                    "episode",
+                    |m: &Show| { &m.episode },
+                    |m: &mut Show| { &mut m.episode },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Copyright>>(
+                    "copyright",
+                    |m: &Show| { &m.copyright },
+                    |m: &mut Show| { &mut m.copyright },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Restriction>>(
+                    "restriction",
+                    |m: &Show| { &m.restriction },
+                    |m: &mut Show| { &mut m.restriction },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+                    "keyword",
+                    |m: &Show| { &m.keyword },
+                    |m: &mut Show| { &mut m.keyword },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<Show_MediaType>>(
+                    "media_type",
+                    |m: &Show| { &m.media_type },
+                    |m: &mut Show| { &mut m.media_type },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<Show_ConsumptionOrder>>(
+                    "consumption_order",
+                    |m: &Show| { &m.consumption_order },
+                    |m: &mut Show| { &mut m.consumption_order },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+                    "interpret_restriction_using_geoip",
+                    |m: &Show| { &m.interpret_restriction_using_geoip },
+                    |m: &mut Show| { &mut m.interpret_restriction_using_geoip },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Availability>>(
+                    "availability",
+                    |m: &Show| { &m.availability },
+                    |m: &mut Show| { &mut m.availability },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+                    "country_of_origin",
+                    |m: &Show| { &m.country_of_origin },
+                    |m: &mut Show| { &mut m.country_of_origin },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Category>>(
+                    "categories",
+                    |m: &Show| { &m.categories },
+                    |m: &mut Show| { &mut m.categories },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<Show_PassthroughEnum>>(
+                    "passthrough",
+                    |m: &Show| { &m.passthrough },
+                    |m: &mut Show| { &mut m.passthrough },
+                ));
+                ::protobuf::reflect::MessageDescriptor::new::<Show>(
+                    "Show",
+                    fields,
+                    file_descriptor_proto()
+                )
+            })
+        }
+    }
+
+    fn default_instance() -> &'static Show {
+        static mut instance: ::protobuf::lazy::Lazy<Show> = ::protobuf::lazy::Lazy {
+            lock: ::protobuf::lazy::ONCE_INIT,
+            ptr: 0 as *const Show,
+        };
+        unsafe {
+            instance.get(Show::new)
+        }
+    }
+}
+
+impl ::protobuf::Clear for Show {
+    fn clear(&mut self) {
+        self.gid.clear();
+        self.name.clear();
+        self.description.clear();
+        self.deprecated_popularity = ::std::option::Option::None;
+        self.publisher.clear();
+        self.language.clear();
+        self.explicit = ::std::option::Option::None;
+        self.covers.clear();
+        self.episode.clear();
+        self.copyright.clear();
+        self.restriction.clear();
+        self.keyword.clear();
+        self.media_type = ::std::option::Option::None;
+        self.consumption_order = ::std::option::Option::None;
+        self.interpret_restriction_using_geoip = ::std::option::Option::None;
+        self.availability.clear();
+        self.country_of_origin.clear();
+        self.categories.clear();
+        self.passthrough = ::std::option::Option::None;
+        self.unknown_fields.clear();
+    }
+}
+
+impl ::std::fmt::Debug for Show {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        ::protobuf::text_format::fmt(self, f)
+    }
+}
+
+impl ::protobuf::reflect::ProtobufValue for Show {
+    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
+        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    }
+}
+
+#[derive(Clone,PartialEq,Eq,Debug,Hash)]
+pub enum Show_MediaType {
+    MIXED = 0,
+    AUDIO = 1,
+    VIDEO = 2,
+}
+
+impl ::protobuf::ProtobufEnum for Show_MediaType {
+    fn value(&self) -> i32 {
+        *self as i32
+    }
+
+    fn from_i32(value: i32) -> ::std::option::Option<Show_MediaType> {
+        match value {
+            0 => ::std::option::Option::Some(Show_MediaType::MIXED),
+            1 => ::std::option::Option::Some(Show_MediaType::AUDIO),
+            2 => ::std::option::Option::Some(Show_MediaType::VIDEO),
+            _ => ::std::option::Option::None
+        }
+    }
+
+    fn values() -> &'static [Self] {
+        static values: &'static [Show_MediaType] = &[
+            Show_MediaType::MIXED,
+            Show_MediaType::AUDIO,
+            Show_MediaType::VIDEO,
+        ];
+        values
+    }
+
+    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
+            lock: ::protobuf::lazy::ONCE_INIT,
+            ptr: 0 as *const ::protobuf::reflect::EnumDescriptor,
+        };
+        unsafe {
+            descriptor.get(|| {
+                ::protobuf::reflect::EnumDescriptor::new("Show_MediaType", file_descriptor_proto())
+            })
+        }
+    }
+}
+
+impl ::std::marker::Copy for Show_MediaType {
+}
+
+impl ::std::default::Default for Show_MediaType {
+    fn default() -> Self {
+        Show_MediaType::MIXED
+    }
+}
+
+impl ::protobuf::reflect::ProtobufValue for Show_MediaType {
+    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
+        ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor())
+    }
+}
+
+#[derive(Clone,PartialEq,Eq,Debug,Hash)]
+pub enum Show_ConsumptionOrder {
+    SEQUENTIAL = 1,
+    EPISODIC = 2,
+    RECENT = 3,
+}
+
+impl ::protobuf::ProtobufEnum for Show_ConsumptionOrder {
+    fn value(&self) -> i32 {
+        *self as i32
+    }
+
+    fn from_i32(value: i32) -> ::std::option::Option<Show_ConsumptionOrder> {
+        match value {
+            1 => ::std::option::Option::Some(Show_ConsumptionOrder::SEQUENTIAL),
+            2 => ::std::option::Option::Some(Show_ConsumptionOrder::EPISODIC),
+            3 => ::std::option::Option::Some(Show_ConsumptionOrder::RECENT),
+            _ => ::std::option::Option::None
+        }
+    }
+
+    fn values() -> &'static [Self] {
+        static values: &'static [Show_ConsumptionOrder] = &[
+            Show_ConsumptionOrder::SEQUENTIAL,
+            Show_ConsumptionOrder::EPISODIC,
+            Show_ConsumptionOrder::RECENT,
+        ];
+        values
+    }
+
+    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
+            lock: ::protobuf::lazy::ONCE_INIT,
+            ptr: 0 as *const ::protobuf::reflect::EnumDescriptor,
+        };
+        unsafe {
+            descriptor.get(|| {
+                ::protobuf::reflect::EnumDescriptor::new("Show_ConsumptionOrder", file_descriptor_proto())
+            })
+        }
+    }
+}
+
+impl ::std::marker::Copy for Show_ConsumptionOrder {
+}
+
+// Note, `Default` is implemented although default value is not 0
+impl ::std::default::Default for Show_ConsumptionOrder {
+    fn default() -> Self {
+        Show_ConsumptionOrder::SEQUENTIAL
+    }
+}
+
+impl ::protobuf::reflect::ProtobufValue for Show_ConsumptionOrder {
+    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
+        ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor())
+    }
+}
+
+#[derive(Clone,PartialEq,Eq,Debug,Hash)]
+pub enum Show_PassthroughEnum {
+    UNKNOWN = 0,
+    NONE = 1,
+    ALLOWED = 2,
+}
+
+impl ::protobuf::ProtobufEnum for Show_PassthroughEnum {
+    fn value(&self) -> i32 {
+        *self as i32
+    }
+
+    fn from_i32(value: i32) -> ::std::option::Option<Show_PassthroughEnum> {
+        match value {
+            0 => ::std::option::Option::Some(Show_PassthroughEnum::UNKNOWN),
+            1 => ::std::option::Option::Some(Show_PassthroughEnum::NONE),
+            2 => ::std::option::Option::Some(Show_PassthroughEnum::ALLOWED),
+            _ => ::std::option::Option::None
+        }
+    }
+
+    fn values() -> &'static [Self] {
+        static values: &'static [Show_PassthroughEnum] = &[
+            Show_PassthroughEnum::UNKNOWN,
+            Show_PassthroughEnum::NONE,
+            Show_PassthroughEnum::ALLOWED,
+        ];
+        values
+    }
+
+    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
+            lock: ::protobuf::lazy::ONCE_INIT,
+            ptr: 0 as *const ::protobuf::reflect::EnumDescriptor,
+        };
+        unsafe {
+            descriptor.get(|| {
+                ::protobuf::reflect::EnumDescriptor::new("Show_PassthroughEnum", file_descriptor_proto())
+            })
+        }
+    }
+}
+
+impl ::std::marker::Copy for Show_PassthroughEnum {
+}
+
+impl ::std::default::Default for Show_PassthroughEnum {
+    fn default() -> Self {
+        Show_PassthroughEnum::UNKNOWN
+    }
+}
+
+impl ::protobuf::reflect::ProtobufValue for Show_PassthroughEnum {
+    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
+        ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor())
+    }
+}
+
+#[derive(PartialEq,Clone,Default)]
+pub struct Episode {
+    // message fields
+    gid: ::protobuf::SingularField<::std::vec::Vec<u8>>,
+    name: ::protobuf::SingularField<::std::string::String>,
+    duration: ::std::option::Option<i32>,
+    popularity: ::std::option::Option<i32>,
+    file: ::protobuf::RepeatedField<AudioFile>,
+    description: ::protobuf::SingularField<::std::string::String>,
+    number: ::std::option::Option<i32>,
+    publish_time: ::protobuf::SingularPtrField<Date>,
+    deprecated_popularity: ::std::option::Option<i32>,
+    covers: ::protobuf::SingularPtrField<ImageGroup>,
+    language: ::protobuf::SingularField<::std::string::String>,
+    explicit: ::std::option::Option<bool>,
+    show: ::protobuf::SingularPtrField<Show>,
+    video: ::protobuf::RepeatedField<VideoFile>,
+    video_preview: ::protobuf::RepeatedField<VideoFile>,
+    audio_preview: ::protobuf::RepeatedField<AudioFile>,
+    restriction: ::protobuf::RepeatedField<Restriction>,
+    freeze_frame: ::protobuf::SingularPtrField<ImageGroup>,
+    keyword: ::protobuf::RepeatedField<::std::string::String>,
+    suppress_monetization: ::std::option::Option<bool>,
+    interpret_restriction_using_geoip: ::std::option::Option<bool>,
+    allow_background_playback: ::std::option::Option<bool>,
+    availability: ::protobuf::RepeatedField<Availability>,
+    external_url: ::protobuf::SingularField<::std::string::String>,
+    original_audio: ::protobuf::SingularPtrField<OriginalAudio>,
+    // special fields
+    pub unknown_fields: ::protobuf::UnknownFields,
+    pub cached_size: ::protobuf::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a Episode {
+    fn default() -> &'a Episode {
+        <Episode as ::protobuf::Message>::default_instance()
+    }
+}
+
+impl Episode {
+    pub fn new() -> Episode {
+        ::std::default::Default::default()
+    }
+
+    // optional bytes gid = 1;
+
+
+    pub fn get_gid(&self) -> &[u8] {
+        match self.gid.as_ref() {
+            Some(v) => &v,
+            None => &[],
+        }
+    }
+    pub fn clear_gid(&mut self) {
+        self.gid.clear();
+    }
+
+    pub fn has_gid(&self) -> bool {
+        self.gid.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_gid(&mut self, v: ::std::vec::Vec<u8>) {
+        self.gid = ::protobuf::SingularField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_gid(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.gid.is_none() {
+            self.gid.set_default();
+        }
+        self.gid.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_gid(&mut self) -> ::std::vec::Vec<u8> {
+        self.gid.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+
+    // optional string name = 2;
+
+
+    pub fn get_name(&self) -> &str {
+        match self.name.as_ref() {
+            Some(v) => &v,
+            None => "",
+        }
+    }
+    pub fn clear_name(&mut self) {
+        self.name.clear();
+    }
+
+    pub fn has_name(&self) -> bool {
+        self.name.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_name(&mut self, v: ::std::string::String) {
+        self.name = ::protobuf::SingularField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_name(&mut self) -> &mut ::std::string::String {
+        if self.name.is_none() {
+            self.name.set_default();
+        }
+        self.name.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_name(&mut self) -> ::std::string::String {
+        self.name.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+
+    // optional sint32 duration = 7;
+
+
+    pub fn get_duration(&self) -> i32 {
+        self.duration.unwrap_or(0)
+    }
+    pub fn clear_duration(&mut self) {
+        self.duration = ::std::option::Option::None;
+    }
+
+    pub fn has_duration(&self) -> bool {
+        self.duration.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_duration(&mut self, v: i32) {
+        self.duration = ::std::option::Option::Some(v);
+    }
+
+    // optional sint32 popularity = 8;
+
+
+    pub fn get_popularity(&self) -> i32 {
+        self.popularity.unwrap_or(0)
+    }
+    pub fn clear_popularity(&mut self) {
+        self.popularity = ::std::option::Option::None;
+    }
+
+    pub fn has_popularity(&self) -> bool {
+        self.popularity.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_popularity(&mut self, v: i32) {
+        self.popularity = ::std::option::Option::Some(v);
+    }
+
+    // repeated .AudioFile file = 12;
+
+
+    pub fn get_file(&self) -> &[AudioFile] {
+        &self.file
+    }
+    pub fn clear_file(&mut self) {
+        self.file.clear();
+    }
+
+    // Param is passed by value, moved
+    pub fn set_file(&mut self, v: ::protobuf::RepeatedField<AudioFile>) {
+        self.file = v;
+    }
+
+    // Mutable pointer to the field.
+    pub fn mut_file(&mut self) -> &mut ::protobuf::RepeatedField<AudioFile> {
+        &mut self.file
+    }
+
+    // Take field
+    pub fn take_file(&mut self) -> ::protobuf::RepeatedField<AudioFile> {
+        ::std::mem::replace(&mut self.file, ::protobuf::RepeatedField::new())
+    }
+
+    // optional string description = 64;
+
+
+    pub fn get_description(&self) -> &str {
+        match self.description.as_ref() {
+            Some(v) => &v,
+            None => "",
+        }
+    }
+    pub fn clear_description(&mut self) {
+        self.description.clear();
+    }
+
+    pub fn has_description(&self) -> bool {
+        self.description.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_description(&mut self, v: ::std::string::String) {
+        self.description = ::protobuf::SingularField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_description(&mut self) -> &mut ::std::string::String {
+        if self.description.is_none() {
+            self.description.set_default();
+        }
+        self.description.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_description(&mut self) -> ::std::string::String {
+        self.description.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+
+    // optional sint32 number = 65;
+
+
+    pub fn get_number(&self) -> i32 {
+        self.number.unwrap_or(0)
+    }
+    pub fn clear_number(&mut self) {
+        self.number = ::std::option::Option::None;
+    }
+
+    pub fn has_number(&self) -> bool {
+        self.number.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_number(&mut self, v: i32) {
+        self.number = ::std::option::Option::Some(v);
+    }
+
+    // optional .Date publish_time = 66;
+
+
+    pub fn get_publish_time(&self) -> &Date {
+        self.publish_time.as_ref().unwrap_or_else(|| Date::default_instance())
+    }
+    pub fn clear_publish_time(&mut self) {
+        self.publish_time.clear();
+    }
+
+    pub fn has_publish_time(&self) -> bool {
+        self.publish_time.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_publish_time(&mut self, v: Date) {
+        self.publish_time = ::protobuf::SingularPtrField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_publish_time(&mut self) -> &mut Date {
+        if self.publish_time.is_none() {
+            self.publish_time.set_default();
+        }
+        self.publish_time.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_publish_time(&mut self) -> Date {
+        self.publish_time.take().unwrap_or_else(|| Date::new())
+    }
+
+    // optional sint32 deprecated_popularity = 67;
+
+
+    pub fn get_deprecated_popularity(&self) -> i32 {
+        self.deprecated_popularity.unwrap_or(0)
+    }
+    pub fn clear_deprecated_popularity(&mut self) {
+        self.deprecated_popularity = ::std::option::Option::None;
+    }
+
+    pub fn has_deprecated_popularity(&self) -> bool {
+        self.deprecated_popularity.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_deprecated_popularity(&mut self, v: i32) {
+        self.deprecated_popularity = ::std::option::Option::Some(v);
+    }
+
+    // optional .ImageGroup covers = 68;
+
+
+    pub fn get_covers(&self) -> &ImageGroup {
+        self.covers.as_ref().unwrap_or_else(|| ImageGroup::default_instance())
+    }
+    pub fn clear_covers(&mut self) {
+        self.covers.clear();
+    }
+
+    pub fn has_covers(&self) -> bool {
+        self.covers.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_covers(&mut self, v: ImageGroup) {
+        self.covers = ::protobuf::SingularPtrField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_covers(&mut self) -> &mut ImageGroup {
+        if self.covers.is_none() {
+            self.covers.set_default();
+        }
+        self.covers.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_covers(&mut self) -> ImageGroup {
+        self.covers.take().unwrap_or_else(|| ImageGroup::new())
+    }
+
+    // optional string language = 69;
+
+
+    pub fn get_language(&self) -> &str {
+        match self.language.as_ref() {
+            Some(v) => &v,
+            None => "",
+        }
+    }
+    pub fn clear_language(&mut self) {
+        self.language.clear();
+    }
+
+    pub fn has_language(&self) -> bool {
+        self.language.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_language(&mut self, v: ::std::string::String) {
+        self.language = ::protobuf::SingularField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_language(&mut self) -> &mut ::std::string::String {
+        if self.language.is_none() {
+            self.language.set_default();
+        }
+        self.language.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_language(&mut self) -> ::std::string::String {
+        self.language.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+
+    // optional bool explicit = 70;
+
+
+    pub fn get_explicit(&self) -> bool {
+        self.explicit.unwrap_or(false)
+    }
+    pub fn clear_explicit(&mut self) {
+        self.explicit = ::std::option::Option::None;
+    }
+
+    pub fn has_explicit(&self) -> bool {
+        self.explicit.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_explicit(&mut self, v: bool) {
+        self.explicit = ::std::option::Option::Some(v);
+    }
+
+    // optional .Show show = 71;
+
+
+    pub fn get_show(&self) -> &Show {
+        self.show.as_ref().unwrap_or_else(|| Show::default_instance())
+    }
+    pub fn clear_show(&mut self) {
+        self.show.clear();
+    }
+
+    pub fn has_show(&self) -> bool {
+        self.show.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_show(&mut self, v: Show) {
+        self.show = ::protobuf::SingularPtrField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_show(&mut self) -> &mut Show {
+        if self.show.is_none() {
+            self.show.set_default();
+        }
+        self.show.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_show(&mut self) -> Show {
+        self.show.take().unwrap_or_else(|| Show::new())
+    }
+
+    // repeated .VideoFile video = 72;
+
+
+    pub fn get_video(&self) -> &[VideoFile] {
+        &self.video
+    }
+    pub fn clear_video(&mut self) {
+        self.video.clear();
+    }
+
+    // Param is passed by value, moved
+    pub fn set_video(&mut self, v: ::protobuf::RepeatedField<VideoFile>) {
+        self.video = v;
+    }
+
+    // Mutable pointer to the field.
+    pub fn mut_video(&mut self) -> &mut ::protobuf::RepeatedField<VideoFile> {
+        &mut self.video
+    }
+
+    // Take field
+    pub fn take_video(&mut self) -> ::protobuf::RepeatedField<VideoFile> {
+        ::std::mem::replace(&mut self.video, ::protobuf::RepeatedField::new())
+    }
+
+    // repeated .VideoFile video_preview = 73;
+
+
+    pub fn get_video_preview(&self) -> &[VideoFile] {
+        &self.video_preview
+    }
+    pub fn clear_video_preview(&mut self) {
+        self.video_preview.clear();
+    }
+
+    // Param is passed by value, moved
+    pub fn set_video_preview(&mut self, v: ::protobuf::RepeatedField<VideoFile>) {
+        self.video_preview = v;
+    }
+
+    // Mutable pointer to the field.
+    pub fn mut_video_preview(&mut self) -> &mut ::protobuf::RepeatedField<VideoFile> {
+        &mut self.video_preview
+    }
+
+    // Take field
+    pub fn take_video_preview(&mut self) -> ::protobuf::RepeatedField<VideoFile> {
+        ::std::mem::replace(&mut self.video_preview, ::protobuf::RepeatedField::new())
+    }
+
+    // repeated .AudioFile audio_preview = 74;
+
+
+    pub fn get_audio_preview(&self) -> &[AudioFile] {
+        &self.audio_preview
+    }
+    pub fn clear_audio_preview(&mut self) {
+        self.audio_preview.clear();
+    }
+
+    // Param is passed by value, moved
+    pub fn set_audio_preview(&mut self, v: ::protobuf::RepeatedField<AudioFile>) {
+        self.audio_preview = v;
+    }
+
+    // Mutable pointer to the field.
+    pub fn mut_audio_preview(&mut self) -> &mut ::protobuf::RepeatedField<AudioFile> {
+        &mut self.audio_preview
+    }
+
+    // Take field
+    pub fn take_audio_preview(&mut self) -> ::protobuf::RepeatedField<AudioFile> {
+        ::std::mem::replace(&mut self.audio_preview, ::protobuf::RepeatedField::new())
+    }
+
+    // repeated .Restriction restriction = 75;
+
+
+    pub fn get_restriction(&self) -> &[Restriction] {
+        &self.restriction
+    }
+    pub fn clear_restriction(&mut self) {
+        self.restriction.clear();
+    }
+
+    // Param is passed by value, moved
+    pub fn set_restriction(&mut self, v: ::protobuf::RepeatedField<Restriction>) {
+        self.restriction = v;
+    }
+
+    // Mutable pointer to the field.
+    pub fn mut_restriction(&mut self) -> &mut ::protobuf::RepeatedField<Restriction> {
+        &mut self.restriction
+    }
+
+    // Take field
+    pub fn take_restriction(&mut self) -> ::protobuf::RepeatedField<Restriction> {
+        ::std::mem::replace(&mut self.restriction, ::protobuf::RepeatedField::new())
+    }
+
+    // optional .ImageGroup freeze_frame = 76;
+
+
+    pub fn get_freeze_frame(&self) -> &ImageGroup {
+        self.freeze_frame.as_ref().unwrap_or_else(|| ImageGroup::default_instance())
+    }
+    pub fn clear_freeze_frame(&mut self) {
+        self.freeze_frame.clear();
+    }
+
+    pub fn has_freeze_frame(&self) -> bool {
+        self.freeze_frame.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_freeze_frame(&mut self, v: ImageGroup) {
+        self.freeze_frame = ::protobuf::SingularPtrField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_freeze_frame(&mut self) -> &mut ImageGroup {
+        if self.freeze_frame.is_none() {
+            self.freeze_frame.set_default();
+        }
+        self.freeze_frame.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_freeze_frame(&mut self) -> ImageGroup {
+        self.freeze_frame.take().unwrap_or_else(|| ImageGroup::new())
+    }
+
+    // repeated string keyword = 77;
+
+
+    pub fn get_keyword(&self) -> &[::std::string::String] {
+        &self.keyword
+    }
+    pub fn clear_keyword(&mut self) {
+        self.keyword.clear();
+    }
+
+    // Param is passed by value, moved
+    pub fn set_keyword(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
+        self.keyword = v;
+    }
+
+    // Mutable pointer to the field.
+    pub fn mut_keyword(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
+        &mut self.keyword
+    }
+
+    // Take field
+    pub fn take_keyword(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
+        ::std::mem::replace(&mut self.keyword, ::protobuf::RepeatedField::new())
+    }
+
+    // optional bool suppress_monetization = 78;
+
+
+    pub fn get_suppress_monetization(&self) -> bool {
+        self.suppress_monetization.unwrap_or(false)
+    }
+    pub fn clear_suppress_monetization(&mut self) {
+        self.suppress_monetization = ::std::option::Option::None;
+    }
+
+    pub fn has_suppress_monetization(&self) -> bool {
+        self.suppress_monetization.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_suppress_monetization(&mut self, v: bool) {
+        self.suppress_monetization = ::std::option::Option::Some(v);
+    }
+
+    // optional bool interpret_restriction_using_geoip = 79;
+
+
+    pub fn get_interpret_restriction_using_geoip(&self) -> bool {
+        self.interpret_restriction_using_geoip.unwrap_or(false)
+    }
+    pub fn clear_interpret_restriction_using_geoip(&mut self) {
+        self.interpret_restriction_using_geoip = ::std::option::Option::None;
+    }
+
+    pub fn has_interpret_restriction_using_geoip(&self) -> bool {
+        self.interpret_restriction_using_geoip.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_interpret_restriction_using_geoip(&mut self, v: bool) {
+        self.interpret_restriction_using_geoip = ::std::option::Option::Some(v);
+    }
+
+    // optional bool allow_background_playback = 81;
+
+
+    pub fn get_allow_background_playback(&self) -> bool {
+        self.allow_background_playback.unwrap_or(false)
+    }
+    pub fn clear_allow_background_playback(&mut self) {
+        self.allow_background_playback = ::std::option::Option::None;
+    }
+
+    pub fn has_allow_background_playback(&self) -> bool {
+        self.allow_background_playback.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_allow_background_playback(&mut self, v: bool) {
+        self.allow_background_playback = ::std::option::Option::Some(v);
+    }
+
+    // repeated .Availability availability = 82;
+
+
+    pub fn get_availability(&self) -> &[Availability] {
+        &self.availability
+    }
+    pub fn clear_availability(&mut self) {
+        self.availability.clear();
+    }
+
+    // Param is passed by value, moved
+    pub fn set_availability(&mut self, v: ::protobuf::RepeatedField<Availability>) {
+        self.availability = v;
+    }
+
+    // Mutable pointer to the field.
+    pub fn mut_availability(&mut self) -> &mut ::protobuf::RepeatedField<Availability> {
+        &mut self.availability
+    }
+
+    // Take field
+    pub fn take_availability(&mut self) -> ::protobuf::RepeatedField<Availability> {
+        ::std::mem::replace(&mut self.availability, ::protobuf::RepeatedField::new())
+    }
+
+    // optional string external_url = 83;
+
+
+    pub fn get_external_url(&self) -> &str {
+        match self.external_url.as_ref() {
+            Some(v) => &v,
+            None => "",
+        }
+    }
+    pub fn clear_external_url(&mut self) {
+        self.external_url.clear();
+    }
+
+    pub fn has_external_url(&self) -> bool {
+        self.external_url.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_external_url(&mut self, v: ::std::string::String) {
+        self.external_url = ::protobuf::SingularField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_external_url(&mut self) -> &mut ::std::string::String {
+        if self.external_url.is_none() {
+            self.external_url.set_default();
+        }
+        self.external_url.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_external_url(&mut self) -> ::std::string::String {
+        self.external_url.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+
+    // optional .OriginalAudio original_audio = 84;
+
+
+    pub fn get_original_audio(&self) -> &OriginalAudio {
+        self.original_audio.as_ref().unwrap_or_else(|| OriginalAudio::default_instance())
+    }
+    pub fn clear_original_audio(&mut self) {
+        self.original_audio.clear();
+    }
+
+    pub fn has_original_audio(&self) -> bool {
+        self.original_audio.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_original_audio(&mut self, v: OriginalAudio) {
+        self.original_audio = ::protobuf::SingularPtrField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_original_audio(&mut self) -> &mut OriginalAudio {
+        if self.original_audio.is_none() {
+            self.original_audio.set_default();
+        }
+        self.original_audio.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_original_audio(&mut self) -> OriginalAudio {
+        self.original_audio.take().unwrap_or_else(|| OriginalAudio::new())
+    }
+}
+
+impl ::protobuf::Message for Episode {
+    fn is_initialized(&self) -> bool {
+        for v in &self.file {
+            if !v.is_initialized() {
+                return false;
+            }
+        };
+        for v in &self.publish_time {
+            if !v.is_initialized() {
+                return false;
+            }
+        };
+        for v in &self.covers {
+            if !v.is_initialized() {
+                return false;
+            }
+        };
+        for v in &self.show {
+            if !v.is_initialized() {
+                return false;
+            }
+        };
+        for v in &self.video {
+            if !v.is_initialized() {
+                return false;
+            }
+        };
+        for v in &self.video_preview {
+            if !v.is_initialized() {
+                return false;
+            }
+        };
+        for v in &self.audio_preview {
+            if !v.is_initialized() {
+                return false;
+            }
+        };
+        for v in &self.restriction {
+            if !v.is_initialized() {
+                return false;
+            }
+        };
+        for v in &self.freeze_frame {
+            if !v.is_initialized() {
+                return false;
+            }
+        };
+        for v in &self.availability {
+            if !v.is_initialized() {
+                return false;
+            }
+        };
+        for v in &self.original_audio {
+            if !v.is_initialized() {
+                return false;
+            }
+        };
+        true
+    }
+
+    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
+        while !is.eof()? {
+            let (field_number, wire_type) = is.read_tag_unpack()?;
+            match field_number {
+                1 => {
+                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.gid)?;
+                },
+                2 => {
+                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
+                },
+                7 => {
+                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    }
+                    let tmp = is.read_sint32()?;
+                    self.duration = ::std::option::Option::Some(tmp);
+                },
+                8 => {
+                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    }
+                    let tmp = is.read_sint32()?;
+                    self.popularity = ::std::option::Option::Some(tmp);
+                },
+                12 => {
+                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.file)?;
+                },
+                64 => {
+                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.description)?;
+                },
+                65 => {
+                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    }
+                    let tmp = is.read_sint32()?;
+                    self.number = ::std::option::Option::Some(tmp);
+                },
+                66 => {
+                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.publish_time)?;
+                },
+                67 => {
+                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    }
+                    let tmp = is.read_sint32()?;
+                    self.deprecated_popularity = ::std::option::Option::Some(tmp);
+                },
+                68 => {
+                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.covers)?;
+                },
+                69 => {
+                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.language)?;
+                },
+                70 => {
+                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    }
+                    let tmp = is.read_bool()?;
+                    self.explicit = ::std::option::Option::Some(tmp);
+                },
+                71 => {
+                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.show)?;
+                },
+                72 => {
+                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.video)?;
+                },
+                73 => {
+                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.video_preview)?;
+                },
+                74 => {
+                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.audio_preview)?;
+                },
+                75 => {
+                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.restriction)?;
+                },
+                76 => {
+                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.freeze_frame)?;
+                },
+                77 => {
+                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.keyword)?;
+                },
+                78 => {
+                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    }
+                    let tmp = is.read_bool()?;
+                    self.suppress_monetization = ::std::option::Option::Some(tmp);
+                },
+                79 => {
+                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    }
+                    let tmp = is.read_bool()?;
+                    self.interpret_restriction_using_geoip = ::std::option::Option::Some(tmp);
+                },
+                81 => {
+                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    }
+                    let tmp = is.read_bool()?;
+                    self.allow_background_playback = ::std::option::Option::Some(tmp);
+                },
+                82 => {
+                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.availability)?;
+                },
+                83 => {
+                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.external_url)?;
+                },
+                84 => {
+                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.original_audio)?;
+                },
+                _ => {
+                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                },
+            };
+        }
+        ::std::result::Result::Ok(())
+    }
+
+    // Compute sizes of nested messages
+    #[allow(unused_variables)]
+    fn compute_size(&self) -> u32 {
+        let mut my_size = 0;
+        if let Some(ref v) = self.gid.as_ref() {
+            my_size += ::protobuf::rt::bytes_size(1, &v);
+        }
+        if let Some(ref v) = self.name.as_ref() {
+            my_size += ::protobuf::rt::string_size(2, &v);
+        }
+        if let Some(v) = self.duration {
+            my_size += ::protobuf::rt::value_varint_zigzag_size(7, v);
+        }
+        if let Some(v) = self.popularity {
+            my_size += ::protobuf::rt::value_varint_zigzag_size(8, v);
+        }
+        for value in &self.file {
+            let len = value.compute_size();
+            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+        };
+        if let Some(ref v) = self.description.as_ref() {
+            my_size += ::protobuf::rt::string_size(64, &v);
+        }
+        if let Some(v) = self.number {
+            my_size += ::protobuf::rt::value_varint_zigzag_size(65, v);
+        }
+        if let Some(ref v) = self.publish_time.as_ref() {
+            let len = v.compute_size();
+            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+        }
+        if let Some(v) = self.deprecated_popularity {
+            my_size += ::protobuf::rt::value_varint_zigzag_size(67, v);
+        }
+        if let Some(ref v) = self.covers.as_ref() {
+            let len = v.compute_size();
+            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+        }
+        if let Some(ref v) = self.language.as_ref() {
+            my_size += ::protobuf::rt::string_size(69, &v);
+        }
+        if let Some(v) = self.explicit {
+            my_size += 3;
+        }
+        if let Some(ref v) = self.show.as_ref() {
+            let len = v.compute_size();
+            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+        }
+        for value in &self.video {
+            let len = value.compute_size();
+            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+        };
+        for value in &self.video_preview {
+            let len = value.compute_size();
+            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+        };
+        for value in &self.audio_preview {
+            let len = value.compute_size();
+            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+        };
+        for value in &self.restriction {
+            let len = value.compute_size();
+            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+        };
+        if let Some(ref v) = self.freeze_frame.as_ref() {
+            let len = v.compute_size();
+            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+        }
+        for value in &self.keyword {
+            my_size += ::protobuf::rt::string_size(77, &value);
+        };
+        if let Some(v) = self.suppress_monetization {
+            my_size += 3;
+        }
+        if let Some(v) = self.interpret_restriction_using_geoip {
+            my_size += 3;
+        }
+        if let Some(v) = self.allow_background_playback {
+            my_size += 3;
+        }
+        for value in &self.availability {
+            let len = value.compute_size();
+            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+        };
+        if let Some(ref v) = self.external_url.as_ref() {
+            my_size += ::protobuf::rt::string_size(83, &v);
+        }
+        if let Some(ref v) = self.original_audio.as_ref() {
+            let len = v.compute_size();
+            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+        }
+        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        self.cached_size.set(my_size);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
+        if let Some(ref v) = self.gid.as_ref() {
+            os.write_bytes(1, &v)?;
+        }
+        if let Some(ref v) = self.name.as_ref() {
+            os.write_string(2, &v)?;
+        }
+        if let Some(v) = self.duration {
+            os.write_sint32(7, v)?;
+        }
+        if let Some(v) = self.popularity {
+            os.write_sint32(8, v)?;
+        }
+        for v in &self.file {
+            os.write_tag(12, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_raw_varint32(v.get_cached_size())?;
+            v.write_to_with_cached_sizes(os)?;
+        };
+        if let Some(ref v) = self.description.as_ref() {
+            os.write_string(64, &v)?;
+        }
+        if let Some(v) = self.number {
+            os.write_sint32(65, v)?;
+        }
+        if let Some(ref v) = self.publish_time.as_ref() {
+            os.write_tag(66, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_raw_varint32(v.get_cached_size())?;
+            v.write_to_with_cached_sizes(os)?;
+        }
+        if let Some(v) = self.deprecated_popularity {
+            os.write_sint32(67, v)?;
+        }
+        if let Some(ref v) = self.covers.as_ref() {
+            os.write_tag(68, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_raw_varint32(v.get_cached_size())?;
+            v.write_to_with_cached_sizes(os)?;
+        }
+        if let Some(ref v) = self.language.as_ref() {
+            os.write_string(69, &v)?;
+        }
+        if let Some(v) = self.explicit {
+            os.write_bool(70, v)?;
+        }
+        if let Some(ref v) = self.show.as_ref() {
+            os.write_tag(71, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_raw_varint32(v.get_cached_size())?;
+            v.write_to_with_cached_sizes(os)?;
+        }
+        for v in &self.video {
+            os.write_tag(72, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_raw_varint32(v.get_cached_size())?;
+            v.write_to_with_cached_sizes(os)?;
+        };
+        for v in &self.video_preview {
+            os.write_tag(73, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_raw_varint32(v.get_cached_size())?;
+            v.write_to_with_cached_sizes(os)?;
+        };
+        for v in &self.audio_preview {
+            os.write_tag(74, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_raw_varint32(v.get_cached_size())?;
+            v.write_to_with_cached_sizes(os)?;
+        };
+        for v in &self.restriction {
+            os.write_tag(75, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_raw_varint32(v.get_cached_size())?;
+            v.write_to_with_cached_sizes(os)?;
+        };
+        if let Some(ref v) = self.freeze_frame.as_ref() {
+            os.write_tag(76, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_raw_varint32(v.get_cached_size())?;
+            v.write_to_with_cached_sizes(os)?;
+        }
+        for v in &self.keyword {
+            os.write_string(77, &v)?;
+        };
+        if let Some(v) = self.suppress_monetization {
+            os.write_bool(78, v)?;
+        }
+        if let Some(v) = self.interpret_restriction_using_geoip {
+            os.write_bool(79, v)?;
+        }
+        if let Some(v) = self.allow_background_playback {
+            os.write_bool(81, v)?;
+        }
+        for v in &self.availability {
+            os.write_tag(82, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_raw_varint32(v.get_cached_size())?;
+            v.write_to_with_cached_sizes(os)?;
+        };
+        if let Some(ref v) = self.external_url.as_ref() {
+            os.write_string(83, &v)?;
+        }
+        if let Some(ref v) = self.original_audio.as_ref() {
+            os.write_tag(84, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_raw_varint32(v.get_cached_size())?;
+            v.write_to_with_cached_sizes(os)?;
+        }
+        os.write_unknown_fields(self.get_unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn get_cached_size(&self) -> u32 {
+        self.cached_size.get()
+    }
+
+    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+        &self.unknown_fields
+    }
+
+    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+        &mut self.unknown_fields
+    }
+
+    fn as_any(&self) -> &dyn (::std::any::Any) {
+        self as &dyn (::std::any::Any)
+    }
+    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
+        self as &mut dyn (::std::any::Any)
+    }
+    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+        self
+    }
+
+    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+        Self::descriptor_static()
+    }
+
+    fn new() -> Episode {
+        Episode::new()
+    }
+
+    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
+            lock: ::protobuf::lazy::ONCE_INIT,
+            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
+        };
+        unsafe {
+            descriptor.get(|| {
+                let mut fields = ::std::vec::Vec::new();
+                fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
+                    "gid",
+                    |m: &Episode| { &m.gid },
+                    |m: &mut Episode| { &mut m.gid },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+                    "name",
+                    |m: &Episode| { &m.name },
+                    |m: &mut Episode| { &mut m.name },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeSint32>(
+                    "duration",
+                    |m: &Episode| { &m.duration },
+                    |m: &mut Episode| { &mut m.duration },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeSint32>(
+                    "popularity",
+                    |m: &Episode| { &m.popularity },
+                    |m: &mut Episode| { &mut m.popularity },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<AudioFile>>(
+                    "file",
+                    |m: &Episode| { &m.file },
+                    |m: &mut Episode| { &mut m.file },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+                    "description",
+                    |m: &Episode| { &m.description },
+                    |m: &mut Episode| { &mut m.description },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeSint32>(
+                    "number",
+                    |m: &Episode| { &m.number },
+                    |m: &mut Episode| { &mut m.number },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Date>>(
+                    "publish_time",
+                    |m: &Episode| { &m.publish_time },
+                    |m: &mut Episode| { &mut m.publish_time },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeSint32>(
+                    "deprecated_popularity",
+                    |m: &Episode| { &m.deprecated_popularity },
+                    |m: &mut Episode| { &mut m.deprecated_popularity },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ImageGroup>>(
+                    "covers",
+                    |m: &Episode| { &m.covers },
+                    |m: &mut Episode| { &mut m.covers },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+                    "language",
+                    |m: &Episode| { &m.language },
+                    |m: &mut Episode| { &mut m.language },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+                    "explicit",
+                    |m: &Episode| { &m.explicit },
+                    |m: &mut Episode| { &mut m.explicit },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Show>>(
+                    "show",
+                    |m: &Episode| { &m.show },
+                    |m: &mut Episode| { &mut m.show },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<VideoFile>>(
+                    "video",
+                    |m: &Episode| { &m.video },
+                    |m: &mut Episode| { &mut m.video },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<VideoFile>>(
+                    "video_preview",
+                    |m: &Episode| { &m.video_preview },
+                    |m: &mut Episode| { &mut m.video_preview },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<AudioFile>>(
+                    "audio_preview",
+                    |m: &Episode| { &m.audio_preview },
+                    |m: &mut Episode| { &mut m.audio_preview },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Restriction>>(
+                    "restriction",
+                    |m: &Episode| { &m.restriction },
+                    |m: &mut Episode| { &mut m.restriction },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ImageGroup>>(
+                    "freeze_frame",
+                    |m: &Episode| { &m.freeze_frame },
+                    |m: &mut Episode| { &mut m.freeze_frame },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+                    "keyword",
+                    |m: &Episode| { &m.keyword },
+                    |m: &mut Episode| { &mut m.keyword },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+                    "suppress_monetization",
+                    |m: &Episode| { &m.suppress_monetization },
+                    |m: &mut Episode| { &mut m.suppress_monetization },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+                    "interpret_restriction_using_geoip",
+                    |m: &Episode| { &m.interpret_restriction_using_geoip },
+                    |m: &mut Episode| { &mut m.interpret_restriction_using_geoip },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+                    "allow_background_playback",
+                    |m: &Episode| { &m.allow_background_playback },
+                    |m: &mut Episode| { &mut m.allow_background_playback },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Availability>>(
+                    "availability",
+                    |m: &Episode| { &m.availability },
+                    |m: &mut Episode| { &mut m.availability },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+                    "external_url",
+                    |m: &Episode| { &m.external_url },
+                    |m: &mut Episode| { &mut m.external_url },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<OriginalAudio>>(
+                    "original_audio",
+                    |m: &Episode| { &m.original_audio },
+                    |m: &mut Episode| { &mut m.original_audio },
+                ));
+                ::protobuf::reflect::MessageDescriptor::new::<Episode>(
+                    "Episode",
+                    fields,
+                    file_descriptor_proto()
+                )
+            })
+        }
+    }
+
+    fn default_instance() -> &'static Episode {
+        static mut instance: ::protobuf::lazy::Lazy<Episode> = ::protobuf::lazy::Lazy {
+            lock: ::protobuf::lazy::ONCE_INIT,
+            ptr: 0 as *const Episode,
+        };
+        unsafe {
+            instance.get(Episode::new)
+        }
+    }
+}
+
+impl ::protobuf::Clear for Episode {
+    fn clear(&mut self) {
+        self.gid.clear();
+        self.name.clear();
+        self.duration = ::std::option::Option::None;
+        self.popularity = ::std::option::Option::None;
+        self.file.clear();
+        self.description.clear();
+        self.number = ::std::option::Option::None;
+        self.publish_time.clear();
+        self.deprecated_popularity = ::std::option::Option::None;
+        self.covers.clear();
+        self.language.clear();
+        self.explicit = ::std::option::Option::None;
+        self.show.clear();
+        self.video.clear();
+        self.video_preview.clear();
+        self.audio_preview.clear();
+        self.restriction.clear();
+        self.freeze_frame.clear();
+        self.keyword.clear();
+        self.suppress_monetization = ::std::option::Option::None;
+        self.interpret_restriction_using_geoip = ::std::option::Option::None;
+        self.allow_background_playback = ::std::option::Option::None;
+        self.availability.clear();
+        self.external_url.clear();
+        self.original_audio.clear();
+        self.unknown_fields.clear();
+    }
+}
+
+impl ::std::fmt::Debug for Episode {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        ::protobuf::text_format::fmt(self, f)
+    }
+}
+
+impl ::protobuf::reflect::ProtobufValue for Episode {
+    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
+        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    }
+}
+
+#[derive(PartialEq,Clone,Default)]
+pub struct Category {
+    // message fields
+    name: ::protobuf::SingularField<::std::string::String>,
+    subcategories: ::protobuf::RepeatedField<Category>,
+    // special fields
+    pub unknown_fields: ::protobuf::UnknownFields,
+    pub cached_size: ::protobuf::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a Category {
+    fn default() -> &'a Category {
+        <Category as ::protobuf::Message>::default_instance()
+    }
+}
+
+impl Category {
+    pub fn new() -> Category {
+        ::std::default::Default::default()
+    }
+
+    // optional string name = 1;
+
+
+    pub fn get_name(&self) -> &str {
+        match self.name.as_ref() {
+            Some(v) => &v,
+            None => "",
+        }
+    }
+    pub fn clear_name(&mut self) {
+        self.name.clear();
+    }
+
+    pub fn has_name(&self) -> bool {
+        self.name.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_name(&mut self, v: ::std::string::String) {
+        self.name = ::protobuf::SingularField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_name(&mut self) -> &mut ::std::string::String {
+        if self.name.is_none() {
+            self.name.set_default();
+        }
+        self.name.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_name(&mut self) -> ::std::string::String {
+        self.name.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+
+    // repeated .Category subcategories = 2;
+
+
+    pub fn get_subcategories(&self) -> &[Category] {
+        &self.subcategories
+    }
+    pub fn clear_subcategories(&mut self) {
+        self.subcategories.clear();
+    }
+
+    // Param is passed by value, moved
+    pub fn set_subcategories(&mut self, v: ::protobuf::RepeatedField<Category>) {
+        self.subcategories = v;
+    }
+
+    // Mutable pointer to the field.
+    pub fn mut_subcategories(&mut self) -> &mut ::protobuf::RepeatedField<Category> {
+        &mut self.subcategories
+    }
+
+    // Take field
+    pub fn take_subcategories(&mut self) -> ::protobuf::RepeatedField<Category> {
+        ::std::mem::replace(&mut self.subcategories, ::protobuf::RepeatedField::new())
+    }
+}
+
+impl ::protobuf::Message for Category {
+    fn is_initialized(&self) -> bool {
+        for v in &self.subcategories {
+            if !v.is_initialized() {
+                return false;
+            }
+        };
+        true
+    }
+
+    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
+        while !is.eof()? {
+            let (field_number, wire_type) = is.read_tag_unpack()?;
+            match field_number {
+                1 => {
+                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
+                },
+                2 => {
+                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.subcategories)?;
+                },
+                _ => {
+                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                },
+            };
+        }
+        ::std::result::Result::Ok(())
+    }
+
+    // Compute sizes of nested messages
+    #[allow(unused_variables)]
+    fn compute_size(&self) -> u32 {
+        let mut my_size = 0;
+        if let Some(ref v) = self.name.as_ref() {
+            my_size += ::protobuf::rt::string_size(1, &v);
+        }
+        for value in &self.subcategories {
+            let len = value.compute_size();
+            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+        };
+        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        self.cached_size.set(my_size);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
+        if let Some(ref v) = self.name.as_ref() {
+            os.write_string(1, &v)?;
+        }
+        for v in &self.subcategories {
+            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_raw_varint32(v.get_cached_size())?;
+            v.write_to_with_cached_sizes(os)?;
+        };
+        os.write_unknown_fields(self.get_unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn get_cached_size(&self) -> u32 {
+        self.cached_size.get()
+    }
+
+    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+        &self.unknown_fields
+    }
+
+    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+        &mut self.unknown_fields
+    }
+
+    fn as_any(&self) -> &dyn (::std::any::Any) {
+        self as &dyn (::std::any::Any)
+    }
+    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
+        self as &mut dyn (::std::any::Any)
+    }
+    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+        self
+    }
+
+    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+        Self::descriptor_static()
+    }
+
+    fn new() -> Category {
+        Category::new()
+    }
+
+    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
+            lock: ::protobuf::lazy::ONCE_INIT,
+            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
+        };
+        unsafe {
+            descriptor.get(|| {
+                let mut fields = ::std::vec::Vec::new();
+                fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+                    "name",
+                    |m: &Category| { &m.name },
+                    |m: &mut Category| { &mut m.name },
+                ));
+                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Category>>(
+                    "subcategories",
+                    |m: &Category| { &m.subcategories },
+                    |m: &mut Category| { &mut m.subcategories },
+                ));
+                ::protobuf::reflect::MessageDescriptor::new::<Category>(
+                    "Category",
+                    fields,
+                    file_descriptor_proto()
+                )
+            })
+        }
+    }
+
+    fn default_instance() -> &'static Category {
+        static mut instance: ::protobuf::lazy::Lazy<Category> = ::protobuf::lazy::Lazy {
+            lock: ::protobuf::lazy::ONCE_INIT,
+            ptr: 0 as *const Category,
+        };
+        unsafe {
+            instance.get(Category::new)
+        }
+    }
+}
+
+impl ::protobuf::Clear for Category {
+    fn clear(&mut self) {
+        self.name.clear();
+        self.subcategories.clear();
+        self.unknown_fields.clear();
+    }
+}
+
+impl ::std::fmt::Debug for Category {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        ::protobuf::text_format::fmt(self, f)
+    }
+}
+
+impl ::protobuf::reflect::ProtobufValue for Category {
+    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
+        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    }
+}
+
+#[derive(PartialEq,Clone,Default)]
+pub struct OriginalAudio {
+    // message fields
+    uuid: ::protobuf::SingularField<::std::vec::Vec<u8>>,
+    // special fields
+    pub unknown_fields: ::protobuf::UnknownFields,
+    pub cached_size: ::protobuf::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a OriginalAudio {
+    fn default() -> &'a OriginalAudio {
+        <OriginalAudio as ::protobuf::Message>::default_instance()
+    }
+}
+
+impl OriginalAudio {
+    pub fn new() -> OriginalAudio {
+        ::std::default::Default::default()
+    }
+
+    // optional bytes uuid = 1;
+
+
+    pub fn get_uuid(&self) -> &[u8] {
+        match self.uuid.as_ref() {
+            Some(v) => &v,
+            None => &[],
+        }
+    }
+    pub fn clear_uuid(&mut self) {
+        self.uuid.clear();
+    }
+
+    pub fn has_uuid(&self) -> bool {
+        self.uuid.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_uuid(&mut self, v: ::std::vec::Vec<u8>) {
+        self.uuid = ::protobuf::SingularField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_uuid(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.uuid.is_none() {
+            self.uuid.set_default();
+        }
+        self.uuid.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_uuid(&mut self) -> ::std::vec::Vec<u8> {
+        self.uuid.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+}
+
+impl ::protobuf::Message for OriginalAudio {
+    fn is_initialized(&self) -> bool {
+        true
+    }
+
+    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
+        while !is.eof()? {
+            let (field_number, wire_type) = is.read_tag_unpack()?;
+            match field_number {
+                1 => {
+                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.uuid)?;
+                },
+                _ => {
+                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                },
+            };
+        }
+        ::std::result::Result::Ok(())
+    }
+
+    // Compute sizes of nested messages
+    #[allow(unused_variables)]
+    fn compute_size(&self) -> u32 {
+        let mut my_size = 0;
+        if let Some(ref v) = self.uuid.as_ref() {
+            my_size += ::protobuf::rt::bytes_size(1, &v);
+        }
+        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        self.cached_size.set(my_size);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
+        if let Some(ref v) = self.uuid.as_ref() {
+            os.write_bytes(1, &v)?;
+        }
+        os.write_unknown_fields(self.get_unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn get_cached_size(&self) -> u32 {
+        self.cached_size.get()
+    }
+
+    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+        &self.unknown_fields
+    }
+
+    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+        &mut self.unknown_fields
+    }
+
+    fn as_any(&self) -> &dyn (::std::any::Any) {
+        self as &dyn (::std::any::Any)
+    }
+    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
+        self as &mut dyn (::std::any::Any)
+    }
+    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+        self
+    }
+
+    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+        Self::descriptor_static()
+    }
+
+    fn new() -> OriginalAudio {
+        OriginalAudio::new()
+    }
+
+    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
+            lock: ::protobuf::lazy::ONCE_INIT,
+            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
+        };
+        unsafe {
+            descriptor.get(|| {
+                let mut fields = ::std::vec::Vec::new();
+                fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
+                    "uuid",
+                    |m: &OriginalAudio| { &m.uuid },
+                    |m: &mut OriginalAudio| { &mut m.uuid },
+                ));
+                ::protobuf::reflect::MessageDescriptor::new::<OriginalAudio>(
+                    "OriginalAudio",
+                    fields,
+                    file_descriptor_proto()
+                )
+            })
+        }
+    }
+
+    fn default_instance() -> &'static OriginalAudio {
+        static mut instance: ::protobuf::lazy::Lazy<OriginalAudio> = ::protobuf::lazy::Lazy {
+            lock: ::protobuf::lazy::ONCE_INIT,
+            ptr: 0 as *const OriginalAudio,
+        };
+        unsafe {
+            instance.get(OriginalAudio::new)
+        }
+    }
+}
+
+impl ::protobuf::Clear for OriginalAudio {
+    fn clear(&mut self) {
+        self.uuid.clear();
+        self.unknown_fields.clear();
+    }
+}
+
+impl ::std::fmt::Debug for OriginalAudio {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        ::protobuf::text_format::fmt(self, f)
+    }
+}
+
+impl ::protobuf::reflect::ProtobufValue for OriginalAudio {
+    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
+        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    }
+}
+
 static file_descriptor_proto_data: &'static [u8] = b"\
     \n\x0emetadata.proto\x12\0\"9\n\tTopTracks\x12\x11\n\x07country\x18\x01\
     \x20\x01(\tB\0\x12\x17\n\x05track\x18\x02\x20\x03(\x0b2\x06.TrackB\0:\0\
@@ -6244,32 +9736,33 @@ static file_descriptor_proto_data: &'static [u8] = b"\
     \x18\x0f\x20\x03(\x0b2\x07.ArtistB\0\x12!\n\x17is_portrait_album_cover\
     \x18\x10\x20\x01(\x08B\0\x12%\n\x0eportrait_group\x18\x11\x20\x01(\x0b2\
     \x0b.ImageGroupB\0:\0\"'\n\nAlbumGroup\x12\x17\n\x05album\x18\x01\x20\
-    \x03(\x0b2\x06.AlbumB\0:\0\"8\n\x04Date\x12\x0e\n\x04year\x18\x01\x20\
+    \x03(\x0b2\x06.AlbumB\0:\0\"Z\n\x04Date\x12\x0e\n\x04year\x18\x01\x20\
     \x01(\x11B\0\x12\x0f\n\x05month\x18\x02\x20\x01(\x11B\0\x12\r\n\x03day\
-    \x18\x03\x20\x01(\x11B\0:\0\"\xf7\x03\n\x05Album\x12\r\n\x03gid\x18\x01\
-    \x20\x01(\x0cB\0\x12\x0e\n\x04name\x18\x02\x20\x01(\tB\0\x12\x19\n\x06ar\
-    tist\x18\x03\x20\x03(\x0b2\x07.ArtistB\0\x12\x1a\n\x03typ\x18\x04\x20\
-    \x01(\x0e2\x0b.Album.TypeB\0\x12\x0f\n\x05label\x18\x05\x20\x01(\tB\0\
-    \x12\x15\n\x04date\x18\x06\x20\x01(\x0b2\x05.DateB\0\x12\x14\n\npopulari\
-    ty\x18\x07\x20\x01(\x11B\0\x12\x0f\n\x05genre\x18\x08\x20\x03(\tB\0\x12\
-    \x17\n\x05cover\x18\t\x20\x03(\x0b2\x06.ImageB\0\x12\"\n\x0bexternal_id\
-    \x18\n\x20\x03(\x0b2\x0b.ExternalIdB\0\x12\x15\n\x04disc\x18\x0b\x20\x03\
-    (\x0b2\x05.DiscB\0\x12\x10\n\x06review\x18\x0c\x20\x03(\tB\0\x12\x1f\n\t\
-    copyright\x18\r\x20\x03(\x0b2\n.CopyrightB\0\x12#\n\x0brestriction\x18\
-    \x0e\x20\x03(\x0b2\x0c.RestrictionB\0\x12\x19\n\x07related\x18\x0f\x20\
-    \x03(\x0b2\x06.AlbumB\0\x12\"\n\x0bsale_period\x18\x10\x20\x03(\x0b2\x0b\
-    .SalePeriodB\0\x12\"\n\x0bcover_group\x18\x11\x20\x01(\x0b2\x0b.ImageGro\
-    upB\0\"8\n\x04Type\x12\t\n\x05ALBUM\x10\x01\x12\n\n\x06SINGLE\x10\x02\
-    \x12\x0f\n\x0bCOMPILATION\x10\x03\x12\x06\n\x02EP\x10\x04\x1a\0:\0\"\x8a\
-    \x03\n\x05Track\x12\r\n\x03gid\x18\x01\x20\x01(\x0cB\0\x12\x0e\n\x04name\
-    \x18\x02\x20\x01(\tB\0\x12\x17\n\x05album\x18\x03\x20\x01(\x0b2\x06.Albu\
-    mB\0\x12\x19\n\x06artist\x18\x04\x20\x03(\x0b2\x07.ArtistB\0\x12\x10\n\
-    \x06number\x18\x05\x20\x01(\x11B\0\x12\x15\n\x0bdisc_number\x18\x06\x20\
-    \x01(\x11B\0\x12\x12\n\x08duration\x18\x07\x20\x01(\x11B\0\x12\x14\n\npo\
-    pularity\x18\x08\x20\x01(\x11B\0\x12\x12\n\x08explicit\x18\t\x20\x01(\
-    \x08B\0\x12\"\n\x0bexternal_id\x18\n\x20\x03(\x0b2\x0b.ExternalIdB\0\x12\
-    #\n\x0brestriction\x18\x0b\x20\x03(\x0b2\x0c.RestrictionB\0\x12\x1a\n\
-    \x04file\x18\x0c\x20\x03(\x0b2\n.AudioFileB\0\x12\x1d\n\x0balternative\
+    \x18\x03\x20\x01(\x11B\0\x12\x0e\n\x04hour\x18\x04\x20\x01(\x11B\0\x12\
+    \x10\n\x06minute\x18\x05\x20\x01(\x11B\0:\0\"\xf7\x03\n\x05Album\x12\r\n\
+    \x03gid\x18\x01\x20\x01(\x0cB\0\x12\x0e\n\x04name\x18\x02\x20\x01(\tB\0\
+    \x12\x19\n\x06artist\x18\x03\x20\x03(\x0b2\x07.ArtistB\0\x12\x1a\n\x03ty\
+    p\x18\x04\x20\x01(\x0e2\x0b.Album.TypeB\0\x12\x0f\n\x05label\x18\x05\x20\
+    \x01(\tB\0\x12\x15\n\x04date\x18\x06\x20\x01(\x0b2\x05.DateB\0\x12\x14\n\
+    \npopularity\x18\x07\x20\x01(\x11B\0\x12\x0f\n\x05genre\x18\x08\x20\x03(\
+    \tB\0\x12\x17\n\x05cover\x18\t\x20\x03(\x0b2\x06.ImageB\0\x12\"\n\x0bext\
+    ernal_id\x18\n\x20\x03(\x0b2\x0b.ExternalIdB\0\x12\x15\n\x04disc\x18\x0b\
+    \x20\x03(\x0b2\x05.DiscB\0\x12\x10\n\x06review\x18\x0c\x20\x03(\tB\0\x12\
+    \x1f\n\tcopyright\x18\r\x20\x03(\x0b2\n.CopyrightB\0\x12#\n\x0brestricti\
+    on\x18\x0e\x20\x03(\x0b2\x0c.RestrictionB\0\x12\x19\n\x07related\x18\x0f\
+    \x20\x03(\x0b2\x06.AlbumB\0\x12\"\n\x0bsale_period\x18\x10\x20\x03(\x0b2\
+    \x0b.SalePeriodB\0\x12\"\n\x0bcover_group\x18\x11\x20\x01(\x0b2\x0b.Imag\
+    eGroupB\0\"8\n\x04Type\x12\t\n\x05ALBUM\x10\x01\x12\n\n\x06SINGLE\x10\
+    \x02\x12\x0f\n\x0bCOMPILATION\x10\x03\x12\x06\n\x02EP\x10\x04\x1a\0:\0\"\
+    \x8a\x03\n\x05Track\x12\r\n\x03gid\x18\x01\x20\x01(\x0cB\0\x12\x0e\n\x04\
+    name\x18\x02\x20\x01(\tB\0\x12\x17\n\x05album\x18\x03\x20\x01(\x0b2\x06.\
+    AlbumB\0\x12\x19\n\x06artist\x18\x04\x20\x03(\x0b2\x07.ArtistB\0\x12\x10\
+    \n\x06number\x18\x05\x20\x01(\x11B\0\x12\x15\n\x0bdisc_number\x18\x06\
+    \x20\x01(\x11B\0\x12\x12\n\x08duration\x18\x07\x20\x01(\x11B\0\x12\x14\n\
+    \npopularity\x18\x08\x20\x01(\x11B\0\x12\x12\n\x08explicit\x18\t\x20\x01\
+    (\x08B\0\x12\"\n\x0bexternal_id\x18\n\x20\x03(\x0b2\x0b.ExternalIdB\0\
+    \x12#\n\x0brestriction\x18\x0b\x20\x03(\x0b2\x0c.RestrictionB\0\x12\x1a\
+    \n\x04file\x18\x0c\x20\x03(\x0b2\n.AudioFileB\0\x12\x1d\n\x0balternative\
     \x18\r\x20\x03(\x0b2\x06.TrackB\0\x12\"\n\x0bsale_period\x18\x0e\x20\x03\
     (\x0b2\x0b.SalePeriodB\0\x12\x1d\n\x07preview\x18\x0f\x20\x03(\x0b2\n.Au\
     dioFileB\0:\0\"\x95\x01\n\x05Image\x12\x11\n\x07file_id\x18\x01\x20\x01(\
@@ -6285,23 +9778,69 @@ static file_descriptor_proto_data: &'static [u8] = b"\
     \n\x05track\x18\x03\x20\x03(\x0b2\x06.TrackB\0:\0\"U\n\tCopyright\x12\
     \x1e\n\x03typ\x18\x01\x20\x01(\x0e2\x0f.Copyright.TypeB\0\x12\x0e\n\x04t\
     ext\x18\x02\x20\x01(\tB\0\"\x16\n\x04Type\x12\x05\n\x01P\x10\0\x12\x05\n\
-    \x01C\x10\x01\x1a\0:\0\"\x9f\x01\n\x0bRestriction\x12\x1b\n\x11countries\
-    _allowed\x18\x02\x20\x01(\tB\0\x12\x1d\n\x13countries_forbidden\x18\x03\
+    \x01C\x10\x01\x1a\0:\0\"\xa5\x02\n\x0bRestriction\x12+\n\tcatalogue\x18\
+    \x01\x20\x03(\x0e2\x16.Restriction.CatalogueB\0\x12\x1b\n\x11countries_a\
+    llowed\x18\x02\x20\x01(\tB\0\x12\x1d\n\x13countries_forbidden\x18\x03\
     \x20\x01(\tB\0\x12\x20\n\x03typ\x18\x04\x20\x01(\x0e2\x11.Restriction.Ty\
-    peB\0\x12\x17\n\rcatalogue_str\x18\x05\x20\x03(\tB\0\"\x17\n\x04Type\x12\
-    \r\n\tSTREAMING\x10\0\x1a\0:\0\"a\n\nSalePeriod\x12#\n\x0brestriction\
-    \x18\x01\x20\x03(\x0b2\x0c.RestrictionB\0\x12\x16\n\x05start\x18\x02\x20\
-    \x01(\x0b2\x05.DateB\0\x12\x14\n\x03end\x18\x03\x20\x01(\x0b2\x05.DateB\
-    \0:\0\"+\n\nExternalId\x12\r\n\x03typ\x18\x01\x20\x01(\tB\0\x12\x0c\n\
-    \x02id\x18\x02\x20\x01(\tB\0:\0\"\x9b\x02\n\tAudioFile\x12\x11\n\x07file\
+    peB\0\x12\x17\n\rcatalogue_str\x18\x05\x20\x03(\tB\0\"W\n\tCatalogue\x12\
+    \x06\n\x02AD\x10\0\x12\x10\n\x0cSUBSCRIPTION\x10\x01\x12\x11\n\rCATALOGU\
+    E_ALL\x10\x02\x12\x0b\n\x07SHUFFLE\x10\x03\x12\x0e\n\nCOMMERCIAL\x10\x04\
+    \x1a\0\"\x17\n\x04Type\x12\r\n\tSTREAMING\x10\0\x1a\0:\0\"A\n\x0cAvailab\
+    ility\x12\x17\n\rcatalogue_str\x18\x01\x20\x03(\tB\0\x12\x16\n\x05start\
+    \x18\x02\x20\x01(\x0b2\x05.DateB\0:\0\"a\n\nSalePeriod\x12#\n\x0brestric\
+    tion\x18\x01\x20\x03(\x0b2\x0c.RestrictionB\0\x12\x16\n\x05start\x18\x02\
+    \x20\x01(\x0b2\x05.DateB\0\x12\x14\n\x03end\x18\x03\x20\x01(\x0b2\x05.Da\
+    teB\0:\0\"+\n\nExternalId\x12\r\n\x03typ\x18\x01\x20\x01(\tB\0\x12\x0c\n\
+    \x02id\x18\x02\x20\x01(\tB\0:\0\"\xa2\x02\n\tAudioFile\x12\x11\n\x07file\
     _id\x18\x01\x20\x01(\x0cB\0\x12#\n\x06format\x18\x02\x20\x01(\x0e2\x11.A\
-    udioFile.FormatB\0\"\xd3\x01\n\x06Format\x12\x11\n\rOGG_VORBIS_96\x10\0\
+    udioFile.FormatB\0\"\xda\x01\n\x06Format\x12\x11\n\rOGG_VORBIS_96\x10\0\
     \x12\x12\n\x0eOGG_VORBIS_160\x10\x01\x12\x12\n\x0eOGG_VORBIS_320\x10\x02\
     \x12\x0b\n\x07MP3_256\x10\x03\x12\x0b\n\x07MP3_320\x10\x04\x12\x0b\n\x07\
     MP3_160\x10\x05\x12\n\n\x06MP3_96\x10\x06\x12\x0f\n\x0bMP3_160_ENC\x10\
-    \x07\x12\n\n\x06OTHER2\x10\x08\x12\n\n\x06OTHER3\x10\t\x12\x0b\n\x07AAC_\
-    160\x10\n\x12\x0b\n\x07AAC_320\x10\x0b\x12\n\n\x06OTHER4\x10\x0c\x12\n\n\
-    \x06OTHER5\x10\r\x1a\0:\0B\0b\x06proto2\
+    \x07\x12\x10\n\x0cMP4_128_DUAL\x10\x08\x12\n\n\x06OTHER3\x10\t\x12\x0b\n\
+    \x07AAC_160\x10\n\x12\x0b\n\x07AAC_320\x10\x0b\x12\x0b\n\x07MP4_128\x10\
+    \x0c\x12\n\n\x06OTHER5\x10\r\x1a\0:\0\"\x20\n\tVideoFile\x12\x11\n\x07fi\
+    le_id\x18\x01\x20\x01(\x0cB\0:\0\"\xf6\x05\n\x04Show\x12\r\n\x03gid\x18\
+    \x01\x20\x01(\x0cB\0\x12\x0e\n\x04name\x18\x02\x20\x01(\tB\0\x12\x15\n\
+    \x0bdescription\x18@\x20\x01(\tB\0\x12\x1f\n\x15deprecated_popularity\
+    \x18A\x20\x01(\x11B\0\x12\x13\n\tpublisher\x18B\x20\x01(\tB\0\x12\x12\n\
+    \x08language\x18C\x20\x01(\tB\0\x12\x12\n\x08explicit\x18D\x20\x01(\x08B\
+    \0\x12\x1d\n\x06covers\x18E\x20\x01(\x0b2\x0b.ImageGroupB\0\x12\x1b\n\
+    \x07episode\x18F\x20\x03(\x0b2\x08.EpisodeB\0\x12\x1f\n\tcopyright\x18G\
+    \x20\x03(\x0b2\n.CopyrightB\0\x12#\n\x0brestriction\x18H\x20\x03(\x0b2\
+    \x0c.RestrictionB\0\x12\x11\n\x07keyword\x18I\x20\x03(\tB\0\x12%\n\nmedi\
+    a_type\x18J\x20\x01(\x0e2\x0f.Show.MediaTypeB\0\x123\n\x11consumption_or\
+    der\x18K\x20\x01(\x0e2\x16.Show.ConsumptionOrderB\0\x12+\n!interpret_res\
+    triction_using_geoip\x18L\x20\x01(\x08B\0\x12%\n\x0cavailability\x18N\
+    \x20\x03(\x0b2\r.AvailabilityB\0\x12\x1b\n\x11country_of_origin\x18O\x20\
+    \x01(\tB\0\x12\x1f\n\ncategories\x18P\x20\x03(\x0b2\t.CategoryB\0\x12,\n\
+    \x0bpassthrough\x18Q\x20\x01(\x0e2\x15.Show.PassthroughEnumB\0\".\n\tMed\
+    iaType\x12\t\n\x05MIXED\x10\0\x12\t\n\x05AUDIO\x10\x01\x12\t\n\x05VIDEO\
+    \x10\x02\x1a\0\">\n\x10ConsumptionOrder\x12\x0e\n\nSEQUENTIAL\x10\x01\
+    \x12\x0c\n\x08EPISODIC\x10\x02\x12\n\n\x06RECENT\x10\x03\x1a\0\"7\n\x0fP\
+    assthroughEnum\x12\x0b\n\x07UNKNOWN\x10\0\x12\x08\n\x04NONE\x10\x01\x12\
+    \x0b\n\x07ALLOWED\x10\x02\x1a\0:\0\"\xd7\x05\n\x07Episode\x12\r\n\x03gid\
+    \x18\x01\x20\x01(\x0cB\0\x12\x0e\n\x04name\x18\x02\x20\x01(\tB\0\x12\x12\
+    \n\x08duration\x18\x07\x20\x01(\x11B\0\x12\x14\n\npopularity\x18\x08\x20\
+    \x01(\x11B\0\x12\x1a\n\x04file\x18\x0c\x20\x03(\x0b2\n.AudioFileB\0\x12\
+    \x15\n\x0bdescription\x18@\x20\x01(\tB\0\x12\x10\n\x06number\x18A\x20\
+    \x01(\x11B\0\x12\x1d\n\x0cpublish_time\x18B\x20\x01(\x0b2\x05.DateB\0\
+    \x12\x1f\n\x15deprecated_popularity\x18C\x20\x01(\x11B\0\x12\x1d\n\x06co\
+    vers\x18D\x20\x01(\x0b2\x0b.ImageGroupB\0\x12\x12\n\x08language\x18E\x20\
+    \x01(\tB\0\x12\x12\n\x08explicit\x18F\x20\x01(\x08B\0\x12\x15\n\x04show\
+    \x18G\x20\x01(\x0b2\x05.ShowB\0\x12\x1b\n\x05video\x18H\x20\x03(\x0b2\n.\
+    VideoFileB\0\x12#\n\rvideo_preview\x18I\x20\x03(\x0b2\n.VideoFileB\0\x12\
+    #\n\raudio_preview\x18J\x20\x03(\x0b2\n.AudioFileB\0\x12#\n\x0brestricti\
+    on\x18K\x20\x03(\x0b2\x0c.RestrictionB\0\x12#\n\x0cfreeze_frame\x18L\x20\
+    \x01(\x0b2\x0b.ImageGroupB\0\x12\x11\n\x07keyword\x18M\x20\x03(\tB\0\x12\
+    \x1f\n\x15suppress_monetization\x18N\x20\x01(\x08B\0\x12+\n!interpret_re\
+    striction_using_geoip\x18O\x20\x01(\x08B\0\x12#\n\x19allow_background_pl\
+    ayback\x18Q\x20\x01(\x08B\0\x12%\n\x0cavailability\x18R\x20\x03(\x0b2\r.\
+    AvailabilityB\0\x12\x16\n\x0cexternal_url\x18S\x20\x01(\tB\0\x12(\n\x0eo\
+    riginal_audio\x18T\x20\x01(\x0b2\x0e.OriginalAudioB\0:\0\"@\n\x08Categor\
+    y\x12\x0e\n\x04name\x18\x01\x20\x01(\tB\0\x12\"\n\rsubcategories\x18\x02\
+    \x20\x03(\x0b2\t.CategoryB\0:\0\"!\n\rOriginalAudio\x12\x0e\n\x04uuid\
+    \x18\x01\x20\x01(\x0cB\0:\0B\0b\x06proto2\
 ";
 
 static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy {