elefren-fork/macro-dbg

#![feature(prelude_import)]
//! # Elefren: API Wrapper around the Mastodon API.
//!
//! Most of the api is documented on [Mastodon's website](https://docs.joinmastodon.org/client/intro/)
//!
//! ```no_run
//! # extern crate elefren;
//! # fn main() {
//! #    run().unwrap();
//! # }
//! # fn run() -> elefren::Result<()> {
//! use elefren::{helpers::cli, prelude::*};
//!
//! let registration = Registration::new("https://mastodon.social")
//!     .client_name("elefren_test")
//!     .build()?;
//! let mastodon = cli::authenticate(registration)?;
//!
//! println!(
//!     "{:?}",
//!     mastodon
//!         .get_home_timeline()?
//!         .items_iter()
//!         .take(100)
//!         .collect::<Vec<_>>()
//! );
//! # Ok(())
//! # }
//! ```
//!
//! Elefren also supports Mastodon's Streaming API:
//!
//! # Example
//!
//! ```no_run
//! # extern crate elefren;
//! # use elefren::prelude::*;
//! # use std::error::Error;
//! use elefren::entities::event::Event;
//! # fn main() -> Result<(), Box<Error>> {
//! # let data = Data {
//! #   base: "".into(),
//! #   client_id: "".into(),
//! #   client_secret: "".into(),
//! #   redirect: "".into(),
//! #   token: "".into(),
//! # };
//! let client = Mastodon::from(data);
//! for event in client.streaming_user()? {
//!     match event {
//!         Event::Update(ref status) => { /* .. */ },
//!         Event::Notification(ref notification) => { /* .. */ },
//!         Event::Delete(ref id) => { /* .. */ },
//!         Event::FiltersChanged => { /* .. */ },
//!     }
//! }
//! # Ok(())
//! # }
//! ```

#![deny(missing_docs, warnings, missing_debug_implementations,
        missing_copy_implementations, trivial_casts, trivial_numeric_casts,
        unsafe_code, unstable_features, unused_import_braces,
        unused_qualifications)]
#![allow(intra_doc_link_resolution_failure)]
#[prelude_import]
use std::prelude::v1::*;
#[macro_use]
extern crate std;

#[macro_use]
extern crate log;
#[macro_use]
extern crate serde_derive;
#[macro_use]
extern crate doc_comment;
extern crate hyper_old_types;
extern crate isolang;
#[macro_use]
extern crate serde_json;
extern crate chrono;
extern crate reqwest;
extern crate serde;
extern crate serde_qs;
extern crate serde_urlencoded;
extern crate tap_reader;
extern crate try_from;
extern crate url;
extern crate tungstenite;





use std::{borrow::Cow,
          /*
          io::BufRead,
          */
          ops};

use async_trait::async_trait;
use reqwest::{Client, RequestBuilder, Response};
use tap_reader::Tap;
/*
use tungstenite::client::AutoStream;
*/

use crate::entities::prelude::*;
use crate::page::Page;

pub use crate::data::Data;
pub use crate::errors::{ApiError, Error, Result};
pub use isolang::Language;
pub use crate::mastodon_client::{MastodonClient, MastodonUnauthenticated};
pub use crate::registration::Registration;
pub use crate::requests::{AddFilterRequest, AddPushRequest, StatusesRequest,
                          UpdateCredsRequest, UpdatePushRequest};
pub use crate::status_builder::{NewStatus, StatusBuilder};

/// Registering your App
pub mod apps {






    /*
    type Stream = EventReader<WebSocket>;
    */




































    /*
    /// returns events that are relevant to the authorized user, i.e. home
    /// timeline & notifications
    ///
    /// # Example
    ///
    /// ```no_run
    /// # extern crate elefren;
    /// # use elefren::prelude::*;
    /// # use std::error::Error;
    /// use elefren::entities::event::Event;
    /// # fn main() -> Result<(), Box<Error>> {
    /// # let data = Data {
    /// #   base: "".into(),
    /// #   client_id: "".into(),
    /// #   client_secret: "".into(),
    /// #   redirect: "".into(),
    /// #   token: "".into(),
    /// # };
    /// let client = Mastodon::from(data);
    /// for event in client.streaming_user()? {
    ///     match event {
    ///         Event::Update(ref status) => { /* .. */ },
    ///         Event::Notification(ref notification) => { /* .. */ },
    ///         Event::Delete(ref id) => { /* .. */ },
    ///         Event::FiltersChanged => { /* .. */ },
    ///     }
    /// }
    /// # Ok(())
    /// # }
    /// ```
    fn streaming_user(&self) -> Result<Self::Stream> {
        let mut url: url::Url = self.route("/api/v1/streaming").parse()?;
        url.query_pairs_mut()
            .append_pair("access_token", &self.token)
            .append_pair("stream", "user");
        let mut url: url::Url = reqwest::get(url.as_str())?.url().as_str().parse()?;
        let new_scheme = match url.scheme() {
            "http" => "ws",
            "https" => "wss",
            x => return Err(Error::Other(format!("Bad URL scheme: {}", x))),
        };
        url.set_scheme(new_scheme).map_err(|_| Error::Other("Bad URL scheme!".to_string()))?;

        let client = tungstenite::connect(url.as_str())?.0;

        Ok(EventReader(WebSocket(client)))
    }

    /// returns all public statuses
    fn streaming_public(&self) -> Result<Self::Stream> {
        let mut url: url::Url = self.route("/api/v1/streaming").parse()?;
        url.query_pairs_mut()
            .append_pair("access_token", &self.token)
            .append_pair("stream", "public");
        let mut url: url::Url = reqwest::get(url.as_str())?.url().as_str().parse()?;
        let new_scheme = match url.scheme() {
            "http" => "ws",
            "https" => "wss",
            x => return Err(Error::Other(format!("Bad URL scheme: {}", x))),
        };
        url.set_scheme(new_scheme).map_err(|_| Error::Other("Bad URL scheme!".to_string()))?;

        let client = tungstenite::connect(url.as_str())?.0;

        Ok(EventReader(WebSocket(client)))
    }

    /// Returns all local statuses
    fn streaming_local(&self) -> Result<Self::Stream> {
        let mut url: url::Url = self.route("/api/v1/streaming").parse()?;
        url.query_pairs_mut()
            .append_pair("access_token", &self.token)
            .append_pair("stream", "public:local");
        let mut url: url::Url = reqwest::get(url.as_str())?.url().as_str().parse()?;
        let new_scheme = match url.scheme() {
            "http" => "ws",
            "https" => "wss",
            x => return Err(Error::Other(format!("Bad URL scheme: {}", x))),
        };
        url.set_scheme(new_scheme).map_err(|_| Error::Other("Bad URL scheme!".to_string()))?;

        let client = tungstenite::connect(url.as_str())?.0;

        Ok(EventReader(WebSocket(client)))
    }

    /// Returns all public statuses for a particular hashtag
    fn streaming_public_hashtag(&self, hashtag: &str) -> Result<Self::Stream> {
        let mut url: url::Url = self.route("/api/v1/streaming").parse()?;
        url.query_pairs_mut()
            .append_pair("access_token", &self.token)
            .append_pair("stream", "hashtag")
            .append_pair("tag", hashtag);
        let mut url: url::Url = reqwest::get(url.as_str())?.url().as_str().parse()?;
        let new_scheme = match url.scheme() {
            "http" => "ws",
            "https" => "wss",
            x => return Err(Error::Other(format!("Bad URL scheme: {}", x))),
        };
        url.set_scheme(new_scheme).map_err(|_| Error::Other("Bad URL scheme!".to_string()))?;

        let client = tungstenite::connect(url.as_str())?.0;

        Ok(EventReader(WebSocket(client)))
    }

    /// Returns all local statuses for a particular hashtag
    fn streaming_local_hashtag(&self, hashtag: &str) -> Result<Self::Stream> {
        let mut url: url::Url = self.route("/api/v1/streaming").parse()?;
        url.query_pairs_mut()
            .append_pair("access_token", &self.token)
            .append_pair("stream", "hashtag:local")
            .append_pair("tag", hashtag);
        let mut url: url::Url = reqwest::get(url.as_str())?.url().as_str().parse()?;
        let new_scheme = match url.scheme() {
            "http" => "ws",
            "https" => "wss",
            x => return Err(Error::Other(format!("Bad URL scheme: {}", x))),
        };
        url.set_scheme(new_scheme).map_err(|_| Error::Other("Bad URL scheme!".to_string()))?;

        let client = tungstenite::connect(url.as_str())?.0;

        Ok(EventReader(WebSocket(client)))
    }

    /// Returns statuses for a list
    fn streaming_list(&self, list_id: &str) -> Result<Self::Stream> {
        let mut url: url::Url = self.route("/api/v1/streaming").parse()?;
        url.query_pairs_mut()
            .append_pair("access_token", &self.token)
            .append_pair("stream", "list")
            .append_pair("list", list_id);
        let mut url: url::Url = reqwest::get(url.as_str())?.url().as_str().parse()?;
        let new_scheme = match url.scheme() {
            "http" => "ws",
            "https" => "wss",
            x => return Err(Error::Other(format!("Bad URL scheme: {}", x))),
        };
        url.set_scheme(new_scheme).map_err(|_| Error::Other("Bad URL scheme!".to_string()))?;

        let client = tungstenite::connect(url.as_str())?.0;

        Ok(EventReader(WebSocket(client)))
    }

    /// Returns all direct messages
    fn streaming_direct(&self) -> Result<Self::Stream> {
        let mut url: url::Url = self.route("/api/v1/streaming").parse()?;
        url.query_pairs_mut()
            .append_pair("access_token", &self.token)
            .append_pair("stream", "direct");
        let mut url: url::Url = reqwest::get(url.as_str())?.url().as_str().parse()?;
        let new_scheme = match url.scheme() {
            "http" => "ws",
            "https" => "wss",
            x => return Err(Error::Other(format!("Bad URL scheme: {}", x))),
        };
        url.set_scheme(new_scheme).map_err(|_| Error::Other("Bad URL scheme!".to_string()))?;

        let client = tungstenite::connect(url.as_str())?.0;

        Ok(EventReader(WebSocket(client)))
    }
    */

    /*
    #[derive(Debug)]
    /// WebSocket newtype so that EventStream can be implemented without coherency issues
    pub struct WebSocket(tungstenite::protocol::WebSocket<AutoStream>);

    /// A type that streaming events can be read from
    pub trait EventStream {
        /// Read a message from this stream
        fn read_message(&mut self) -> Result<String>;
    }

    impl<R: BufRead> EventStream for R {
        fn read_message(&mut self) -> Result<String> {
            let mut buf = String::new();
            self.read_line(&mut buf)?;
            Ok(buf)
        }
    }

    impl EventStream for WebSocket {
        fn read_message(&mut self) -> Result<String> {
            Ok(self.0.read_message()?.into_text()?)
        }
    }

    #[derive(Debug)]
    /// Iterator that produces events from a mastodon streaming API event stream
    pub struct EventReader<R: EventStream>(R);
    impl<R: EventStream> Iterator for EventReader<R> {
        type Item = Event;

        fn next(&mut self) -> Option<Self::Item> {
            let mut lines = Vec::new();
            loop {
                if let Ok(line) = self.0.read_message() {
                    let line = line.trim().to_string();
                    if line.starts_with(":") || line.is_empty() {
                        continue;
                    }
                    lines.push(line);
                    if let Ok(event) = self.make_event(&lines) {
                        lines.clear();
                        return Some(event);
                    } else {
                        continue;
                    }
                }
            }
        }
    }

    impl<R: EventStream> EventReader<R> {
        fn make_event(&self, lines: &[String]) -> Result<Event> {
            let event;
            let data;
            if let Some(event_line) = lines
                .iter()
                .find(|line| line.starts_with("event:"))
            {
                event = event_line[6..].trim().to_string();
                data = lines.iter().find(|line| line.starts_with("data:")).map(|x| x[5..].trim().to_string());
            } else {
                #[derive(Deserialize)]
                struct Message {
                    pub event: String,
                    pub payload: Option<String>,
                }
                let message = serde_json::from_str::<Message>(&lines[0])?;
                event = message.event;
                data = message.payload;
            }
            let event: &str = &event;
            Ok(match event {
                "notification" => {
                    let data = data.ok_or_else(|| {
                        Error::Other("Missing `data` line for notification".to_string())
                    })?;
                    let notification = serde_json::from_str::<Notification>(&data)?;
                    Event::Notification(notification)
                },
                "update" => {
                    let data =
                        data.ok_or_else(|| Error::Other("Missing `data` line for update".to_string()))?;
                    let status = serde_json::from_str::<Status>(&data)?;
                    Event::Update(status)
                },
                "delete" => {
                    let data =
                        data.ok_or_else(|| Error::Other("Missing `data` line for delete".to_string()))?;
                    Event::Delete(data)
                },
                "filters_changed" => Event::FiltersChanged,
                _ => return Err(Error::Other(format!("Unknown event `{}`", event))),
            })
        }
    }
    */















    // Convert the HTTP response body from JSON. Pass up deserialization errors
    // transparently.

    // If deserializing into the desired type fails try again to
    // see if this is an error response.
    use std::borrow::Cow;
    use try_from::TryInto;
    use crate::errors::{Error, Result};
    use crate::scopes::Scopes;
    /// Represents an application that can be registered with a mastodon instance
    pub struct App {
        client_name: String,
        redirect_uris: String,
        scopes: Scopes,
        #[serde(skip_serializing_if = "Option::is_none")]
        website: Option<String>,
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::clone::Clone for App {
        #[inline]
        fn clone(&self) -> App {
            match *self {
                App {
                client_name: ref __self_0_0,
                redirect_uris: ref __self_0_1,
                scopes: ref __self_0_2,
                website: ref __self_0_3 } =>
                App{client_name: ::core::clone::Clone::clone(&(*__self_0_0)),
                    redirect_uris:
                        ::core::clone::Clone::clone(&(*__self_0_1)),
                    scopes: ::core::clone::Clone::clone(&(*__self_0_2)),
                    website: ::core::clone::Clone::clone(&(*__self_0_3)),},
            }
        }
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::fmt::Debug for App {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            match *self {
                App {
                client_name: ref __self_0_0,
                redirect_uris: ref __self_0_1,
                scopes: ref __self_0_2,
                website: ref __self_0_3 } => {
                    let mut debug_trait_builder = f.debug_struct("App");
                    let _ =
                        debug_trait_builder.field("client_name",
                                                  &&(*__self_0_0));
                    let _ =
                        debug_trait_builder.field("redirect_uris",
                                                  &&(*__self_0_1));
                    let _ =
                        debug_trait_builder.field("scopes", &&(*__self_0_2));
                    let _ =
                        debug_trait_builder.field("website", &&(*__self_0_3));
                    debug_trait_builder.finish()
                }
            }
        }
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::default::Default for App {
        #[inline]
        fn default() -> App {
            App{client_name: ::core::default::Default::default(),
                redirect_uris: ::core::default::Default::default(),
                scopes: ::core::default::Default::default(),
                website: ::core::default::Default::default(),}
        }
    }
    #[doc(hidden)]
    #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
    const _IMPL_SERIALIZE_FOR_App: () =
        {
            #[allow(rust_2018_idioms, clippy :: useless_attribute)]
            extern crate serde as _serde;
            #[allow(unused_macros)]
            macro_rules! try {
                ($ __expr : expr) =>
                {
                    match $ __expr
                    {
                        _serde :: export :: Ok(__val) => __val, _serde ::
                        export :: Err(__err) =>
                        { return _serde :: export :: Err(__err) ; }
                    }
                }
            }
            #[automatically_derived]
            impl _serde::Serialize for App {
                fn serialize<__S>(&self, __serializer: __S)
                 -> _serde::export::Result<__S::Ok, __S::Error> where
                 __S: _serde::Serializer {
                    let mut __serde_state =
                        match _serde::Serializer::serialize_struct(__serializer,
                                                                   "App",
                                                                   false as
                                                                       usize +
                                                                       1 + 1 +
                                                                       1 +
                                                                       if Option::is_none(&self.website)
                                                                          {
                                                                           0
                                                                       } else {
                                                                           1
                                                                       }) {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                    match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                        "client_name",
                                                                        &self.client_name)
                        {
                        _serde::export::Ok(__val) => __val,
                        _serde::export::Err(__err) => {
                            return _serde::export::Err(__err);
                        }
                    };
                    match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                        "redirect_uris",
                                                                        &self.redirect_uris)
                        {
                        _serde::export::Ok(__val) => __val,
                        _serde::export::Err(__err) => {
                            return _serde::export::Err(__err);
                        }
                    };
                    match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                        "scopes",
                                                                        &self.scopes)
                        {
                        _serde::export::Ok(__val) => __val,
                        _serde::export::Err(__err) => {
                            return _serde::export::Err(__err);
                        }
                    };
                    if !Option::is_none(&self.website) {
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "website",
                                                                            &self.website)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                    } else {
                        match _serde::ser::SerializeStruct::skip_field(&mut __serde_state,
                                                                       "website")
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                    }
                    _serde::ser::SerializeStruct::end(__serde_state)
                }
            }
        };
    impl ::core::marker::StructuralPartialEq for App { }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::cmp::PartialEq for App {
        #[inline]
        fn eq(&self, other: &App) -> bool {
            match *other {
                App {
                client_name: ref __self_1_0,
                redirect_uris: ref __self_1_1,
                scopes: ref __self_1_2,
                website: ref __self_1_3 } =>
                match *self {
                    App {
                    client_name: ref __self_0_0,
                    redirect_uris: ref __self_0_1,
                    scopes: ref __self_0_2,
                    website: ref __self_0_3 } =>
                    (*__self_0_0) == (*__self_1_0) &&
                        (*__self_0_1) == (*__self_1_1) &&
                        (*__self_0_2) == (*__self_1_2) &&
                        (*__self_0_3) == (*__self_1_3),
                },
            }
        }
        #[inline]
        fn ne(&self, other: &App) -> bool {
            match *other {
                App {
                client_name: ref __self_1_0,
                redirect_uris: ref __self_1_1,
                scopes: ref __self_1_2,
                website: ref __self_1_3 } =>
                match *self {
                    App {
                    client_name: ref __self_0_0,
                    redirect_uris: ref __self_0_1,
                    scopes: ref __self_0_2,
                    website: ref __self_0_3 } =>
                    (*__self_0_0) != (*__self_1_0) ||
                        (*__self_0_1) != (*__self_1_1) ||
                        (*__self_0_2) != (*__self_1_2) ||
                        (*__self_0_3) != (*__self_1_3),
                },
            }
        }
    }
    impl App {
        /// Get an AppBuilder object
        ///
        /// # Example
        ///
        /// ```
        /// # extern crate elefren;
        /// use elefren::apps::App;
        ///
        /// let mut builder = App::builder();
        /// ```
        pub fn builder<'a>() -> AppBuilder<'a> { AppBuilder::new() }
        /// Retrieve the list of scopes that apply to this App
        ///
        /// # Example
        ///
        /// ```
        /// # extern crate elefren;
        /// # use elefren::Error;
        /// use elefren::{apps::App, scopes::Scopes};
        ///
        /// # fn main() -> Result<(), Error> {
        /// let mut builder = App::builder();
        /// builder.client_name("elefren-test");
        /// let app = builder.build()?;
        /// let scopes = app.scopes();
        /// assert_eq!(scopes, &Scopes::read_all());
        /// #   Ok(())
        /// # }
        /// ```
        pub fn scopes(&self) -> &Scopes { &self.scopes }
    }
    /// Builder struct for defining your application.
    /// ```
    /// use elefren::apps::App;
    /// use std::error::Error;
    ///
    /// # fn main() -> Result<(), Box<Error>> {
    /// let mut builder = App::builder();
    /// builder.client_name("elefren_test");
    /// let app = builder.build()?;
    /// #   Ok(())
    /// # }
    /// ```
    pub struct AppBuilder<'a> {
        client_name: Option<Cow<'a, str>>,
        redirect_uris: Option<Cow<'a, str>>,
        scopes: Option<Scopes>,
        website: Option<Cow<'a, str>>,
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl <'a> ::core::clone::Clone for AppBuilder<'a> {
        #[inline]
        fn clone(&self) -> AppBuilder<'a> {
            match *self {
                AppBuilder {
                client_name: ref __self_0_0,
                redirect_uris: ref __self_0_1,
                scopes: ref __self_0_2,
                website: ref __self_0_3 } =>
                AppBuilder{client_name:
                               ::core::clone::Clone::clone(&(*__self_0_0)),
                           redirect_uris:
                               ::core::clone::Clone::clone(&(*__self_0_1)),
                           scopes:
                               ::core::clone::Clone::clone(&(*__self_0_2)),
                           website:
                               ::core::clone::Clone::clone(&(*__self_0_3)),},
            }
        }
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl <'a> ::core::fmt::Debug for AppBuilder<'a> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            match *self {
                AppBuilder {
                client_name: ref __self_0_0,
                redirect_uris: ref __self_0_1,
                scopes: ref __self_0_2,
                website: ref __self_0_3 } => {
                    let mut debug_trait_builder =
                        f.debug_struct("AppBuilder");
                    let _ =
                        debug_trait_builder.field("client_name",
                                                  &&(*__self_0_0));
                    let _ =
                        debug_trait_builder.field("redirect_uris",
                                                  &&(*__self_0_1));
                    let _ =
                        debug_trait_builder.field("scopes", &&(*__self_0_2));
                    let _ =
                        debug_trait_builder.field("website", &&(*__self_0_3));
                    debug_trait_builder.finish()
                }
            }
        }
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl <'a> ::core::default::Default for AppBuilder<'a> {
        #[inline]
        fn default() -> AppBuilder<'a> {
            AppBuilder{client_name: ::core::default::Default::default(),
                       redirect_uris: ::core::default::Default::default(),
                       scopes: ::core::default::Default::default(),
                       website: ::core::default::Default::default(),}
        }
    }
    impl <'a> ::core::marker::StructuralPartialEq for AppBuilder<'a> { }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl <'a> ::core::cmp::PartialEq for AppBuilder<'a> {
        #[inline]
        fn eq(&self, other: &AppBuilder<'a>) -> bool {
            match *other {
                AppBuilder {
                client_name: ref __self_1_0,
                redirect_uris: ref __self_1_1,
                scopes: ref __self_1_2,
                website: ref __self_1_3 } =>
                match *self {
                    AppBuilder {
                    client_name: ref __self_0_0,
                    redirect_uris: ref __self_0_1,
                    scopes: ref __self_0_2,
                    website: ref __self_0_3 } =>
                    (*__self_0_0) == (*__self_1_0) &&
                        (*__self_0_1) == (*__self_1_1) &&
                        (*__self_0_2) == (*__self_1_2) &&
                        (*__self_0_3) == (*__self_1_3),
                },
            }
        }
        #[inline]
        fn ne(&self, other: &AppBuilder<'a>) -> bool {
            match *other {
                AppBuilder {
                client_name: ref __self_1_0,
                redirect_uris: ref __self_1_1,
                scopes: ref __self_1_2,
                website: ref __self_1_3 } =>
                match *self {
                    AppBuilder {
                    client_name: ref __self_0_0,
                    redirect_uris: ref __self_0_1,
                    scopes: ref __self_0_2,
                    website: ref __self_0_3 } =>
                    (*__self_0_0) != (*__self_1_0) ||
                        (*__self_0_1) != (*__self_1_1) ||
                        (*__self_0_2) != (*__self_1_2) ||
                        (*__self_0_3) != (*__self_1_3),
                },
            }
        }
    }
    #[doc(hidden)]
    #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
    const _IMPL_SERIALIZE_FOR_AppBuilder: () =
        {
            #[allow(rust_2018_idioms, clippy :: useless_attribute)]
            extern crate serde as _serde;
            #[allow(unused_macros)]
            macro_rules! try {
                ($ __expr : expr) =>
                {
                    match $ __expr
                    {
                        _serde :: export :: Ok(__val) => __val, _serde ::
                        export :: Err(__err) =>
                        { return _serde :: export :: Err(__err) ; }
                    }
                }
            }
            #[automatically_derived]
            impl <'a> _serde::Serialize for AppBuilder<'a> {
                fn serialize<__S>(&self, __serializer: __S)
                 -> _serde::export::Result<__S::Ok, __S::Error> where
                 __S: _serde::Serializer {
                    let mut __serde_state =
                        match _serde::Serializer::serialize_struct(__serializer,
                                                                   "AppBuilder",
                                                                   false as
                                                                       usize +
                                                                       1 + 1 +
                                                                       1 + 1)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                    match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                        "client_name",
                                                                        &self.client_name)
                        {
                        _serde::export::Ok(__val) => __val,
                        _serde::export::Err(__err) => {
                            return _serde::export::Err(__err);
                        }
                    };
                    match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                        "redirect_uris",
                                                                        &self.redirect_uris)
                        {
                        _serde::export::Ok(__val) => __val,
                        _serde::export::Err(__err) => {
                            return _serde::export::Err(__err);
                        }
                    };
                    match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                        "scopes",
                                                                        &self.scopes)
                        {
                        _serde::export::Ok(__val) => __val,
                        _serde::export::Err(__err) => {
                            return _serde::export::Err(__err);
                        }
                    };
                    match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                        "website",
                                                                        &self.website)
                        {
                        _serde::export::Ok(__val) => __val,
                        _serde::export::Err(__err) => {
                            return _serde::export::Err(__err);
                        }
                    };
                    _serde::ser::SerializeStruct::end(__serde_state)
                }
            }
        };
    impl <'a> AppBuilder<'a> {
        /// Creates a new AppBuilder object
        pub fn new() -> Self { Default::default() }
        /// Name of the application. Will be displayed when the user is deciding to
        /// grant permission.
        ///
        /// In order to turn this builder into an App, this needs to be provided
        pub fn client_name<I: Into<Cow<'a, str>>>(&mut self, name: I)
         -> &mut Self {
            self.client_name = Some(name.into());
            self
        }
        /// Where the user should be redirected after authorization
        ///
        /// If none is specified, the default is `urn:ietf:wg:oauth:2.0:oob`
        pub fn redirect_uris<I: Into<Cow<'a, str>>>(&mut self, uris: I)
         -> &mut Self {
            self.redirect_uris = Some(uris.into());
            self
        }
        /// Permission scope of the application.
        ///
        /// IF none is specified, the default is Scopes::read_all()
        pub fn scopes(&mut self, scopes: Scopes) -> &mut Self {
            self.scopes = Some(scopes);
            self
        }
        /// URL to the homepage of your application.
        pub fn website<I: Into<Cow<'a, str>>>(&mut self, website: I)
         -> &mut Self {
            self.website = Some(website.into());
            self
        }
        /// Attempts to convert this build into an `App`
        ///
        /// Will fail if no `client_name` was provided
        pub fn build(self) -> Result<App> {
            Ok(App{client_name:
                       self.client_name.ok_or_else(||
                                                       Error::MissingField("client_name"))?.into(),
                   redirect_uris:
                       self.redirect_uris.unwrap_or_else(||
                                                             "urn:ietf:wg:oauth:2.0:oob".into()).into(),
                   scopes: self.scopes.unwrap_or_else(|| Scopes::read_all()),
                   website: self.website.map(|s| s.into()),})
        }
    }
    impl TryInto<App> for App {
        type Err = Error;
        fn try_into(self) -> Result<App> { Ok(self) }
    }
    impl <'a> TryInto<App> for AppBuilder<'a> {
        type Err = Error;
        fn try_into(self) -> Result<App> { Ok(self.build()?) }
    }
}
/// Contains the struct that holds the client auth data
pub mod data {
    use std::borrow::Cow;
    /// Raw data about mastodon app. Save `Data` using `serde` to prevent needing
    /// to authenticate on every run.
    pub struct Data {
        /// Base url of instance eg. `https://mastodon.social`.
        pub base: Cow<'static, str>,
        /// The client's id given by the instance.
        pub client_id: Cow<'static, str>,
        /// The client's secret given by the instance.
        pub client_secret: Cow<'static, str>,
        /// Url to redirect back to your application from the instance signup.
        pub redirect: Cow<'static, str>,
        /// The client's access token.
        pub token: Cow<'static, str>,
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::clone::Clone for Data {
        #[inline]
        fn clone(&self) -> Data {
            match *self {
                Data {
                base: ref __self_0_0,
                client_id: ref __self_0_1,
                client_secret: ref __self_0_2,
                redirect: ref __self_0_3,
                token: ref __self_0_4 } =>
                Data{base: ::core::clone::Clone::clone(&(*__self_0_0)),
                     client_id: ::core::clone::Clone::clone(&(*__self_0_1)),
                     client_secret:
                         ::core::clone::Clone::clone(&(*__self_0_2)),
                     redirect: ::core::clone::Clone::clone(&(*__self_0_3)),
                     token: ::core::clone::Clone::clone(&(*__self_0_4)),},
            }
        }
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::fmt::Debug for Data {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            match *self {
                Data {
                base: ref __self_0_0,
                client_id: ref __self_0_1,
                client_secret: ref __self_0_2,
                redirect: ref __self_0_3,
                token: ref __self_0_4 } => {
                    let mut debug_trait_builder = f.debug_struct("Data");
                    let _ =
                        debug_trait_builder.field("base", &&(*__self_0_0));
                    let _ =
                        debug_trait_builder.field("client_id",
                                                  &&(*__self_0_1));
                    let _ =
                        debug_trait_builder.field("client_secret",
                                                  &&(*__self_0_2));
                    let _ =
                        debug_trait_builder.field("redirect",
                                                  &&(*__self_0_3));
                    let _ =
                        debug_trait_builder.field("token", &&(*__self_0_4));
                    debug_trait_builder.finish()
                }
            }
        }
    }
    impl ::core::marker::StructuralPartialEq for Data { }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::cmp::PartialEq for Data {
        #[inline]
        fn eq(&self, other: &Data) -> bool {
            match *other {
                Data {
                base: ref __self_1_0,
                client_id: ref __self_1_1,
                client_secret: ref __self_1_2,
                redirect: ref __self_1_3,
                token: ref __self_1_4 } =>
                match *self {
                    Data {
                    base: ref __self_0_0,
                    client_id: ref __self_0_1,
                    client_secret: ref __self_0_2,
                    redirect: ref __self_0_3,
                    token: ref __self_0_4 } =>
                    (*__self_0_0) == (*__self_1_0) &&
                        (*__self_0_1) == (*__self_1_1) &&
                        (*__self_0_2) == (*__self_1_2) &&
                        (*__self_0_3) == (*__self_1_3) &&
                        (*__self_0_4) == (*__self_1_4),
                },
            }
        }
        #[inline]
        fn ne(&self, other: &Data) -> bool {
            match *other {
                Data {
                base: ref __self_1_0,
                client_id: ref __self_1_1,
                client_secret: ref __self_1_2,
                redirect: ref __self_1_3,
                token: ref __self_1_4 } =>
                match *self {
                    Data {
                    base: ref __self_0_0,
                    client_id: ref __self_0_1,
                    client_secret: ref __self_0_2,
                    redirect: ref __self_0_3,
                    token: ref __self_0_4 } =>
                    (*__self_0_0) != (*__self_1_0) ||
                        (*__self_0_1) != (*__self_1_1) ||
                        (*__self_0_2) != (*__self_1_2) ||
                        (*__self_0_3) != (*__self_1_3) ||
                        (*__self_0_4) != (*__self_1_4),
                },
            }
        }
    }
    #[doc(hidden)]
    #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
    const _IMPL_DESERIALIZE_FOR_Data: () =
        {
            #[allow(rust_2018_idioms, clippy :: useless_attribute)]
            extern crate serde as _serde;
            #[allow(unused_macros)]
            macro_rules! try {
                ($ __expr : expr) =>
                {
                    match $ __expr
                    {
                        _serde :: export :: Ok(__val) => __val, _serde ::
                        export :: Err(__err) =>
                        { return _serde :: export :: Err(__err) ; }
                    }
                }
            }
            #[automatically_derived]
            impl <'de> _serde::Deserialize<'de> for Data {
                fn deserialize<__D>(__deserializer: __D)
                 -> _serde::export::Result<Self, __D::Error> where
                 __D: _serde::Deserializer<'de> {
                    #[allow(non_camel_case_types)]
                    enum __Field {
                        __field0,
                        __field1,
                        __field2,
                        __field3,
                        __field4,
                        __ignore,
                    }
                    struct __FieldVisitor;
                    impl <'de> _serde::de::Visitor<'de> for __FieldVisitor {
                        type Value = __Field;
                        fn expecting(&self,
                                     __formatter:
                                         &mut _serde::export::Formatter)
                         -> _serde::export::fmt::Result {
                            _serde::export::Formatter::write_str(__formatter,
                                                                 "field identifier")
                        }
                        fn visit_u64<__E>(self, __value: u64)
                         -> _serde::export::Result<Self::Value, __E> where
                         __E: _serde::de::Error {
                            match __value {
                                0u64 => _serde::export::Ok(__Field::__field0),
                                1u64 => _serde::export::Ok(__Field::__field1),
                                2u64 => _serde::export::Ok(__Field::__field2),
                                3u64 => _serde::export::Ok(__Field::__field3),
                                4u64 => _serde::export::Ok(__Field::__field4),
                                _ =>
                                _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                     &"field index 0 <= i < 5")),
                            }
                        }
                        fn visit_str<__E>(self, __value: &str)
                         -> _serde::export::Result<Self::Value, __E> where
                         __E: _serde::de::Error {
                            match __value {
                                "base" =>
                                _serde::export::Ok(__Field::__field0),
                                "client_id" =>
                                _serde::export::Ok(__Field::__field1),
                                "client_secret" =>
                                _serde::export::Ok(__Field::__field2),
                                "redirect" =>
                                _serde::export::Ok(__Field::__field3),
                                "token" =>
                                _serde::export::Ok(__Field::__field4),
                                _ => { _serde::export::Ok(__Field::__ignore) }
                            }
                        }
                        fn visit_bytes<__E>(self, __value: &[u8])
                         -> _serde::export::Result<Self::Value, __E> where
                         __E: _serde::de::Error {
                            match __value {
                                b"base" =>
                                _serde::export::Ok(__Field::__field0),
                                b"client_id" =>
                                _serde::export::Ok(__Field::__field1),
                                b"client_secret" =>
                                _serde::export::Ok(__Field::__field2),
                                b"redirect" =>
                                _serde::export::Ok(__Field::__field3),
                                b"token" =>
                                _serde::export::Ok(__Field::__field4),
                                _ => { _serde::export::Ok(__Field::__ignore) }
                            }
                        }
                    }
                    impl <'de> _serde::Deserialize<'de> for __Field {
                        #[inline]
                        fn deserialize<__D>(__deserializer: __D)
                         -> _serde::export::Result<Self, __D::Error> where
                         __D: _serde::Deserializer<'de> {
                            _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                         __FieldVisitor)
                        }
                    }
                    struct __Visitor<'de> {
                        marker: _serde::export::PhantomData<Data>,
                        lifetime: _serde::export::PhantomData<&'de ()>,
                    }
                    impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> {
                        type Value = Data;
                        fn expecting(&self,
                                     __formatter:
                                         &mut _serde::export::Formatter)
                         -> _serde::export::fmt::Result {
                            _serde::export::Formatter::write_str(__formatter,
                                                                 "struct Data")
                        }
                        #[inline]
                        fn visit_seq<__A>(self, mut __seq: __A)
                         -> _serde::export::Result<Self::Value, __A::Error>
                         where __A: _serde::de::SeqAccess<'de> {
                            let __field0 =
                                match match _serde::de::SeqAccess::next_element::<Cow<'static,
                                                                                      str>>(&mut __seq)
                                          {
                                          _serde::export::Ok(__val) => __val,
                                          _serde::export::Err(__err) => {
                                              return _serde::export::Err(__err);
                                          }
                                      } {
                                    _serde::export::Some(__value) => __value,
                                    _serde::export::None => {
                                        return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                     &"struct Data with 5 elements"));
                                    }
                                };
                            let __field1 =
                                match match _serde::de::SeqAccess::next_element::<Cow<'static,
                                                                                      str>>(&mut __seq)
                                          {
                                          _serde::export::Ok(__val) => __val,
                                          _serde::export::Err(__err) => {
                                              return _serde::export::Err(__err);
                                          }
                                      } {
                                    _serde::export::Some(__value) => __value,
                                    _serde::export::None => {
                                        return _serde::export::Err(_serde::de::Error::invalid_length(1usize,
                                                                                                     &"struct Data with 5 elements"));
                                    }
                                };
                            let __field2 =
                                match match _serde::de::SeqAccess::next_element::<Cow<'static,
                                                                                      str>>(&mut __seq)
                                          {
                                          _serde::export::Ok(__val) => __val,
                                          _serde::export::Err(__err) => {
                                              return _serde::export::Err(__err);
                                          }
                                      } {
                                    _serde::export::Some(__value) => __value,
                                    _serde::export::None => {
                                        return _serde::export::Err(_serde::de::Error::invalid_length(2usize,
                                                                                                     &"struct Data with 5 elements"));
                                    }
                                };
                            let __field3 =
                                match match _serde::de::SeqAccess::next_element::<Cow<'static,
                                                                                      str>>(&mut __seq)
                                          {
                                          _serde::export::Ok(__val) => __val,
                                          _serde::export::Err(__err) => {
                                              return _serde::export::Err(__err);
                                          }
                                      } {
                                    _serde::export::Some(__value) => __value,
                                    _serde::export::None => {
                                        return _serde::export::Err(_serde::de::Error::invalid_length(3usize,
                                                                                                     &"struct Data with 5 elements"));
                                    }
                                };
                            let __field4 =
                                match match _serde::de::SeqAccess::next_element::<Cow<'static,
                                                                                      str>>(&mut __seq)
                                          {
                                          _serde::export::Ok(__val) => __val,
                                          _serde::export::Err(__err) => {
                                              return _serde::export::Err(__err);
                                          }
                                      } {
                                    _serde::export::Some(__value) => __value,
                                    _serde::export::None => {
                                        return _serde::export::Err(_serde::de::Error::invalid_length(4usize,
                                                                                                     &"struct Data with 5 elements"));
                                    }
                                };
                            _serde::export::Ok(Data{base: __field0,
                                                    client_id: __field1,
                                                    client_secret: __field2,
                                                    redirect: __field3,
                                                    token: __field4,})
                        }
                        #[inline]
                        fn visit_map<__A>(self, mut __map: __A)
                         -> _serde::export::Result<Self::Value, __A::Error>
                         where __A: _serde::de::MapAccess<'de> {
                            let mut __field0:
                                    _serde::export::Option<Cow<'static,
                                                               str>> =
                                _serde::export::None;
                            let mut __field1:
                                    _serde::export::Option<Cow<'static,
                                                               str>> =
                                _serde::export::None;
                            let mut __field2:
                                    _serde::export::Option<Cow<'static,
                                                               str>> =
                                _serde::export::None;
                            let mut __field3:
                                    _serde::export::Option<Cow<'static,
                                                               str>> =
                                _serde::export::None;
                            let mut __field4:
                                    _serde::export::Option<Cow<'static,
                                                               str>> =
                                _serde::export::None;
                            while let _serde::export::Some(__key) =
                                      match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                          {
                                          _serde::export::Ok(__val) => __val,
                                          _serde::export::Err(__err) => {
                                              return _serde::export::Err(__err);
                                          }
                                      } {
                                match __key {
                                    __Field::__field0 => {
                                        if _serde::export::Option::is_some(&__field0)
                                           {
                                            return _serde::export::Err(<__A::Error
                                                                           as
                                                                           _serde::de::Error>::duplicate_field("base"));
                                        }
                                        __field0 =
                                            _serde::export::Some(match _serde::de::MapAccess::next_value::<Cow<'static,
                                                                                                               str>>(&mut __map)
                                                                     {
                                                                     _serde::export::Ok(__val)
                                                                     => __val,
                                                                     _serde::export::Err(__err)
                                                                     => {
                                                                         return _serde::export::Err(__err);
                                                                     }
                                                                 });
                                    }
                                    __Field::__field1 => {
                                        if _serde::export::Option::is_some(&__field1)
                                           {
                                            return _serde::export::Err(<__A::Error
                                                                           as
                                                                           _serde::de::Error>::duplicate_field("client_id"));
                                        }
                                        __field1 =
                                            _serde::export::Some(match _serde::de::MapAccess::next_value::<Cow<'static,
                                                                                                               str>>(&mut __map)
                                                                     {
                                                                     _serde::export::Ok(__val)
                                                                     => __val,
                                                                     _serde::export::Err(__err)
                                                                     => {
                                                                         return _serde::export::Err(__err);
                                                                     }
                                                                 });
                                    }
                                    __Field::__field2 => {
                                        if _serde::export::Option::is_some(&__field2)
                                           {
                                            return _serde::export::Err(<__A::Error
                                                                           as
                                                                           _serde::de::Error>::duplicate_field("client_secret"));
                                        }
                                        __field2 =
                                            _serde::export::Some(match _serde::de::MapAccess::next_value::<Cow<'static,
                                                                                                               str>>(&mut __map)
                                                                     {
                                                                     _serde::export::Ok(__val)
                                                                     => __val,
                                                                     _serde::export::Err(__err)
                                                                     => {
                                                                         return _serde::export::Err(__err);
                                                                     }
                                                                 });
                                    }
                                    __Field::__field3 => {
                                        if _serde::export::Option::is_some(&__field3)
                                           {
                                            return _serde::export::Err(<__A::Error
                                                                           as
                                                                           _serde::de::Error>::duplicate_field("redirect"));
                                        }
                                        __field3 =
                                            _serde::export::Some(match _serde::de::MapAccess::next_value::<Cow<'static,
                                                                                                               str>>(&mut __map)
                                                                     {
                                                                     _serde::export::Ok(__val)
                                                                     => __val,
                                                                     _serde::export::Err(__err)
                                                                     => {
                                                                         return _serde::export::Err(__err);
                                                                     }
                                                                 });
                                    }
                                    __Field::__field4 => {
                                        if _serde::export::Option::is_some(&__field4)
                                           {
                                            return _serde::export::Err(<__A::Error
                                                                           as
                                                                           _serde::de::Error>::duplicate_field("token"));
                                        }
                                        __field4 =
                                            _serde::export::Some(match _serde::de::MapAccess::next_value::<Cow<'static,
                                                                                                               str>>(&mut __map)
                                                                     {
                                                                     _serde::export::Ok(__val)
                                                                     => __val,
                                                                     _serde::export::Err(__err)
                                                                     => {
                                                                         return _serde::export::Err(__err);
                                                                     }
                                                                 });
                                    }
                                    _ => {
                                        let _ =
                                            match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                {
                                                _serde::export::Ok(__val) =>
                                                __val,
                                                _serde::export::Err(__err) =>
                                                {
                                                    return _serde::export::Err(__err);
                                                }
                                            };
                                    }
                                }
                            }
                            let __field0 =
                                match __field0 {
                                    _serde::export::Some(__field0) =>
                                    __field0,
                                    _serde::export::None =>
                                    match _serde::private::de::missing_field("base")
                                        {
                                        _serde::export::Ok(__val) => __val,
                                        _serde::export::Err(__err) => {
                                            return _serde::export::Err(__err);
                                        }
                                    },
                                };
                            let __field1 =
                                match __field1 {
                                    _serde::export::Some(__field1) =>
                                    __field1,
                                    _serde::export::None =>
                                    match _serde::private::de::missing_field("client_id")
                                        {
                                        _serde::export::Ok(__val) => __val,
                                        _serde::export::Err(__err) => {
                                            return _serde::export::Err(__err);
                                        }
                                    },
                                };
                            let __field2 =
                                match __field2 {
                                    _serde::export::Some(__field2) =>
                                    __field2,
                                    _serde::export::None =>
                                    match _serde::private::de::missing_field("client_secret")
                                        {
                                        _serde::export::Ok(__val) => __val,
                                        _serde::export::Err(__err) => {
                                            return _serde::export::Err(__err);
                                        }
                                    },
                                };
                            let __field3 =
                                match __field3 {
                                    _serde::export::Some(__field3) =>
                                    __field3,
                                    _serde::export::None =>
                                    match _serde::private::de::missing_field("redirect")
                                        {
                                        _serde::export::Ok(__val) => __val,
                                        _serde::export::Err(__err) => {
                                            return _serde::export::Err(__err);
                                        }
                                    },
                                };
                            let __field4 =
                                match __field4 {
                                    _serde::export::Some(__field4) =>
                                    __field4,
                                    _serde::export::None =>
                                    match _serde::private::de::missing_field("token")
                                        {
                                        _serde::export::Ok(__val) => __val,
                                        _serde::export::Err(__err) => {
                                            return _serde::export::Err(__err);
                                        }
                                    },
                                };
                            _serde::export::Ok(Data{base: __field0,
                                                    client_id: __field1,
                                                    client_secret: __field2,
                                                    redirect: __field3,
                                                    token: __field4,})
                        }
                    }
                    const FIELDS: &'static [&'static str] =
                        &["base", "client_id", "client_secret", "redirect",
                          "token"];
                    _serde::Deserializer::deserialize_struct(__deserializer,
                                                             "Data", FIELDS,
                                                             __Visitor{marker:
                                                                           _serde::export::PhantomData::<Data>,
                                                                       lifetime:
                                                                           _serde::export::PhantomData,})
                }
            }
        };
    #[doc(hidden)]
    #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
    const _IMPL_SERIALIZE_FOR_Data: () =
        {
            #[allow(rust_2018_idioms, clippy :: useless_attribute)]
            extern crate serde as _serde;
            #[allow(unused_macros)]
            macro_rules! try {
                ($ __expr : expr) =>
                {
                    match $ __expr
                    {
                        _serde :: export :: Ok(__val) => __val, _serde ::
                        export :: Err(__err) =>
                        { return _serde :: export :: Err(__err) ; }
                    }
                }
            }
            #[automatically_derived]
            impl _serde::Serialize for Data {
                fn serialize<__S>(&self, __serializer: __S)
                 -> _serde::export::Result<__S::Ok, __S::Error> where
                 __S: _serde::Serializer {
                    let mut __serde_state =
                        match _serde::Serializer::serialize_struct(__serializer,
                                                                   "Data",
                                                                   false as
                                                                       usize +
                                                                       1 + 1 +
                                                                       1 + 1 +
                                                                       1) {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                    match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                        "base",
                                                                        &self.base)
                        {
                        _serde::export::Ok(__val) => __val,
                        _serde::export::Err(__err) => {
                            return _serde::export::Err(__err);
                        }
                    };
                    match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                        "client_id",
                                                                        &self.client_id)
                        {
                        _serde::export::Ok(__val) => __val,
                        _serde::export::Err(__err) => {
                            return _serde::export::Err(__err);
                        }
                    };
                    match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                        "client_secret",
                                                                        &self.client_secret)
                        {
                        _serde::export::Ok(__val) => __val,
                        _serde::export::Err(__err) => {
                            return _serde::export::Err(__err);
                        }
                    };
                    match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                        "redirect",
                                                                        &self.redirect)
                        {
                        _serde::export::Ok(__val) => __val,
                        _serde::export::Err(__err) => {
                            return _serde::export::Err(__err);
                        }
                    };
                    match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                        "token",
                                                                        &self.token)
                        {
                        _serde::export::Ok(__val) => __val,
                        _serde::export::Err(__err) => {
                            return _serde::export::Err(__err);
                        }
                    };
                    _serde::ser::SerializeStruct::end(__serde_state)
                }
            }
        };
}
/// Entities returned from the API
pub mod entities {
    /// Data structures for ser/de of account-related resources
    pub mod account {
        //! A module containing everything relating to a account returned from the api.
        use chrono::prelude::*;
        use serde::de::{self, Deserialize, Deserializer, Unexpected};
        use crate::status_builder;
        use std::path::PathBuf;
        /// A struct representing an Account.
        pub struct Account {
            /// Equals `username` for local users, includes `@domain` for remote ones.
            pub acct: String,
            /// URL to the avatar image
            pub avatar: String,
            /// URL to the avatar static image (gif)
            pub avatar_static: String,
            /// The time the account was created.
            pub created_at: DateTime<Utc>,
            /// The account's display name.
            pub display_name: String,
            /// The number of followers for the account.
            pub followers_count: u64,
            /// The number of accounts the given account is following.
            pub following_count: u64,
            /// URL to the header image.
            pub header: String,
            /// URL to the header static image (gif).
            pub header_static: String,
            /// The ID of the account.
            pub id: String,
            /// Boolean for when the account cannot be followed without waiting for
            /// approval first.
            pub locked: bool,
            /// Biography of user.
            pub note: String,
            /// The number of statuses the account has made.
            pub statuses_count: u64,
            /// URL of the user's profile page (can be remote).
            pub url: String,
            /// The username of the account.
            pub username: String,
            /// An extra attribute given from `verify_credentials` giving defaults about
            /// a user
            pub source: Option<Source>,
            /// If the owner decided to switch accounts, new account is in
            /// this attribute
            pub moved: Option<Box<Account>>,
            /// List of profile metadata fields
            pub fields: Option<Vec<MetadataField>>,
            /// Boolean indicating whether this account is a bot or not
            pub bot: Option<bool>,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for Account {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    Account {
                    acct: ref __self_0_0,
                    avatar: ref __self_0_1,
                    avatar_static: ref __self_0_2,
                    created_at: ref __self_0_3,
                    display_name: ref __self_0_4,
                    followers_count: ref __self_0_5,
                    following_count: ref __self_0_6,
                    header: ref __self_0_7,
                    header_static: ref __self_0_8,
                    id: ref __self_0_9,
                    locked: ref __self_0_10,
                    note: ref __self_0_11,
                    statuses_count: ref __self_0_12,
                    url: ref __self_0_13,
                    username: ref __self_0_14,
                    source: ref __self_0_15,
                    moved: ref __self_0_16,
                    fields: ref __self_0_17,
                    bot: ref __self_0_18 } => {
                        let mut debug_trait_builder =
                            f.debug_struct("Account");
                        let _ =
                            debug_trait_builder.field("acct",
                                                      &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("avatar",
                                                      &&(*__self_0_1));
                        let _ =
                            debug_trait_builder.field("avatar_static",
                                                      &&(*__self_0_2));
                        let _ =
                            debug_trait_builder.field("created_at",
                                                      &&(*__self_0_3));
                        let _ =
                            debug_trait_builder.field("display_name",
                                                      &&(*__self_0_4));
                        let _ =
                            debug_trait_builder.field("followers_count",
                                                      &&(*__self_0_5));
                        let _ =
                            debug_trait_builder.field("following_count",
                                                      &&(*__self_0_6));
                        let _ =
                            debug_trait_builder.field("header",
                                                      &&(*__self_0_7));
                        let _ =
                            debug_trait_builder.field("header_static",
                                                      &&(*__self_0_8));
                        let _ =
                            debug_trait_builder.field("id", &&(*__self_0_9));
                        let _ =
                            debug_trait_builder.field("locked",
                                                      &&(*__self_0_10));
                        let _ =
                            debug_trait_builder.field("note",
                                                      &&(*__self_0_11));
                        let _ =
                            debug_trait_builder.field("statuses_count",
                                                      &&(*__self_0_12));
                        let _ =
                            debug_trait_builder.field("url",
                                                      &&(*__self_0_13));
                        let _ =
                            debug_trait_builder.field("username",
                                                      &&(*__self_0_14));
                        let _ =
                            debug_trait_builder.field("source",
                                                      &&(*__self_0_15));
                        let _ =
                            debug_trait_builder.field("moved",
                                                      &&(*__self_0_16));
                        let _ =
                            debug_trait_builder.field("fields",
                                                      &&(*__self_0_17));
                        let _ =
                            debug_trait_builder.field("bot",
                                                      &&(*__self_0_18));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for Account {
            #[inline]
            fn clone(&self) -> Account {
                match *self {
                    Account {
                    acct: ref __self_0_0,
                    avatar: ref __self_0_1,
                    avatar_static: ref __self_0_2,
                    created_at: ref __self_0_3,
                    display_name: ref __self_0_4,
                    followers_count: ref __self_0_5,
                    following_count: ref __self_0_6,
                    header: ref __self_0_7,
                    header_static: ref __self_0_8,
                    id: ref __self_0_9,
                    locked: ref __self_0_10,
                    note: ref __self_0_11,
                    statuses_count: ref __self_0_12,
                    url: ref __self_0_13,
                    username: ref __self_0_14,
                    source: ref __self_0_15,
                    moved: ref __self_0_16,
                    fields: ref __self_0_17,
                    bot: ref __self_0_18 } =>
                    Account{acct: ::core::clone::Clone::clone(&(*__self_0_0)),
                            avatar:
                                ::core::clone::Clone::clone(&(*__self_0_1)),
                            avatar_static:
                                ::core::clone::Clone::clone(&(*__self_0_2)),
                            created_at:
                                ::core::clone::Clone::clone(&(*__self_0_3)),
                            display_name:
                                ::core::clone::Clone::clone(&(*__self_0_4)),
                            followers_count:
                                ::core::clone::Clone::clone(&(*__self_0_5)),
                            following_count:
                                ::core::clone::Clone::clone(&(*__self_0_6)),
                            header:
                                ::core::clone::Clone::clone(&(*__self_0_7)),
                            header_static:
                                ::core::clone::Clone::clone(&(*__self_0_8)),
                            id: ::core::clone::Clone::clone(&(*__self_0_9)),
                            locked:
                                ::core::clone::Clone::clone(&(*__self_0_10)),
                            note:
                                ::core::clone::Clone::clone(&(*__self_0_11)),
                            statuses_count:
                                ::core::clone::Clone::clone(&(*__self_0_12)),
                            url: ::core::clone::Clone::clone(&(*__self_0_13)),
                            username:
                                ::core::clone::Clone::clone(&(*__self_0_14)),
                            source:
                                ::core::clone::Clone::clone(&(*__self_0_15)),
                            moved:
                                ::core::clone::Clone::clone(&(*__self_0_16)),
                            fields:
                                ::core::clone::Clone::clone(&(*__self_0_17)),
                            bot:
                                ::core::clone::Clone::clone(&(*__self_0_18)),},
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_Account: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'de> _serde::Deserialize<'de> for Account {
                    fn deserialize<__D>(__deserializer: __D)
                     -> _serde::export::Result<Self, __D::Error> where
                     __D: _serde::Deserializer<'de> {
                        #[allow(non_camel_case_types)]
                        enum __Field {
                            __field0,
                            __field1,
                            __field2,
                            __field3,
                            __field4,
                            __field5,
                            __field6,
                            __field7,
                            __field8,
                            __field9,
                            __field10,
                            __field11,
                            __field12,
                            __field13,
                            __field14,
                            __field15,
                            __field16,
                            __field17,
                            __field18,
                            __ignore,
                        }
                        struct __FieldVisitor;
                        impl <'de> _serde::de::Visitor<'de> for __FieldVisitor
                         {
                            type Value = __Field;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "field identifier")
                            }
                            fn visit_u64<__E>(self, __value: u64)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    0u64 =>
                                    _serde::export::Ok(__Field::__field0),
                                    1u64 =>
                                    _serde::export::Ok(__Field::__field1),
                                    2u64 =>
                                    _serde::export::Ok(__Field::__field2),
                                    3u64 =>
                                    _serde::export::Ok(__Field::__field3),
                                    4u64 =>
                                    _serde::export::Ok(__Field::__field4),
                                    5u64 =>
                                    _serde::export::Ok(__Field::__field5),
                                    6u64 =>
                                    _serde::export::Ok(__Field::__field6),
                                    7u64 =>
                                    _serde::export::Ok(__Field::__field7),
                                    8u64 =>
                                    _serde::export::Ok(__Field::__field8),
                                    9u64 =>
                                    _serde::export::Ok(__Field::__field9),
                                    10u64 =>
                                    _serde::export::Ok(__Field::__field10),
                                    11u64 =>
                                    _serde::export::Ok(__Field::__field11),
                                    12u64 =>
                                    _serde::export::Ok(__Field::__field12),
                                    13u64 =>
                                    _serde::export::Ok(__Field::__field13),
                                    14u64 =>
                                    _serde::export::Ok(__Field::__field14),
                                    15u64 =>
                                    _serde::export::Ok(__Field::__field15),
                                    16u64 =>
                                    _serde::export::Ok(__Field::__field16),
                                    17u64 =>
                                    _serde::export::Ok(__Field::__field17),
                                    18u64 =>
                                    _serde::export::Ok(__Field::__field18),
                                    _ =>
                                    _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                         &"field index 0 <= i < 19")),
                                }
                            }
                            fn visit_str<__E>(self, __value: &str)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    "acct" =>
                                    _serde::export::Ok(__Field::__field0),
                                    "avatar" =>
                                    _serde::export::Ok(__Field::__field1),
                                    "avatar_static" =>
                                    _serde::export::Ok(__Field::__field2),
                                    "created_at" =>
                                    _serde::export::Ok(__Field::__field3),
                                    "display_name" =>
                                    _serde::export::Ok(__Field::__field4),
                                    "followers_count" =>
                                    _serde::export::Ok(__Field::__field5),
                                    "following_count" =>
                                    _serde::export::Ok(__Field::__field6),
                                    "header" =>
                                    _serde::export::Ok(__Field::__field7),
                                    "header_static" =>
                                    _serde::export::Ok(__Field::__field8),
                                    "id" =>
                                    _serde::export::Ok(__Field::__field9),
                                    "locked" =>
                                    _serde::export::Ok(__Field::__field10),
                                    "note" =>
                                    _serde::export::Ok(__Field::__field11),
                                    "statuses_count" =>
                                    _serde::export::Ok(__Field::__field12),
                                    "url" =>
                                    _serde::export::Ok(__Field::__field13),
                                    "username" =>
                                    _serde::export::Ok(__Field::__field14),
                                    "source" =>
                                    _serde::export::Ok(__Field::__field15),
                                    "moved" =>
                                    _serde::export::Ok(__Field::__field16),
                                    "fields" =>
                                    _serde::export::Ok(__Field::__field17),
                                    "bot" =>
                                    _serde::export::Ok(__Field::__field18),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                            fn visit_bytes<__E>(self, __value: &[u8])
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    b"acct" =>
                                    _serde::export::Ok(__Field::__field0),
                                    b"avatar" =>
                                    _serde::export::Ok(__Field::__field1),
                                    b"avatar_static" =>
                                    _serde::export::Ok(__Field::__field2),
                                    b"created_at" =>
                                    _serde::export::Ok(__Field::__field3),
                                    b"display_name" =>
                                    _serde::export::Ok(__Field::__field4),
                                    b"followers_count" =>
                                    _serde::export::Ok(__Field::__field5),
                                    b"following_count" =>
                                    _serde::export::Ok(__Field::__field6),
                                    b"header" =>
                                    _serde::export::Ok(__Field::__field7),
                                    b"header_static" =>
                                    _serde::export::Ok(__Field::__field8),
                                    b"id" =>
                                    _serde::export::Ok(__Field::__field9),
                                    b"locked" =>
                                    _serde::export::Ok(__Field::__field10),
                                    b"note" =>
                                    _serde::export::Ok(__Field::__field11),
                                    b"statuses_count" =>
                                    _serde::export::Ok(__Field::__field12),
                                    b"url" =>
                                    _serde::export::Ok(__Field::__field13),
                                    b"username" =>
                                    _serde::export::Ok(__Field::__field14),
                                    b"source" =>
                                    _serde::export::Ok(__Field::__field15),
                                    b"moved" =>
                                    _serde::export::Ok(__Field::__field16),
                                    b"fields" =>
                                    _serde::export::Ok(__Field::__field17),
                                    b"bot" =>
                                    _serde::export::Ok(__Field::__field18),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                        }
                        impl <'de> _serde::Deserialize<'de> for __Field {
                            #[inline]
                            fn deserialize<__D>(__deserializer: __D)
                             -> _serde::export::Result<Self, __D::Error> where
                             __D: _serde::Deserializer<'de> {
                                _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                             __FieldVisitor)
                            }
                        }
                        struct __Visitor<'de> {
                            marker: _serde::export::PhantomData<Account>,
                            lifetime: _serde::export::PhantomData<&'de ()>,
                        }
                        impl <'de> _serde::de::Visitor<'de> for __Visitor<'de>
                         {
                            type Value = Account;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "struct Account")
                            }
                            #[inline]
                            fn visit_seq<__A>(self, mut __seq: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::SeqAccess<'de> {
                                let __field0 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                         &"struct Account with 19 elements"));
                                        }
                                    };
                                let __field1 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(1usize,
                                                                                                         &"struct Account with 19 elements"));
                                        }
                                    };
                                let __field2 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(2usize,
                                                                                                         &"struct Account with 19 elements"));
                                        }
                                    };
                                let __field3 =
                                    match match _serde::de::SeqAccess::next_element::<DateTime<Utc>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(3usize,
                                                                                                         &"struct Account with 19 elements"));
                                        }
                                    };
                                let __field4 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(4usize,
                                                                                                         &"struct Account with 19 elements"));
                                        }
                                    };
                                let __field5 =
                                    match match _serde::de::SeqAccess::next_element::<u64>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(5usize,
                                                                                                         &"struct Account with 19 elements"));
                                        }
                                    };
                                let __field6 =
                                    match match _serde::de::SeqAccess::next_element::<u64>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(6usize,
                                                                                                         &"struct Account with 19 elements"));
                                        }
                                    };
                                let __field7 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(7usize,
                                                                                                         &"struct Account with 19 elements"));
                                        }
                                    };
                                let __field8 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(8usize,
                                                                                                         &"struct Account with 19 elements"));
                                        }
                                    };
                                let __field9 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(9usize,
                                                                                                         &"struct Account with 19 elements"));
                                        }
                                    };
                                let __field10 =
                                    match match _serde::de::SeqAccess::next_element::<bool>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(10usize,
                                                                                                         &"struct Account with 19 elements"));
                                        }
                                    };
                                let __field11 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(11usize,
                                                                                                         &"struct Account with 19 elements"));
                                        }
                                    };
                                let __field12 =
                                    match match _serde::de::SeqAccess::next_element::<u64>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(12usize,
                                                                                                         &"struct Account with 19 elements"));
                                        }
                                    };
                                let __field13 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(13usize,
                                                                                                         &"struct Account with 19 elements"));
                                        }
                                    };
                                let __field14 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(14usize,
                                                                                                         &"struct Account with 19 elements"));
                                        }
                                    };
                                let __field15 =
                                    match match _serde::de::SeqAccess::next_element::<Option<Source>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(15usize,
                                                                                                         &"struct Account with 19 elements"));
                                        }
                                    };
                                let __field16 =
                                    match match _serde::de::SeqAccess::next_element::<Option<Box<Account>>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(16usize,
                                                                                                         &"struct Account with 19 elements"));
                                        }
                                    };
                                let __field17 =
                                    match match _serde::de::SeqAccess::next_element::<Option<Vec<MetadataField>>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(17usize,
                                                                                                         &"struct Account with 19 elements"));
                                        }
                                    };
                                let __field18 =
                                    match match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(18usize,
                                                                                                         &"struct Account with 19 elements"));
                                        }
                                    };
                                _serde::export::Ok(Account{acct: __field0,
                                                           avatar: __field1,
                                                           avatar_static:
                                                               __field2,
                                                           created_at:
                                                               __field3,
                                                           display_name:
                                                               __field4,
                                                           followers_count:
                                                               __field5,
                                                           following_count:
                                                               __field6,
                                                           header: __field7,
                                                           header_static:
                                                               __field8,
                                                           id: __field9,
                                                           locked: __field10,
                                                           note: __field11,
                                                           statuses_count:
                                                               __field12,
                                                           url: __field13,
                                                           username:
                                                               __field14,
                                                           source: __field15,
                                                           moved: __field16,
                                                           fields: __field17,
                                                           bot: __field18,})
                            }
                            #[inline]
                            fn visit_map<__A>(self, mut __map: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::MapAccess<'de> {
                                let mut __field0:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field1:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field2:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field3:
                                        _serde::export::Option<DateTime<Utc>> =
                                    _serde::export::None;
                                let mut __field4:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field5:
                                        _serde::export::Option<u64> =
                                    _serde::export::None;
                                let mut __field6:
                                        _serde::export::Option<u64> =
                                    _serde::export::None;
                                let mut __field7:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field8:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field9:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field10:
                                        _serde::export::Option<bool> =
                                    _serde::export::None;
                                let mut __field11:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field12:
                                        _serde::export::Option<u64> =
                                    _serde::export::None;
                                let mut __field13:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field14:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field15:
                                        _serde::export::Option<Option<Source>> =
                                    _serde::export::None;
                                let mut __field16:
                                        _serde::export::Option<Option<Box<Account>>> =
                                    _serde::export::None;
                                let mut __field17:
                                        _serde::export::Option<Option<Vec<MetadataField>>> =
                                    _serde::export::None;
                                let mut __field18:
                                        _serde::export::Option<Option<bool>> =
                                    _serde::export::None;
                                while let _serde::export::Some(__key) =
                                          match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                    match __key {
                                        __Field::__field0 => {
                                            if _serde::export::Option::is_some(&__field0)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("acct"));
                                            }
                                            __field0 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field1 => {
                                            if _serde::export::Option::is_some(&__field1)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("avatar"));
                                            }
                                            __field1 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field2 => {
                                            if _serde::export::Option::is_some(&__field2)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("avatar_static"));
                                            }
                                            __field2 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field3 => {
                                            if _serde::export::Option::is_some(&__field3)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("created_at"));
                                            }
                                            __field3 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<DateTime<Utc>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field4 => {
                                            if _serde::export::Option::is_some(&__field4)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("display_name"));
                                            }
                                            __field4 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field5 => {
                                            if _serde::export::Option::is_some(&__field5)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("followers_count"));
                                            }
                                            __field5 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<u64>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field6 => {
                                            if _serde::export::Option::is_some(&__field6)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("following_count"));
                                            }
                                            __field6 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<u64>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field7 => {
                                            if _serde::export::Option::is_some(&__field7)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("header"));
                                            }
                                            __field7 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field8 => {
                                            if _serde::export::Option::is_some(&__field8)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("header_static"));
                                            }
                                            __field8 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field9 => {
                                            if _serde::export::Option::is_some(&__field9)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("id"));
                                            }
                                            __field9 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field10 => {
                                            if _serde::export::Option::is_some(&__field10)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("locked"));
                                            }
                                            __field10 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<bool>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field11 => {
                                            if _serde::export::Option::is_some(&__field11)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("note"));
                                            }
                                            __field11 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field12 => {
                                            if _serde::export::Option::is_some(&__field12)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("statuses_count"));
                                            }
                                            __field12 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<u64>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field13 => {
                                            if _serde::export::Option::is_some(&__field13)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("url"));
                                            }
                                            __field13 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field14 => {
                                            if _serde::export::Option::is_some(&__field14)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("username"));
                                            }
                                            __field14 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field15 => {
                                            if _serde::export::Option::is_some(&__field15)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("source"));
                                            }
                                            __field15 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<Source>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field16 => {
                                            if _serde::export::Option::is_some(&__field16)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("moved"));
                                            }
                                            __field16 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<Box<Account>>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field17 => {
                                            if _serde::export::Option::is_some(&__field17)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("fields"));
                                            }
                                            __field17 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<Vec<MetadataField>>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field18 => {
                                            if _serde::export::Option::is_some(&__field18)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("bot"));
                                            }
                                            __field18 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        _ => {
                                            let _ =
                                                match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                    {
                                                    _serde::export::Ok(__val)
                                                    => __val,
                                                    _serde::export::Err(__err)
                                                    => {
                                                        return _serde::export::Err(__err);
                                                    }
                                                };
                                        }
                                    }
                                }
                                let __field0 =
                                    match __field0 {
                                        _serde::export::Some(__field0) =>
                                        __field0,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("acct")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field1 =
                                    match __field1 {
                                        _serde::export::Some(__field1) =>
                                        __field1,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("avatar")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field2 =
                                    match __field2 {
                                        _serde::export::Some(__field2) =>
                                        __field2,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("avatar_static")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field3 =
                                    match __field3 {
                                        _serde::export::Some(__field3) =>
                                        __field3,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("created_at")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field4 =
                                    match __field4 {
                                        _serde::export::Some(__field4) =>
                                        __field4,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("display_name")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field5 =
                                    match __field5 {
                                        _serde::export::Some(__field5) =>
                                        __field5,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("followers_count")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field6 =
                                    match __field6 {
                                        _serde::export::Some(__field6) =>
                                        __field6,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("following_count")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field7 =
                                    match __field7 {
                                        _serde::export::Some(__field7) =>
                                        __field7,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("header")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field8 =
                                    match __field8 {
                                        _serde::export::Some(__field8) =>
                                        __field8,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("header_static")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field9 =
                                    match __field9 {
                                        _serde::export::Some(__field9) =>
                                        __field9,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("id")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field10 =
                                    match __field10 {
                                        _serde::export::Some(__field10) =>
                                        __field10,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("locked")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field11 =
                                    match __field11 {
                                        _serde::export::Some(__field11) =>
                                        __field11,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("note")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field12 =
                                    match __field12 {
                                        _serde::export::Some(__field12) =>
                                        __field12,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("statuses_count")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field13 =
                                    match __field13 {
                                        _serde::export::Some(__field13) =>
                                        __field13,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("url")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field14 =
                                    match __field14 {
                                        _serde::export::Some(__field14) =>
                                        __field14,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("username")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field15 =
                                    match __field15 {
                                        _serde::export::Some(__field15) =>
                                        __field15,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("source")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field16 =
                                    match __field16 {
                                        _serde::export::Some(__field16) =>
                                        __field16,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("moved")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field17 =
                                    match __field17 {
                                        _serde::export::Some(__field17) =>
                                        __field17,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("fields")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field18 =
                                    match __field18 {
                                        _serde::export::Some(__field18) =>
                                        __field18,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("bot")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                _serde::export::Ok(Account{acct: __field0,
                                                           avatar: __field1,
                                                           avatar_static:
                                                               __field2,
                                                           created_at:
                                                               __field3,
                                                           display_name:
                                                               __field4,
                                                           followers_count:
                                                               __field5,
                                                           following_count:
                                                               __field6,
                                                           header: __field7,
                                                           header_static:
                                                               __field8,
                                                           id: __field9,
                                                           locked: __field10,
                                                           note: __field11,
                                                           statuses_count:
                                                               __field12,
                                                           url: __field13,
                                                           username:
                                                               __field14,
                                                           source: __field15,
                                                           moved: __field16,
                                                           fields: __field17,
                                                           bot: __field18,})
                            }
                        }
                        const FIELDS: &'static [&'static str] =
                            &["acct", "avatar", "avatar_static", "created_at",
                              "display_name", "followers_count",
                              "following_count", "header", "header_static",
                              "id", "locked", "note", "statuses_count", "url",
                              "username", "source", "moved", "fields", "bot"];
                        _serde::Deserializer::deserialize_struct(__deserializer,
                                                                 "Account",
                                                                 FIELDS,
                                                                 __Visitor{marker:
                                                                               _serde::export::PhantomData::<Account>,
                                                                           lifetime:
                                                                               _serde::export::PhantomData,})
                    }
                }
            };
        impl ::core::marker::StructuralPartialEq for Account { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for Account {
            #[inline]
            fn eq(&self, other: &Account) -> bool {
                match *other {
                    Account {
                    acct: ref __self_1_0,
                    avatar: ref __self_1_1,
                    avatar_static: ref __self_1_2,
                    created_at: ref __self_1_3,
                    display_name: ref __self_1_4,
                    followers_count: ref __self_1_5,
                    following_count: ref __self_1_6,
                    header: ref __self_1_7,
                    header_static: ref __self_1_8,
                    id: ref __self_1_9,
                    locked: ref __self_1_10,
                    note: ref __self_1_11,
                    statuses_count: ref __self_1_12,
                    url: ref __self_1_13,
                    username: ref __self_1_14,
                    source: ref __self_1_15,
                    moved: ref __self_1_16,
                    fields: ref __self_1_17,
                    bot: ref __self_1_18 } =>
                    match *self {
                        Account {
                        acct: ref __self_0_0,
                        avatar: ref __self_0_1,
                        avatar_static: ref __self_0_2,
                        created_at: ref __self_0_3,
                        display_name: ref __self_0_4,
                        followers_count: ref __self_0_5,
                        following_count: ref __self_0_6,
                        header: ref __self_0_7,
                        header_static: ref __self_0_8,
                        id: ref __self_0_9,
                        locked: ref __self_0_10,
                        note: ref __self_0_11,
                        statuses_count: ref __self_0_12,
                        url: ref __self_0_13,
                        username: ref __self_0_14,
                        source: ref __self_0_15,
                        moved: ref __self_0_16,
                        fields: ref __self_0_17,
                        bot: ref __self_0_18 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1) &&
                            (*__self_0_2) == (*__self_1_2) &&
                            (*__self_0_3) == (*__self_1_3) &&
                            (*__self_0_4) == (*__self_1_4) &&
                            (*__self_0_5) == (*__self_1_5) &&
                            (*__self_0_6) == (*__self_1_6) &&
                            (*__self_0_7) == (*__self_1_7) &&
                            (*__self_0_8) == (*__self_1_8) &&
                            (*__self_0_9) == (*__self_1_9) &&
                            (*__self_0_10) == (*__self_1_10) &&
                            (*__self_0_11) == (*__self_1_11) &&
                            (*__self_0_12) == (*__self_1_12) &&
                            (*__self_0_13) == (*__self_1_13) &&
                            (*__self_0_14) == (*__self_1_14) &&
                            (*__self_0_15) == (*__self_1_15) &&
                            (*__self_0_16) == (*__self_1_16) &&
                            (*__self_0_17) == (*__self_1_17) &&
                            (*__self_0_18) == (*__self_1_18),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &Account) -> bool {
                match *other {
                    Account {
                    acct: ref __self_1_0,
                    avatar: ref __self_1_1,
                    avatar_static: ref __self_1_2,
                    created_at: ref __self_1_3,
                    display_name: ref __self_1_4,
                    followers_count: ref __self_1_5,
                    following_count: ref __self_1_6,
                    header: ref __self_1_7,
                    header_static: ref __self_1_8,
                    id: ref __self_1_9,
                    locked: ref __self_1_10,
                    note: ref __self_1_11,
                    statuses_count: ref __self_1_12,
                    url: ref __self_1_13,
                    username: ref __self_1_14,
                    source: ref __self_1_15,
                    moved: ref __self_1_16,
                    fields: ref __self_1_17,
                    bot: ref __self_1_18 } =>
                    match *self {
                        Account {
                        acct: ref __self_0_0,
                        avatar: ref __self_0_1,
                        avatar_static: ref __self_0_2,
                        created_at: ref __self_0_3,
                        display_name: ref __self_0_4,
                        followers_count: ref __self_0_5,
                        following_count: ref __self_0_6,
                        header: ref __self_0_7,
                        header_static: ref __self_0_8,
                        id: ref __self_0_9,
                        locked: ref __self_0_10,
                        note: ref __self_0_11,
                        statuses_count: ref __self_0_12,
                        url: ref __self_0_13,
                        username: ref __self_0_14,
                        source: ref __self_0_15,
                        moved: ref __self_0_16,
                        fields: ref __self_0_17,
                        bot: ref __self_0_18 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1) ||
                            (*__self_0_2) != (*__self_1_2) ||
                            (*__self_0_3) != (*__self_1_3) ||
                            (*__self_0_4) != (*__self_1_4) ||
                            (*__self_0_5) != (*__self_1_5) ||
                            (*__self_0_6) != (*__self_1_6) ||
                            (*__self_0_7) != (*__self_1_7) ||
                            (*__self_0_8) != (*__self_1_8) ||
                            (*__self_0_9) != (*__self_1_9) ||
                            (*__self_0_10) != (*__self_1_10) ||
                            (*__self_0_11) != (*__self_1_11) ||
                            (*__self_0_12) != (*__self_1_12) ||
                            (*__self_0_13) != (*__self_1_13) ||
                            (*__self_0_14) != (*__self_1_14) ||
                            (*__self_0_15) != (*__self_1_15) ||
                            (*__self_0_16) != (*__self_1_16) ||
                            (*__self_0_17) != (*__self_1_17) ||
                            (*__self_0_18) != (*__self_1_18),
                    },
                }
            }
        }
        /// A single name: value pair from a user's profile
        pub struct MetadataField {
            /// name part of metadata
            pub name: String,
            /// value part of metadata
            pub value: String,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for MetadataField {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    MetadataField {
                    name: ref __self_0_0, value: ref __self_0_1 } => {
                        let mut debug_trait_builder =
                            f.debug_struct("MetadataField");
                        let _ =
                            debug_trait_builder.field("name",
                                                      &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("value",
                                                      &&(*__self_0_1));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for MetadataField {
            #[inline]
            fn clone(&self) -> MetadataField {
                match *self {
                    MetadataField {
                    name: ref __self_0_0, value: ref __self_0_1 } =>
                    MetadataField{name:
                                      ::core::clone::Clone::clone(&(*__self_0_0)),
                                  value:
                                      ::core::clone::Clone::clone(&(*__self_0_1)),},
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_SERIALIZE_FOR_MetadataField: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl _serde::Serialize for MetadataField {
                    fn serialize<__S>(&self, __serializer: __S)
                     -> _serde::export::Result<__S::Ok, __S::Error> where
                     __S: _serde::Serializer {
                        let mut __serde_state =
                            match _serde::Serializer::serialize_struct(__serializer,
                                                                       "MetadataField",
                                                                       false
                                                                           as
                                                                           usize
                                                                           + 1
                                                                           +
                                                                           1)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "name",
                                                                            &self.name)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "value",
                                                                            &self.value)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        _serde::ser::SerializeStruct::end(__serde_state)
                    }
                }
            };
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_MetadataField: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'de> _serde::Deserialize<'de> for MetadataField {
                    fn deserialize<__D>(__deserializer: __D)
                     -> _serde::export::Result<Self, __D::Error> where
                     __D: _serde::Deserializer<'de> {
                        #[allow(non_camel_case_types)]
                        enum __Field { __field0, __field1, __ignore, }
                        struct __FieldVisitor;
                        impl <'de> _serde::de::Visitor<'de> for __FieldVisitor
                         {
                            type Value = __Field;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "field identifier")
                            }
                            fn visit_u64<__E>(self, __value: u64)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    0u64 =>
                                    _serde::export::Ok(__Field::__field0),
                                    1u64 =>
                                    _serde::export::Ok(__Field::__field1),
                                    _ =>
                                    _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                         &"field index 0 <= i < 2")),
                                }
                            }
                            fn visit_str<__E>(self, __value: &str)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    "name" =>
                                    _serde::export::Ok(__Field::__field0),
                                    "value" =>
                                    _serde::export::Ok(__Field::__field1),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                            fn visit_bytes<__E>(self, __value: &[u8])
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    b"name" =>
                                    _serde::export::Ok(__Field::__field0),
                                    b"value" =>
                                    _serde::export::Ok(__Field::__field1),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                        }
                        impl <'de> _serde::Deserialize<'de> for __Field {
                            #[inline]
                            fn deserialize<__D>(__deserializer: __D)
                             -> _serde::export::Result<Self, __D::Error> where
                             __D: _serde::Deserializer<'de> {
                                _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                             __FieldVisitor)
                            }
                        }
                        struct __Visitor<'de> {
                            marker: _serde::export::PhantomData<MetadataField>,
                            lifetime: _serde::export::PhantomData<&'de ()>,
                        }
                        impl <'de> _serde::de::Visitor<'de> for __Visitor<'de>
                         {
                            type Value = MetadataField;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "struct MetadataField")
                            }
                            #[inline]
                            fn visit_seq<__A>(self, mut __seq: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::SeqAccess<'de> {
                                let __field0 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                         &"struct MetadataField with 2 elements"));
                                        }
                                    };
                                let __field1 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(1usize,
                                                                                                         &"struct MetadataField with 2 elements"));
                                        }
                                    };
                                _serde::export::Ok(MetadataField{name:
                                                                     __field0,
                                                                 value:
                                                                     __field1,})
                            }
                            #[inline]
                            fn visit_map<__A>(self, mut __map: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::MapAccess<'de> {
                                let mut __field0:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field1:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                while let _serde::export::Some(__key) =
                                          match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                    match __key {
                                        __Field::__field0 => {
                                            if _serde::export::Option::is_some(&__field0)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("name"));
                                            }
                                            __field0 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field1 => {
                                            if _serde::export::Option::is_some(&__field1)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("value"));
                                            }
                                            __field1 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        _ => {
                                            let _ =
                                                match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                    {
                                                    _serde::export::Ok(__val)
                                                    => __val,
                                                    _serde::export::Err(__err)
                                                    => {
                                                        return _serde::export::Err(__err);
                                                    }
                                                };
                                        }
                                    }
                                }
                                let __field0 =
                                    match __field0 {
                                        _serde::export::Some(__field0) =>
                                        __field0,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("name")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field1 =
                                    match __field1 {
                                        _serde::export::Some(__field1) =>
                                        __field1,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("value")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                _serde::export::Ok(MetadataField{name:
                                                                     __field0,
                                                                 value:
                                                                     __field1,})
                            }
                        }
                        const FIELDS: &'static [&'static str] =
                            &["name", "value"];
                        _serde::Deserializer::deserialize_struct(__deserializer,
                                                                 "MetadataField",
                                                                 FIELDS,
                                                                 __Visitor{marker:
                                                                               _serde::export::PhantomData::<MetadataField>,
                                                                           lifetime:
                                                                               _serde::export::PhantomData,})
                    }
                }
            };
        impl ::core::marker::StructuralPartialEq for MetadataField { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for MetadataField {
            #[inline]
            fn eq(&self, other: &MetadataField) -> bool {
                match *other {
                    MetadataField {
                    name: ref __self_1_0, value: ref __self_1_1 } =>
                    match *self {
                        MetadataField {
                        name: ref __self_0_0, value: ref __self_0_1 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &MetadataField) -> bool {
                match *other {
                    MetadataField {
                    name: ref __self_1_0, value: ref __self_1_1 } =>
                    match *self {
                        MetadataField {
                        name: ref __self_0_0, value: ref __self_0_1 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1),
                    },
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::default::Default for MetadataField {
            #[inline]
            fn default() -> MetadataField {
                MetadataField{name: ::core::default::Default::default(),
                              value: ::core::default::Default::default(),}
            }
        }
        impl MetadataField {
            pub(crate) fn new(name: &str, value: &str) -> MetadataField {
                MetadataField{name: name.into(), value: value.into(),}
            }
        }
        /// An extra object given from `verify_credentials` giving defaults about a user
        pub struct Source {
            privacy: Option<status_builder::Visibility>,
            #[serde(deserialize_with = "string_or_bool")]
            sensitive: bool,
            note: Option<String>,
            fields: Option<Vec<MetadataField>>,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for Source {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    Source {
                    privacy: ref __self_0_0,
                    sensitive: ref __self_0_1,
                    note: ref __self_0_2,
                    fields: ref __self_0_3 } => {
                        let mut debug_trait_builder =
                            f.debug_struct("Source");
                        let _ =
                            debug_trait_builder.field("privacy",
                                                      &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("sensitive",
                                                      &&(*__self_0_1));
                        let _ =
                            debug_trait_builder.field("note",
                                                      &&(*__self_0_2));
                        let _ =
                            debug_trait_builder.field("fields",
                                                      &&(*__self_0_3));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for Source {
            #[inline]
            fn clone(&self) -> Source {
                match *self {
                    Source {
                    privacy: ref __self_0_0,
                    sensitive: ref __self_0_1,
                    note: ref __self_0_2,
                    fields: ref __self_0_3 } =>
                    Source{privacy:
                               ::core::clone::Clone::clone(&(*__self_0_0)),
                           sensitive:
                               ::core::clone::Clone::clone(&(*__self_0_1)),
                           note: ::core::clone::Clone::clone(&(*__self_0_2)),
                           fields:
                               ::core::clone::Clone::clone(&(*__self_0_3)),},
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_Source: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'de> _serde::Deserialize<'de> for Source {
                    fn deserialize<__D>(__deserializer: __D)
                     -> _serde::export::Result<Self, __D::Error> where
                     __D: _serde::Deserializer<'de> {
                        #[allow(non_camel_case_types)]
                        enum __Field {
                            __field0,
                            __field1,
                            __field2,
                            __field3,
                            __ignore,
                        }
                        struct __FieldVisitor;
                        impl <'de> _serde::de::Visitor<'de> for __FieldVisitor
                         {
                            type Value = __Field;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "field identifier")
                            }
                            fn visit_u64<__E>(self, __value: u64)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    0u64 =>
                                    _serde::export::Ok(__Field::__field0),
                                    1u64 =>
                                    _serde::export::Ok(__Field::__field1),
                                    2u64 =>
                                    _serde::export::Ok(__Field::__field2),
                                    3u64 =>
                                    _serde::export::Ok(__Field::__field3),
                                    _ =>
                                    _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                         &"field index 0 <= i < 4")),
                                }
                            }
                            fn visit_str<__E>(self, __value: &str)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    "privacy" =>
                                    _serde::export::Ok(__Field::__field0),
                                    "sensitive" =>
                                    _serde::export::Ok(__Field::__field1),
                                    "note" =>
                                    _serde::export::Ok(__Field::__field2),
                                    "fields" =>
                                    _serde::export::Ok(__Field::__field3),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                            fn visit_bytes<__E>(self, __value: &[u8])
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    b"privacy" =>
                                    _serde::export::Ok(__Field::__field0),
                                    b"sensitive" =>
                                    _serde::export::Ok(__Field::__field1),
                                    b"note" =>
                                    _serde::export::Ok(__Field::__field2),
                                    b"fields" =>
                                    _serde::export::Ok(__Field::__field3),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                        }
                        impl <'de> _serde::Deserialize<'de> for __Field {
                            #[inline]
                            fn deserialize<__D>(__deserializer: __D)
                             -> _serde::export::Result<Self, __D::Error> where
                             __D: _serde::Deserializer<'de> {
                                _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                             __FieldVisitor)
                            }
                        }
                        struct __Visitor<'de> {
                            marker: _serde::export::PhantomData<Source>,
                            lifetime: _serde::export::PhantomData<&'de ()>,
                        }
                        impl <'de> _serde::de::Visitor<'de> for __Visitor<'de>
                         {
                            type Value = Source;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "struct Source")
                            }
                            #[inline]
                            fn visit_seq<__A>(self, mut __seq: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::SeqAccess<'de> {
                                let __field0 =
                                    match match _serde::de::SeqAccess::next_element::<Option<status_builder::Visibility>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                         &"struct Source with 4 elements"));
                                        }
                                    };
                                let __field1 =
                                    match {
                                              struct __DeserializeWith<'de> {
                                                  value: bool,
                                                  phantom: _serde::export::PhantomData<Source>,
                                                  lifetime: _serde::export::PhantomData<&'de ()>,
                                              }
                                              impl <'de>
                                               _serde::Deserialize<'de> for
                                               __DeserializeWith<'de> {
                                                  fn deserialize<__D>(__deserializer:
                                                                          __D)
                                                   ->
                                                       _serde::export::Result<Self,
                                                                              __D::Error>
                                                   where
                                                   __D: _serde::Deserializer<'de> {
                                                      _serde::export::Ok(__DeserializeWith{value:
                                                                                               match string_or_bool(__deserializer)
                                                                                                   {
                                                                                                   _serde::export::Ok(__val)
                                                                                                   =>
                                                                                                   __val,
                                                                                                   _serde::export::Err(__err)
                                                                                                   =>
                                                                                                   {
                                                                                                       return _serde::export::Err(__err);
                                                                                                   }
                                                                                               },
                                                                                           phantom:
                                                                                               _serde::export::PhantomData,
                                                                                           lifetime:
                                                                                               _serde::export::PhantomData,})
                                                  }
                                              }
                                              _serde::export::Option::map(match _serde::de::SeqAccess::next_element::<__DeserializeWith<'de>>(&mut __seq)
                                                                              {
                                                                              _serde::export::Ok(__val)
                                                                              =>
                                                                              __val,
                                                                              _serde::export::Err(__err)
                                                                              =>
                                                                              {
                                                                                  return _serde::export::Err(__err);
                                                                              }
                                                                          },
                                                                          |__wrap|
                                                                              __wrap.value)
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(1usize,
                                                                                                         &"struct Source with 4 elements"));
                                        }
                                    };
                                let __field2 =
                                    match match _serde::de::SeqAccess::next_element::<Option<String>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(2usize,
                                                                                                         &"struct Source with 4 elements"));
                                        }
                                    };
                                let __field3 =
                                    match match _serde::de::SeqAccess::next_element::<Option<Vec<MetadataField>>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(3usize,
                                                                                                         &"struct Source with 4 elements"));
                                        }
                                    };
                                _serde::export::Ok(Source{privacy: __field0,
                                                          sensitive: __field1,
                                                          note: __field2,
                                                          fields: __field3,})
                            }
                            #[inline]
                            fn visit_map<__A>(self, mut __map: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::MapAccess<'de> {
                                let mut __field0:
                                        _serde::export::Option<Option<status_builder::Visibility>> =
                                    _serde::export::None;
                                let mut __field1:
                                        _serde::export::Option<bool> =
                                    _serde::export::None;
                                let mut __field2:
                                        _serde::export::Option<Option<String>> =
                                    _serde::export::None;
                                let mut __field3:
                                        _serde::export::Option<Option<Vec<MetadataField>>> =
                                    _serde::export::None;
                                while let _serde::export::Some(__key) =
                                          match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                    match __key {
                                        __Field::__field0 => {
                                            if _serde::export::Option::is_some(&__field0)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("privacy"));
                                            }
                                            __field0 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<status_builder::Visibility>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field1 => {
                                            if _serde::export::Option::is_some(&__field1)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("sensitive"));
                                            }
                                            __field1 =
                                                _serde::export::Some({
                                                                         struct __DeserializeWith<'de> {
                                                                             value: bool,
                                                                             phantom: _serde::export::PhantomData<Source>,
                                                                             lifetime: _serde::export::PhantomData<&'de ()>,
                                                                         }
                                                                         impl <'de>
                                                                          _serde::Deserialize<'de>
                                                                          for
                                                                          __DeserializeWith<'de>
                                                                          {
                                                                             fn deserialize<__D>(__deserializer:
                                                                                                     __D)
                                                                              ->
                                                                                  _serde::export::Result<Self,
                                                                                                         __D::Error>
                                                                              where
                                                                              __D: _serde::Deserializer<'de> {
                                                                                 _serde::export::Ok(__DeserializeWith{value:
                                                                                                                          match string_or_bool(__deserializer)
                                                                                                                              {
                                                                                                                              _serde::export::Ok(__val)
                                                                                                                              =>
                                                                                                                              __val,
                                                                                                                              _serde::export::Err(__err)
                                                                                                                              =>
                                                                                                                              {
                                                                                                                                  return _serde::export::Err(__err);
                                                                                                                              }
                                                                                                                          },
                                                                                                                      phantom:
                                                                                                                          _serde::export::PhantomData,
                                                                                                                      lifetime:
                                                                                                                          _serde::export::PhantomData,})
                                                                             }
                                                                         }
                                                                         match _serde::de::MapAccess::next_value::<__DeserializeWith<'de>>(&mut __map)
                                                                             {
                                                                             _serde::export::Ok(__wrapper)
                                                                             =>
                                                                             __wrapper.value,
                                                                             _serde::export::Err(__err)
                                                                             =>
                                                                             {
                                                                                 return _serde::export::Err(__err);
                                                                             }
                                                                         }
                                                                     });
                                        }
                                        __Field::__field2 => {
                                            if _serde::export::Option::is_some(&__field2)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("note"));
                                            }
                                            __field2 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<String>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field3 => {
                                            if _serde::export::Option::is_some(&__field3)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("fields"));
                                            }
                                            __field3 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<Vec<MetadataField>>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        _ => {
                                            let _ =
                                                match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                    {
                                                    _serde::export::Ok(__val)
                                                    => __val,
                                                    _serde::export::Err(__err)
                                                    => {
                                                        return _serde::export::Err(__err);
                                                    }
                                                };
                                        }
                                    }
                                }
                                let __field0 =
                                    match __field0 {
                                        _serde::export::Some(__field0) =>
                                        __field0,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("privacy")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field1 =
                                    match __field1 {
                                        _serde::export::Some(__field1) =>
                                        __field1,
                                        _serde::export::None =>
                                        return _serde::export::Err(<__A::Error
                                                                       as
                                                                       _serde::de::Error>::missing_field("sensitive")),
                                    };
                                let __field2 =
                                    match __field2 {
                                        _serde::export::Some(__field2) =>
                                        __field2,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("note")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field3 =
                                    match __field3 {
                                        _serde::export::Some(__field3) =>
                                        __field3,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("fields")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                _serde::export::Ok(Source{privacy: __field0,
                                                          sensitive: __field1,
                                                          note: __field2,
                                                          fields: __field3,})
                            }
                        }
                        const FIELDS: &'static [&'static str] =
                            &["privacy", "sensitive", "note", "fields"];
                        _serde::Deserializer::deserialize_struct(__deserializer,
                                                                 "Source",
                                                                 FIELDS,
                                                                 __Visitor{marker:
                                                                               _serde::export::PhantomData::<Source>,
                                                                           lifetime:
                                                                               _serde::export::PhantomData,})
                    }
                }
            };
        impl ::core::marker::StructuralPartialEq for Source { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for Source {
            #[inline]
            fn eq(&self, other: &Source) -> bool {
                match *other {
                    Source {
                    privacy: ref __self_1_0,
                    sensitive: ref __self_1_1,
                    note: ref __self_1_2,
                    fields: ref __self_1_3 } =>
                    match *self {
                        Source {
                        privacy: ref __self_0_0,
                        sensitive: ref __self_0_1,
                        note: ref __self_0_2,
                        fields: ref __self_0_3 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1) &&
                            (*__self_0_2) == (*__self_1_2) &&
                            (*__self_0_3) == (*__self_1_3),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &Source) -> bool {
                match *other {
                    Source {
                    privacy: ref __self_1_0,
                    sensitive: ref __self_1_1,
                    note: ref __self_1_2,
                    fields: ref __self_1_3 } =>
                    match *self {
                        Source {
                        privacy: ref __self_0_0,
                        sensitive: ref __self_0_1,
                        note: ref __self_0_2,
                        fields: ref __self_0_3 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1) ||
                            (*__self_0_2) != (*__self_1_2) ||
                            (*__self_0_3) != (*__self_1_3),
                    },
                }
            }
        }
        fn string_or_bool<'de, D: Deserializer<'de>>(val: D)
         -> ::std::result::Result<bool, D::Error> {
            #[serde(untagged)]
            pub enum BoolOrString { Bool(bool), Str(String), }
            #[automatically_derived]
            #[allow(unused_qualifications)]
            impl ::core::clone::Clone for BoolOrString {
                #[inline]
                fn clone(&self) -> BoolOrString {
                    match (&*self,) {
                        (&BoolOrString::Bool(ref __self_0),) =>
                        BoolOrString::Bool(::core::clone::Clone::clone(&(*__self_0))),
                        (&BoolOrString::Str(ref __self_0),) =>
                        BoolOrString::Str(::core::clone::Clone::clone(&(*__self_0))),
                    }
                }
            }
            #[automatically_derived]
            #[allow(unused_qualifications)]
            impl ::core::fmt::Debug for BoolOrString {
                fn fmt(&self, f: &mut ::core::fmt::Formatter)
                 -> ::core::fmt::Result {
                    match (&*self,) {
                        (&BoolOrString::Bool(ref __self_0),) => {
                            let mut debug_trait_builder =
                                f.debug_tuple("Bool");
                            let _ = debug_trait_builder.field(&&(*__self_0));
                            debug_trait_builder.finish()
                        }
                        (&BoolOrString::Str(ref __self_0),) => {
                            let mut debug_trait_builder =
                                f.debug_tuple("Str");
                            let _ = debug_trait_builder.field(&&(*__self_0));
                            debug_trait_builder.finish()
                        }
                    }
                }
            }
            #[doc(hidden)]
            #[allow(non_upper_case_globals, unused_attributes,
                    unused_qualifications)]
            const _IMPL_DESERIALIZE_FOR_BoolOrString: () =
                {
                    #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                    extern crate serde as _serde;
                    #[allow(unused_macros)]
                    macro_rules! try {
                        ($ __expr : expr) =>
                        {
                            match $ __expr
                            {
                                _serde :: export :: Ok(__val) => __val, _serde
                                :: export :: Err(__err) =>
                                { return _serde :: export :: Err(__err) ; }
                            }
                        }
                    }
                    #[automatically_derived]
                    impl <'de> _serde::Deserialize<'de> for BoolOrString {
                        fn deserialize<__D>(__deserializer: __D)
                         -> _serde::export::Result<Self, __D::Error> where
                         __D: _serde::Deserializer<'de> {
                            let __content =
                                match <_serde::private::de::Content as
                                          _serde::Deserialize>::deserialize(__deserializer)
                                    {
                                    _serde::export::Ok(__val) => __val,
                                    _serde::export::Err(__err) => {
                                        return _serde::export::Err(__err);
                                    }
                                };
                            if let _serde::export::Ok(__ok) =
                                   _serde::export::Result::map(<bool as
                                                                   _serde::Deserialize>::deserialize(_serde::private::de::ContentRefDeserializer::<__D::Error>::new(&__content)),
                                                               BoolOrString::Bool)
                               {
                                return _serde::export::Ok(__ok);
                            }
                            if let _serde::export::Ok(__ok) =
                                   _serde::export::Result::map(<String as
                                                                   _serde::Deserialize>::deserialize(_serde::private::de::ContentRefDeserializer::<__D::Error>::new(&__content)),
                                                               BoolOrString::Str)
                               {
                                return _serde::export::Ok(__ok);
                            }
                            _serde::export::Err(_serde::de::Error::custom("data did not match any variant of untagged enum BoolOrString"))
                        }
                    }
                };
            impl ::core::marker::StructuralPartialEq for BoolOrString { }
            #[automatically_derived]
            #[allow(unused_qualifications)]
            impl ::core::cmp::PartialEq for BoolOrString {
                #[inline]
                fn eq(&self, other: &BoolOrString) -> bool {
                    {
                        let __self_vi =
                            unsafe {
                                ::core::intrinsics::discriminant_value(&*self)
                            };
                        let __arg_1_vi =
                            unsafe {
                                ::core::intrinsics::discriminant_value(&*other)
                            };
                        if true && __self_vi == __arg_1_vi {
                            match (&*self, &*other) {
                                (&BoolOrString::Bool(ref __self_0),
                                 &BoolOrString::Bool(ref __arg_1_0)) =>
                                (*__self_0) == (*__arg_1_0),
                                (&BoolOrString::Str(ref __self_0),
                                 &BoolOrString::Str(ref __arg_1_0)) =>
                                (*__self_0) == (*__arg_1_0),
                                _ => unsafe {
                                    ::core::intrinsics::unreachable()
                                }
                            }
                        } else { false }
                    }
                }
                #[inline]
                fn ne(&self, other: &BoolOrString) -> bool {
                    {
                        let __self_vi =
                            unsafe {
                                ::core::intrinsics::discriminant_value(&*self)
                            };
                        let __arg_1_vi =
                            unsafe {
                                ::core::intrinsics::discriminant_value(&*other)
                            };
                        if true && __self_vi == __arg_1_vi {
                            match (&*self, &*other) {
                                (&BoolOrString::Bool(ref __self_0),
                                 &BoolOrString::Bool(ref __arg_1_0)) =>
                                (*__self_0) != (*__arg_1_0),
                                (&BoolOrString::Str(ref __self_0),
                                 &BoolOrString::Str(ref __arg_1_0)) =>
                                (*__self_0) != (*__arg_1_0),
                                _ => unsafe {
                                    ::core::intrinsics::unreachable()
                                }
                            }
                        } else { true }
                    }
                }
            }
            Ok(match BoolOrString::deserialize(val)? {
                   BoolOrString::Bool(b) => b,
                   BoolOrString::Str(ref s) => {
                       if s == "true" {
                           true
                       } else if s == "false" {
                           false
                       } else {
                           return Err(de::Error::invalid_value(Unexpected::Str(s),
                                                               &"true or false"));
                       }
                   }
               })
        }
        pub(crate) struct UpdateSource {
            #[serde(skip_serializing_if = "Option::is_none")]
            pub(crate) privacy: Option<status_builder::Visibility>,
            #[serde(skip_serializing_if = "Option::is_none")]
            pub(crate) sensitive: Option<bool>,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for UpdateSource {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    UpdateSource {
                    privacy: ref __self_0_0, sensitive: ref __self_0_1 } => {
                        let mut debug_trait_builder =
                            f.debug_struct("UpdateSource");
                        let _ =
                            debug_trait_builder.field("privacy",
                                                      &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("sensitive",
                                                      &&(*__self_0_1));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::default::Default for UpdateSource {
            #[inline]
            fn default() -> UpdateSource {
                UpdateSource{privacy: ::core::default::Default::default(),
                             sensitive: ::core::default::Default::default(),}
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for UpdateSource {
            #[inline]
            fn clone(&self) -> UpdateSource {
                match *self {
                    UpdateSource {
                    privacy: ref __self_0_0, sensitive: ref __self_0_1 } =>
                    UpdateSource{privacy:
                                     ::core::clone::Clone::clone(&(*__self_0_0)),
                                 sensitive:
                                     ::core::clone::Clone::clone(&(*__self_0_1)),},
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_SERIALIZE_FOR_UpdateSource: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl _serde::Serialize for UpdateSource {
                    fn serialize<__S>(&self, __serializer: __S)
                     -> _serde::export::Result<__S::Ok, __S::Error> where
                     __S: _serde::Serializer {
                        let mut __serde_state =
                            match _serde::Serializer::serialize_struct(__serializer,
                                                                       "UpdateSource",
                                                                       false
                                                                           as
                                                                           usize
                                                                           +
                                                                           if Option::is_none(&self.privacy)
                                                                              {
                                                                               0
                                                                           } else {
                                                                               1
                                                                           } +
                                                                           if Option::is_none(&self.sensitive)
                                                                              {
                                                                               0
                                                                           } else {
                                                                               1
                                                                           })
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        if !Option::is_none(&self.privacy) {
                            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                "privacy",
                                                                                &self.privacy)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        } else {
                            match _serde::ser::SerializeStruct::skip_field(&mut __serde_state,
                                                                           "privacy")
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        }
                        if !Option::is_none(&self.sensitive) {
                            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                "sensitive",
                                                                                &self.sensitive)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        } else {
                            match _serde::ser::SerializeStruct::skip_field(&mut __serde_state,
                                                                           "sensitive")
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        }
                        _serde::ser::SerializeStruct::end(__serde_state)
                    }
                }
            };
        impl ::core::marker::StructuralPartialEq for UpdateSource { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for UpdateSource {
            #[inline]
            fn eq(&self, other: &UpdateSource) -> bool {
                match *other {
                    UpdateSource {
                    privacy: ref __self_1_0, sensitive: ref __self_1_1 } =>
                    match *self {
                        UpdateSource {
                        privacy: ref __self_0_0, sensitive: ref __self_0_1 }
                        =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &UpdateSource) -> bool {
                match *other {
                    UpdateSource {
                    privacy: ref __self_1_0, sensitive: ref __self_1_1 } =>
                    match *self {
                        UpdateSource {
                        privacy: ref __self_0_0, sensitive: ref __self_0_1 }
                        =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1),
                    },
                }
            }
        }
        pub(crate) struct Credentials {
            #[serde(skip_serializing_if = "Option::is_none")]
            pub(crate) display_name: Option<String>,
            #[serde(skip_serializing_if = "Option::is_none")]
            pub(crate) note: Option<String>,
            #[serde(skip_serializing_if = "Option::is_none")]
            pub(crate) avatar: Option<PathBuf>,
            #[serde(skip_serializing_if = "Option::is_none")]
            pub(crate) header: Option<PathBuf>,
            #[serde(skip_serializing_if = "Option::is_none")]
            pub(crate) source: Option<UpdateSource>,
            #[serde(serialize_with = "fields_attributes_ser::ser")]
            pub(crate) fields_attributes: Vec<MetadataField>,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for Credentials {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    Credentials {
                    display_name: ref __self_0_0,
                    note: ref __self_0_1,
                    avatar: ref __self_0_2,
                    header: ref __self_0_3,
                    source: ref __self_0_4,
                    fields_attributes: ref __self_0_5 } => {
                        let mut debug_trait_builder =
                            f.debug_struct("Credentials");
                        let _ =
                            debug_trait_builder.field("display_name",
                                                      &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("note",
                                                      &&(*__self_0_1));
                        let _ =
                            debug_trait_builder.field("avatar",
                                                      &&(*__self_0_2));
                        let _ =
                            debug_trait_builder.field("header",
                                                      &&(*__self_0_3));
                        let _ =
                            debug_trait_builder.field("source",
                                                      &&(*__self_0_4));
                        let _ =
                            debug_trait_builder.field("fields_attributes",
                                                      &&(*__self_0_5));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::default::Default for Credentials {
            #[inline]
            fn default() -> Credentials {
                Credentials{display_name: ::core::default::Default::default(),
                            note: ::core::default::Default::default(),
                            avatar: ::core::default::Default::default(),
                            header: ::core::default::Default::default(),
                            source: ::core::default::Default::default(),
                            fields_attributes:
                                ::core::default::Default::default(),}
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_SERIALIZE_FOR_Credentials: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl _serde::Serialize for Credentials {
                    fn serialize<__S>(&self, __serializer: __S)
                     -> _serde::export::Result<__S::Ok, __S::Error> where
                     __S: _serde::Serializer {
                        let mut __serde_state =
                            match _serde::Serializer::serialize_struct(__serializer,
                                                                       "Credentials",
                                                                       false
                                                                           as
                                                                           usize
                                                                           +
                                                                           if Option::is_none(&self.display_name)
                                                                              {
                                                                               0
                                                                           } else {
                                                                               1
                                                                           } +
                                                                           if Option::is_none(&self.note)
                                                                              {
                                                                               0
                                                                           } else {
                                                                               1
                                                                           } +
                                                                           if Option::is_none(&self.avatar)
                                                                              {
                                                                               0
                                                                           } else {
                                                                               1
                                                                           } +
                                                                           if Option::is_none(&self.header)
                                                                              {
                                                                               0
                                                                           } else {
                                                                               1
                                                                           } +
                                                                           if Option::is_none(&self.source)
                                                                              {
                                                                               0
                                                                           } else {
                                                                               1
                                                                           } +
                                                                           1)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        if !Option::is_none(&self.display_name) {
                            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                "display_name",
                                                                                &self.display_name)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        } else {
                            match _serde::ser::SerializeStruct::skip_field(&mut __serde_state,
                                                                           "display_name")
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        }
                        if !Option::is_none(&self.note) {
                            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                "note",
                                                                                &self.note)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        } else {
                            match _serde::ser::SerializeStruct::skip_field(&mut __serde_state,
                                                                           "note")
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        }
                        if !Option::is_none(&self.avatar) {
                            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                "avatar",
                                                                                &self.avatar)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        } else {
                            match _serde::ser::SerializeStruct::skip_field(&mut __serde_state,
                                                                           "avatar")
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        }
                        if !Option::is_none(&self.header) {
                            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                "header",
                                                                                &self.header)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        } else {
                            match _serde::ser::SerializeStruct::skip_field(&mut __serde_state,
                                                                           "header")
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        }
                        if !Option::is_none(&self.source) {
                            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                "source",
                                                                                &self.source)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        } else {
                            match _serde::ser::SerializeStruct::skip_field(&mut __serde_state,
                                                                           "source")
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        }
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "fields_attributes",
                                                                            {
                                                                                struct __SerializeWith<'__a> {
                                                                                    values: (&'__a Vec<MetadataField>,),
                                                                                    phantom: _serde::export::PhantomData<Credentials>,
                                                                                }
                                                                                impl <'__a>
                                                                                 _serde::Serialize
                                                                                 for
                                                                                 __SerializeWith<'__a>
                                                                                 {
                                                                                    fn serialize<__S>(&self,
                                                                                                      __s:
                                                                                                          __S)
                                                                                     ->
                                                                                         _serde::export::Result<__S::Ok,
                                                                                                                __S::Error>
                                                                                     where
                                                                                     __S: _serde::Serializer {
                                                                                        fields_attributes_ser::ser(self.values.0,
                                                                                                                   __s)
                                                                                    }
                                                                                }
                                                                                &__SerializeWith{values:
                                                                                                     (&self.fields_attributes,),
                                                                                                 phantom:
                                                                                                     _serde::export::PhantomData::<Credentials>,}
                                                                            })
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        _serde::ser::SerializeStruct::end(__serde_state)
                    }
                }
            };
        impl ::core::marker::StructuralPartialEq for Credentials { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for Credentials {
            #[inline]
            fn eq(&self, other: &Credentials) -> bool {
                match *other {
                    Credentials {
                    display_name: ref __self_1_0,
                    note: ref __self_1_1,
                    avatar: ref __self_1_2,
                    header: ref __self_1_3,
                    source: ref __self_1_4,
                    fields_attributes: ref __self_1_5 } =>
                    match *self {
                        Credentials {
                        display_name: ref __self_0_0,
                        note: ref __self_0_1,
                        avatar: ref __self_0_2,
                        header: ref __self_0_3,
                        source: ref __self_0_4,
                        fields_attributes: ref __self_0_5 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1) &&
                            (*__self_0_2) == (*__self_1_2) &&
                            (*__self_0_3) == (*__self_1_3) &&
                            (*__self_0_4) == (*__self_1_4) &&
                            (*__self_0_5) == (*__self_1_5),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &Credentials) -> bool {
                match *other {
                    Credentials {
                    display_name: ref __self_1_0,
                    note: ref __self_1_1,
                    avatar: ref __self_1_2,
                    header: ref __self_1_3,
                    source: ref __self_1_4,
                    fields_attributes: ref __self_1_5 } =>
                    match *self {
                        Credentials {
                        display_name: ref __self_0_0,
                        note: ref __self_0_1,
                        avatar: ref __self_0_2,
                        header: ref __self_0_3,
                        source: ref __self_0_4,
                        fields_attributes: ref __self_0_5 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1) ||
                            (*__self_0_2) != (*__self_1_2) ||
                            (*__self_0_3) != (*__self_1_3) ||
                            (*__self_0_4) != (*__self_1_4) ||
                            (*__self_0_5) != (*__self_1_5),
                    },
                }
            }
        }
        mod fields_attributes_ser {
            use super::*;
            use serde::ser::{SerializeMap, Serializer};
            pub(crate) fn ser<S>(attrs: &Vec<MetadataField>, serializer: S)
             -> Result<S::Ok, S::Error> where S: Serializer {
                let mut map = serializer.serialize_map(Some(attrs.len()))?;
                for (i, field) in attrs.iter().enumerate() {
                    map.serialize_entry(&i, &field)?;
                }
                map.end()
            }
        }
    }
    /// Data structures for ser/de of attachment-related resources
    pub mod attachment {
        //! Module containing everything related to media attachements.
        /// A struct representing a media attachment.
        pub struct Attachment {
            /// ID of the attachment.
            pub id: String,
            /// The media type of an attachment.
            #[serde(rename = "type")]
            pub media_type: MediaType,
            /// URL of the locally hosted version of the image.
            pub url: String,
            /// For remote images, the remote URL of the original image.
            pub remote_url: Option<String>,
            /// URL of the preview image.
            pub preview_url: String,
            /// Shorter URL for the image, for insertion into text
            /// (only present on local images)
            pub text_url: Option<String>,
            /// Meta information about the attachment.
            pub meta: Option<Meta>,
            /// Noop will be removed.
            pub description: Option<String>,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for Attachment {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    Attachment {
                    id: ref __self_0_0,
                    media_type: ref __self_0_1,
                    url: ref __self_0_2,
                    remote_url: ref __self_0_3,
                    preview_url: ref __self_0_4,
                    text_url: ref __self_0_5,
                    meta: ref __self_0_6,
                    description: ref __self_0_7 } => {
                        let mut debug_trait_builder =
                            f.debug_struct("Attachment");
                        let _ =
                            debug_trait_builder.field("id", &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("media_type",
                                                      &&(*__self_0_1));
                        let _ =
                            debug_trait_builder.field("url", &&(*__self_0_2));
                        let _ =
                            debug_trait_builder.field("remote_url",
                                                      &&(*__self_0_3));
                        let _ =
                            debug_trait_builder.field("preview_url",
                                                      &&(*__self_0_4));
                        let _ =
                            debug_trait_builder.field("text_url",
                                                      &&(*__self_0_5));
                        let _ =
                            debug_trait_builder.field("meta",
                                                      &&(*__self_0_6));
                        let _ =
                            debug_trait_builder.field("description",
                                                      &&(*__self_0_7));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for Attachment {
            #[inline]
            fn clone(&self) -> Attachment {
                match *self {
                    Attachment {
                    id: ref __self_0_0,
                    media_type: ref __self_0_1,
                    url: ref __self_0_2,
                    remote_url: ref __self_0_3,
                    preview_url: ref __self_0_4,
                    text_url: ref __self_0_5,
                    meta: ref __self_0_6,
                    description: ref __self_0_7 } =>
                    Attachment{id:
                                   ::core::clone::Clone::clone(&(*__self_0_0)),
                               media_type:
                                   ::core::clone::Clone::clone(&(*__self_0_1)),
                               url:
                                   ::core::clone::Clone::clone(&(*__self_0_2)),
                               remote_url:
                                   ::core::clone::Clone::clone(&(*__self_0_3)),
                               preview_url:
                                   ::core::clone::Clone::clone(&(*__self_0_4)),
                               text_url:
                                   ::core::clone::Clone::clone(&(*__self_0_5)),
                               meta:
                                   ::core::clone::Clone::clone(&(*__self_0_6)),
                               description:
                                   ::core::clone::Clone::clone(&(*__self_0_7)),},
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_Attachment: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'de> _serde::Deserialize<'de> for Attachment {
                    fn deserialize<__D>(__deserializer: __D)
                     -> _serde::export::Result<Self, __D::Error> where
                     __D: _serde::Deserializer<'de> {
                        #[allow(non_camel_case_types)]
                        enum __Field {
                            __field0,
                            __field1,
                            __field2,
                            __field3,
                            __field4,
                            __field5,
                            __field6,
                            __field7,
                            __ignore,
                        }
                        struct __FieldVisitor;
                        impl <'de> _serde::de::Visitor<'de> for __FieldVisitor
                         {
                            type Value = __Field;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "field identifier")
                            }
                            fn visit_u64<__E>(self, __value: u64)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    0u64 =>
                                    _serde::export::Ok(__Field::__field0),
                                    1u64 =>
                                    _serde::export::Ok(__Field::__field1),
                                    2u64 =>
                                    _serde::export::Ok(__Field::__field2),
                                    3u64 =>
                                    _serde::export::Ok(__Field::__field3),
                                    4u64 =>
                                    _serde::export::Ok(__Field::__field4),
                                    5u64 =>
                                    _serde::export::Ok(__Field::__field5),
                                    6u64 =>
                                    _serde::export::Ok(__Field::__field6),
                                    7u64 =>
                                    _serde::export::Ok(__Field::__field7),
                                    _ =>
                                    _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                         &"field index 0 <= i < 8")),
                                }
                            }
                            fn visit_str<__E>(self, __value: &str)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    "id" =>
                                    _serde::export::Ok(__Field::__field0),
                                    "type" =>
                                    _serde::export::Ok(__Field::__field1),
                                    "url" =>
                                    _serde::export::Ok(__Field::__field2),
                                    "remote_url" =>
                                    _serde::export::Ok(__Field::__field3),
                                    "preview_url" =>
                                    _serde::export::Ok(__Field::__field4),
                                    "text_url" =>
                                    _serde::export::Ok(__Field::__field5),
                                    "meta" =>
                                    _serde::export::Ok(__Field::__field6),
                                    "description" =>
                                    _serde::export::Ok(__Field::__field7),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                            fn visit_bytes<__E>(self, __value: &[u8])
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    b"id" =>
                                    _serde::export::Ok(__Field::__field0),
                                    b"type" =>
                                    _serde::export::Ok(__Field::__field1),
                                    b"url" =>
                                    _serde::export::Ok(__Field::__field2),
                                    b"remote_url" =>
                                    _serde::export::Ok(__Field::__field3),
                                    b"preview_url" =>
                                    _serde::export::Ok(__Field::__field4),
                                    b"text_url" =>
                                    _serde::export::Ok(__Field::__field5),
                                    b"meta" =>
                                    _serde::export::Ok(__Field::__field6),
                                    b"description" =>
                                    _serde::export::Ok(__Field::__field7),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                        }
                        impl <'de> _serde::Deserialize<'de> for __Field {
                            #[inline]
                            fn deserialize<__D>(__deserializer: __D)
                             -> _serde::export::Result<Self, __D::Error> where
                             __D: _serde::Deserializer<'de> {
                                _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                             __FieldVisitor)
                            }
                        }
                        struct __Visitor<'de> {
                            marker: _serde::export::PhantomData<Attachment>,
                            lifetime: _serde::export::PhantomData<&'de ()>,
                        }
                        impl <'de> _serde::de::Visitor<'de> for __Visitor<'de>
                         {
                            type Value = Attachment;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "struct Attachment")
                            }
                            #[inline]
                            fn visit_seq<__A>(self, mut __seq: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::SeqAccess<'de> {
                                let __field0 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                         &"struct Attachment with 8 elements"));
                                        }
                                    };
                                let __field1 =
                                    match match _serde::de::SeqAccess::next_element::<MediaType>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(1usize,
                                                                                                         &"struct Attachment with 8 elements"));
                                        }
                                    };
                                let __field2 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(2usize,
                                                                                                         &"struct Attachment with 8 elements"));
                                        }
                                    };
                                let __field3 =
                                    match match _serde::de::SeqAccess::next_element::<Option<String>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(3usize,
                                                                                                         &"struct Attachment with 8 elements"));
                                        }
                                    };
                                let __field4 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(4usize,
                                                                                                         &"struct Attachment with 8 elements"));
                                        }
                                    };
                                let __field5 =
                                    match match _serde::de::SeqAccess::next_element::<Option<String>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(5usize,
                                                                                                         &"struct Attachment with 8 elements"));
                                        }
                                    };
                                let __field6 =
                                    match match _serde::de::SeqAccess::next_element::<Option<Meta>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(6usize,
                                                                                                         &"struct Attachment with 8 elements"));
                                        }
                                    };
                                let __field7 =
                                    match match _serde::de::SeqAccess::next_element::<Option<String>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(7usize,
                                                                                                         &"struct Attachment with 8 elements"));
                                        }
                                    };
                                _serde::export::Ok(Attachment{id: __field0,
                                                              media_type:
                                                                  __field1,
                                                              url: __field2,
                                                              remote_url:
                                                                  __field3,
                                                              preview_url:
                                                                  __field4,
                                                              text_url:
                                                                  __field5,
                                                              meta: __field6,
                                                              description:
                                                                  __field7,})
                            }
                            #[inline]
                            fn visit_map<__A>(self, mut __map: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::MapAccess<'de> {
                                let mut __field0:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field1:
                                        _serde::export::Option<MediaType> =
                                    _serde::export::None;
                                let mut __field2:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field3:
                                        _serde::export::Option<Option<String>> =
                                    _serde::export::None;
                                let mut __field4:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field5:
                                        _serde::export::Option<Option<String>> =
                                    _serde::export::None;
                                let mut __field6:
                                        _serde::export::Option<Option<Meta>> =
                                    _serde::export::None;
                                let mut __field7:
                                        _serde::export::Option<Option<String>> =
                                    _serde::export::None;
                                while let _serde::export::Some(__key) =
                                          match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                    match __key {
                                        __Field::__field0 => {
                                            if _serde::export::Option::is_some(&__field0)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("id"));
                                            }
                                            __field0 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field1 => {
                                            if _serde::export::Option::is_some(&__field1)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("type"));
                                            }
                                            __field1 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<MediaType>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field2 => {
                                            if _serde::export::Option::is_some(&__field2)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("url"));
                                            }
                                            __field2 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field3 => {
                                            if _serde::export::Option::is_some(&__field3)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("remote_url"));
                                            }
                                            __field3 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<String>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field4 => {
                                            if _serde::export::Option::is_some(&__field4)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("preview_url"));
                                            }
                                            __field4 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field5 => {
                                            if _serde::export::Option::is_some(&__field5)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("text_url"));
                                            }
                                            __field5 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<String>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field6 => {
                                            if _serde::export::Option::is_some(&__field6)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("meta"));
                                            }
                                            __field6 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<Meta>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field7 => {
                                            if _serde::export::Option::is_some(&__field7)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("description"));
                                            }
                                            __field7 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<String>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        _ => {
                                            let _ =
                                                match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                    {
                                                    _serde::export::Ok(__val)
                                                    => __val,
                                                    _serde::export::Err(__err)
                                                    => {
                                                        return _serde::export::Err(__err);
                                                    }
                                                };
                                        }
                                    }
                                }
                                let __field0 =
                                    match __field0 {
                                        _serde::export::Some(__field0) =>
                                        __field0,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("id")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field1 =
                                    match __field1 {
                                        _serde::export::Some(__field1) =>
                                        __field1,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("type")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field2 =
                                    match __field2 {
                                        _serde::export::Some(__field2) =>
                                        __field2,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("url")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field3 =
                                    match __field3 {
                                        _serde::export::Some(__field3) =>
                                        __field3,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("remote_url")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field4 =
                                    match __field4 {
                                        _serde::export::Some(__field4) =>
                                        __field4,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("preview_url")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field5 =
                                    match __field5 {
                                        _serde::export::Some(__field5) =>
                                        __field5,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("text_url")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field6 =
                                    match __field6 {
                                        _serde::export::Some(__field6) =>
                                        __field6,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("meta")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field7 =
                                    match __field7 {
                                        _serde::export::Some(__field7) =>
                                        __field7,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("description")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                _serde::export::Ok(Attachment{id: __field0,
                                                              media_type:
                                                                  __field1,
                                                              url: __field2,
                                                              remote_url:
                                                                  __field3,
                                                              preview_url:
                                                                  __field4,
                                                              text_url:
                                                                  __field5,
                                                              meta: __field6,
                                                              description:
                                                                  __field7,})
                            }
                        }
                        const FIELDS: &'static [&'static str] =
                            &["id", "type", "url", "remote_url",
                              "preview_url", "text_url", "meta",
                              "description"];
                        _serde::Deserializer::deserialize_struct(__deserializer,
                                                                 "Attachment",
                                                                 FIELDS,
                                                                 __Visitor{marker:
                                                                               _serde::export::PhantomData::<Attachment>,
                                                                           lifetime:
                                                                               _serde::export::PhantomData,})
                    }
                }
            };
        impl ::core::marker::StructuralPartialEq for Attachment { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for Attachment {
            #[inline]
            fn eq(&self, other: &Attachment) -> bool {
                match *other {
                    Attachment {
                    id: ref __self_1_0,
                    media_type: ref __self_1_1,
                    url: ref __self_1_2,
                    remote_url: ref __self_1_3,
                    preview_url: ref __self_1_4,
                    text_url: ref __self_1_5,
                    meta: ref __self_1_6,
                    description: ref __self_1_7 } =>
                    match *self {
                        Attachment {
                        id: ref __self_0_0,
                        media_type: ref __self_0_1,
                        url: ref __self_0_2,
                        remote_url: ref __self_0_3,
                        preview_url: ref __self_0_4,
                        text_url: ref __self_0_5,
                        meta: ref __self_0_6,
                        description: ref __self_0_7 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1) &&
                            (*__self_0_2) == (*__self_1_2) &&
                            (*__self_0_3) == (*__self_1_3) &&
                            (*__self_0_4) == (*__self_1_4) &&
                            (*__self_0_5) == (*__self_1_5) &&
                            (*__self_0_6) == (*__self_1_6) &&
                            (*__self_0_7) == (*__self_1_7),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &Attachment) -> bool {
                match *other {
                    Attachment {
                    id: ref __self_1_0,
                    media_type: ref __self_1_1,
                    url: ref __self_1_2,
                    remote_url: ref __self_1_3,
                    preview_url: ref __self_1_4,
                    text_url: ref __self_1_5,
                    meta: ref __self_1_6,
                    description: ref __self_1_7 } =>
                    match *self {
                        Attachment {
                        id: ref __self_0_0,
                        media_type: ref __self_0_1,
                        url: ref __self_0_2,
                        remote_url: ref __self_0_3,
                        preview_url: ref __self_0_4,
                        text_url: ref __self_0_5,
                        meta: ref __self_0_6,
                        description: ref __self_0_7 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1) ||
                            (*__self_0_2) != (*__self_1_2) ||
                            (*__self_0_3) != (*__self_1_3) ||
                            (*__self_0_4) != (*__self_1_4) ||
                            (*__self_0_5) != (*__self_1_5) ||
                            (*__self_0_6) != (*__self_1_6) ||
                            (*__self_0_7) != (*__self_1_7),
                    },
                }
            }
        }
        /// Information about the attachment itself.
        pub struct Meta {
            /// Original version.
            pub original: Option<ImageDetails>,
            /// Smaller version.
            pub small: Option<ImageDetails>,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for Meta {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    Meta { original: ref __self_0_0, small: ref __self_0_1 }
                    => {
                        let mut debug_trait_builder = f.debug_struct("Meta");
                        let _ =
                            debug_trait_builder.field("original",
                                                      &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("small",
                                                      &&(*__self_0_1));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_Meta: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'de> _serde::Deserialize<'de> for Meta {
                    fn deserialize<__D>(__deserializer: __D)
                     -> _serde::export::Result<Self, __D::Error> where
                     __D: _serde::Deserializer<'de> {
                        #[allow(non_camel_case_types)]
                        enum __Field { __field0, __field1, __ignore, }
                        struct __FieldVisitor;
                        impl <'de> _serde::de::Visitor<'de> for __FieldVisitor
                         {
                            type Value = __Field;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "field identifier")
                            }
                            fn visit_u64<__E>(self, __value: u64)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    0u64 =>
                                    _serde::export::Ok(__Field::__field0),
                                    1u64 =>
                                    _serde::export::Ok(__Field::__field1),
                                    _ =>
                                    _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                         &"field index 0 <= i < 2")),
                                }
                            }
                            fn visit_str<__E>(self, __value: &str)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    "original" =>
                                    _serde::export::Ok(__Field::__field0),
                                    "small" =>
                                    _serde::export::Ok(__Field::__field1),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                            fn visit_bytes<__E>(self, __value: &[u8])
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    b"original" =>
                                    _serde::export::Ok(__Field::__field0),
                                    b"small" =>
                                    _serde::export::Ok(__Field::__field1),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                        }
                        impl <'de> _serde::Deserialize<'de> for __Field {
                            #[inline]
                            fn deserialize<__D>(__deserializer: __D)
                             -> _serde::export::Result<Self, __D::Error> where
                             __D: _serde::Deserializer<'de> {
                                _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                             __FieldVisitor)
                            }
                        }
                        struct __Visitor<'de> {
                            marker: _serde::export::PhantomData<Meta>,
                            lifetime: _serde::export::PhantomData<&'de ()>,
                        }
                        impl <'de> _serde::de::Visitor<'de> for __Visitor<'de>
                         {
                            type Value = Meta;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "struct Meta")
                            }
                            #[inline]
                            fn visit_seq<__A>(self, mut __seq: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::SeqAccess<'de> {
                                let __field0 =
                                    match match _serde::de::SeqAccess::next_element::<Option<ImageDetails>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                         &"struct Meta with 2 elements"));
                                        }
                                    };
                                let __field1 =
                                    match match _serde::de::SeqAccess::next_element::<Option<ImageDetails>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(1usize,
                                                                                                         &"struct Meta with 2 elements"));
                                        }
                                    };
                                _serde::export::Ok(Meta{original: __field0,
                                                        small: __field1,})
                            }
                            #[inline]
                            fn visit_map<__A>(self, mut __map: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::MapAccess<'de> {
                                let mut __field0:
                                        _serde::export::Option<Option<ImageDetails>> =
                                    _serde::export::None;
                                let mut __field1:
                                        _serde::export::Option<Option<ImageDetails>> =
                                    _serde::export::None;
                                while let _serde::export::Some(__key) =
                                          match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                    match __key {
                                        __Field::__field0 => {
                                            if _serde::export::Option::is_some(&__field0)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("original"));
                                            }
                                            __field0 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<ImageDetails>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field1 => {
                                            if _serde::export::Option::is_some(&__field1)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("small"));
                                            }
                                            __field1 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<ImageDetails>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        _ => {
                                            let _ =
                                                match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                    {
                                                    _serde::export::Ok(__val)
                                                    => __val,
                                                    _serde::export::Err(__err)
                                                    => {
                                                        return _serde::export::Err(__err);
                                                    }
                                                };
                                        }
                                    }
                                }
                                let __field0 =
                                    match __field0 {
                                        _serde::export::Some(__field0) =>
                                        __field0,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("original")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field1 =
                                    match __field1 {
                                        _serde::export::Some(__field1) =>
                                        __field1,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("small")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                _serde::export::Ok(Meta{original: __field0,
                                                        small: __field1,})
                            }
                        }
                        const FIELDS: &'static [&'static str] =
                            &["original", "small"];
                        _serde::Deserializer::deserialize_struct(__deserializer,
                                                                 "Meta",
                                                                 FIELDS,
                                                                 __Visitor{marker:
                                                                               _serde::export::PhantomData::<Meta>,
                                                                           lifetime:
                                                                               _serde::export::PhantomData,})
                    }
                }
            };
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for Meta {
            #[inline]
            fn clone(&self) -> Meta {
                match *self {
                    Meta { original: ref __self_0_0, small: ref __self_0_1 }
                    =>
                    Meta{original:
                             ::core::clone::Clone::clone(&(*__self_0_0)),
                         small: ::core::clone::Clone::clone(&(*__self_0_1)),},
                }
            }
        }
        impl ::core::marker::StructuralPartialEq for Meta { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for Meta {
            #[inline]
            fn eq(&self, other: &Meta) -> bool {
                match *other {
                    Meta { original: ref __self_1_0, small: ref __self_1_1 }
                    =>
                    match *self {
                        Meta { original: ref __self_0_0, small: ref __self_0_1
                        } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &Meta) -> bool {
                match *other {
                    Meta { original: ref __self_1_0, small: ref __self_1_1 }
                    =>
                    match *self {
                        Meta { original: ref __self_0_0, small: ref __self_0_1
                        } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1),
                    },
                }
            }
        }
        /// Dimensions of an attachement.
        pub struct ImageDetails {
            /// width of attachment.
            width: u64,
            /// height of attachment.
            height: u64,
            /// A string of `widthxheight`.
            size: Option<String>,
            /// The aspect ratio of the attachment.
            aspect: Option<f64>,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for ImageDetails {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    ImageDetails {
                    width: ref __self_0_0,
                    height: ref __self_0_1,
                    size: ref __self_0_2,
                    aspect: ref __self_0_3 } => {
                        let mut debug_trait_builder =
                            f.debug_struct("ImageDetails");
                        let _ =
                            debug_trait_builder.field("width",
                                                      &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("height",
                                                      &&(*__self_0_1));
                        let _ =
                            debug_trait_builder.field("size",
                                                      &&(*__self_0_2));
                        let _ =
                            debug_trait_builder.field("aspect",
                                                      &&(*__self_0_3));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_ImageDetails: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'de> _serde::Deserialize<'de> for ImageDetails {
                    fn deserialize<__D>(__deserializer: __D)
                     -> _serde::export::Result<Self, __D::Error> where
                     __D: _serde::Deserializer<'de> {
                        #[allow(non_camel_case_types)]
                        enum __Field {
                            __field0,
                            __field1,
                            __field2,
                            __field3,
                            __ignore,
                        }
                        struct __FieldVisitor;
                        impl <'de> _serde::de::Visitor<'de> for __FieldVisitor
                         {
                            type Value = __Field;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "field identifier")
                            }
                            fn visit_u64<__E>(self, __value: u64)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    0u64 =>
                                    _serde::export::Ok(__Field::__field0),
                                    1u64 =>
                                    _serde::export::Ok(__Field::__field1),
                                    2u64 =>
                                    _serde::export::Ok(__Field::__field2),
                                    3u64 =>
                                    _serde::export::Ok(__Field::__field3),
                                    _ =>
                                    _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                         &"field index 0 <= i < 4")),
                                }
                            }
                            fn visit_str<__E>(self, __value: &str)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    "width" =>
                                    _serde::export::Ok(__Field::__field0),
                                    "height" =>
                                    _serde::export::Ok(__Field::__field1),
                                    "size" =>
                                    _serde::export::Ok(__Field::__field2),
                                    "aspect" =>
                                    _serde::export::Ok(__Field::__field3),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                            fn visit_bytes<__E>(self, __value: &[u8])
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    b"width" =>
                                    _serde::export::Ok(__Field::__field0),
                                    b"height" =>
                                    _serde::export::Ok(__Field::__field1),
                                    b"size" =>
                                    _serde::export::Ok(__Field::__field2),
                                    b"aspect" =>
                                    _serde::export::Ok(__Field::__field3),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                        }
                        impl <'de> _serde::Deserialize<'de> for __Field {
                            #[inline]
                            fn deserialize<__D>(__deserializer: __D)
                             -> _serde::export::Result<Self, __D::Error> where
                             __D: _serde::Deserializer<'de> {
                                _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                             __FieldVisitor)
                            }
                        }
                        struct __Visitor<'de> {
                            marker: _serde::export::PhantomData<ImageDetails>,
                            lifetime: _serde::export::PhantomData<&'de ()>,
                        }
                        impl <'de> _serde::de::Visitor<'de> for __Visitor<'de>
                         {
                            type Value = ImageDetails;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "struct ImageDetails")
                            }
                            #[inline]
                            fn visit_seq<__A>(self, mut __seq: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::SeqAccess<'de> {
                                let __field0 =
                                    match match _serde::de::SeqAccess::next_element::<u64>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                         &"struct ImageDetails with 4 elements"));
                                        }
                                    };
                                let __field1 =
                                    match match _serde::de::SeqAccess::next_element::<u64>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(1usize,
                                                                                                         &"struct ImageDetails with 4 elements"));
                                        }
                                    };
                                let __field2 =
                                    match match _serde::de::SeqAccess::next_element::<Option<String>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(2usize,
                                                                                                         &"struct ImageDetails with 4 elements"));
                                        }
                                    };
                                let __field3 =
                                    match match _serde::de::SeqAccess::next_element::<Option<f64>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(3usize,
                                                                                                         &"struct ImageDetails with 4 elements"));
                                        }
                                    };
                                _serde::export::Ok(ImageDetails{width:
                                                                    __field0,
                                                                height:
                                                                    __field1,
                                                                size:
                                                                    __field2,
                                                                aspect:
                                                                    __field3,})
                            }
                            #[inline]
                            fn visit_map<__A>(self, mut __map: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::MapAccess<'de> {
                                let mut __field0:
                                        _serde::export::Option<u64> =
                                    _serde::export::None;
                                let mut __field1:
                                        _serde::export::Option<u64> =
                                    _serde::export::None;
                                let mut __field2:
                                        _serde::export::Option<Option<String>> =
                                    _serde::export::None;
                                let mut __field3:
                                        _serde::export::Option<Option<f64>> =
                                    _serde::export::None;
                                while let _serde::export::Some(__key) =
                                          match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                    match __key {
                                        __Field::__field0 => {
                                            if _serde::export::Option::is_some(&__field0)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("width"));
                                            }
                                            __field0 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<u64>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field1 => {
                                            if _serde::export::Option::is_some(&__field1)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("height"));
                                            }
                                            __field1 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<u64>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field2 => {
                                            if _serde::export::Option::is_some(&__field2)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("size"));
                                            }
                                            __field2 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<String>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field3 => {
                                            if _serde::export::Option::is_some(&__field3)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("aspect"));
                                            }
                                            __field3 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<f64>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        _ => {
                                            let _ =
                                                match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                    {
                                                    _serde::export::Ok(__val)
                                                    => __val,
                                                    _serde::export::Err(__err)
                                                    => {
                                                        return _serde::export::Err(__err);
                                                    }
                                                };
                                        }
                                    }
                                }
                                let __field0 =
                                    match __field0 {
                                        _serde::export::Some(__field0) =>
                                        __field0,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("width")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field1 =
                                    match __field1 {
                                        _serde::export::Some(__field1) =>
                                        __field1,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("height")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field2 =
                                    match __field2 {
                                        _serde::export::Some(__field2) =>
                                        __field2,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("size")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field3 =
                                    match __field3 {
                                        _serde::export::Some(__field3) =>
                                        __field3,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("aspect")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                _serde::export::Ok(ImageDetails{width:
                                                                    __field0,
                                                                height:
                                                                    __field1,
                                                                size:
                                                                    __field2,
                                                                aspect:
                                                                    __field3,})
                            }
                        }
                        const FIELDS: &'static [&'static str] =
                            &["width", "height", "size", "aspect"];
                        _serde::Deserializer::deserialize_struct(__deserializer,
                                                                 "ImageDetails",
                                                                 FIELDS,
                                                                 __Visitor{marker:
                                                                               _serde::export::PhantomData::<ImageDetails>,
                                                                           lifetime:
                                                                               _serde::export::PhantomData,})
                    }
                }
            };
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for ImageDetails {
            #[inline]
            fn clone(&self) -> ImageDetails {
                match *self {
                    ImageDetails {
                    width: ref __self_0_0,
                    height: ref __self_0_1,
                    size: ref __self_0_2,
                    aspect: ref __self_0_3 } =>
                    ImageDetails{width:
                                     ::core::clone::Clone::clone(&(*__self_0_0)),
                                 height:
                                     ::core::clone::Clone::clone(&(*__self_0_1)),
                                 size:
                                     ::core::clone::Clone::clone(&(*__self_0_2)),
                                 aspect:
                                     ::core::clone::Clone::clone(&(*__self_0_3)),},
                }
            }
        }
        impl ::core::marker::StructuralPartialEq for ImageDetails { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for ImageDetails {
            #[inline]
            fn eq(&self, other: &ImageDetails) -> bool {
                match *other {
                    ImageDetails {
                    width: ref __self_1_0,
                    height: ref __self_1_1,
                    size: ref __self_1_2,
                    aspect: ref __self_1_3 } =>
                    match *self {
                        ImageDetails {
                        width: ref __self_0_0,
                        height: ref __self_0_1,
                        size: ref __self_0_2,
                        aspect: ref __self_0_3 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1) &&
                            (*__self_0_2) == (*__self_1_2) &&
                            (*__self_0_3) == (*__self_1_3),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &ImageDetails) -> bool {
                match *other {
                    ImageDetails {
                    width: ref __self_1_0,
                    height: ref __self_1_1,
                    size: ref __self_1_2,
                    aspect: ref __self_1_3 } =>
                    match *self {
                        ImageDetails {
                        width: ref __self_0_0,
                        height: ref __self_0_1,
                        size: ref __self_0_2,
                        aspect: ref __self_0_3 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1) ||
                            (*__self_0_2) != (*__self_1_2) ||
                            (*__self_0_3) != (*__self_1_3),
                    },
                }
            }
        }
        /// The type of media attachment.
        pub enum MediaType {

            /// An image.
            #[serde(rename = "image")]
            Image,

            /// A video file.
            #[serde(rename = "video")]
            Video,

            /// A gifv format file.
            #[serde(rename = "gifv")]
            Gifv,

            /// Unknown format.
            #[serde(rename = "unknown")]
            Unknown,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for MediaType {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match (&*self,) {
                    (&MediaType::Image,) => {
                        let mut debug_trait_builder = f.debug_tuple("Image");
                        debug_trait_builder.finish()
                    }
                    (&MediaType::Video,) => {
                        let mut debug_trait_builder = f.debug_tuple("Video");
                        debug_trait_builder.finish()
                    }
                    (&MediaType::Gifv,) => {
                        let mut debug_trait_builder = f.debug_tuple("Gifv");
                        debug_trait_builder.finish()
                    }
                    (&MediaType::Unknown,) => {
                        let mut debug_trait_builder =
                            f.debug_tuple("Unknown");
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_MediaType: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'de> _serde::Deserialize<'de> for MediaType {
                    fn deserialize<__D>(__deserializer: __D)
                     -> _serde::export::Result<Self, __D::Error> where
                     __D: _serde::Deserializer<'de> {
                        #[allow(non_camel_case_types)]
                        enum __Field {
                            __field0,
                            __field1,
                            __field2,
                            __field3,
                        }
                        struct __FieldVisitor;
                        impl <'de> _serde::de::Visitor<'de> for __FieldVisitor
                         {
                            type Value = __Field;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "variant identifier")
                            }
                            fn visit_u64<__E>(self, __value: u64)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    0u64 =>
                                    _serde::export::Ok(__Field::__field0),
                                    1u64 =>
                                    _serde::export::Ok(__Field::__field1),
                                    2u64 =>
                                    _serde::export::Ok(__Field::__field2),
                                    3u64 =>
                                    _serde::export::Ok(__Field::__field3),
                                    _ =>
                                    _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                         &"variant index 0 <= i < 4")),
                                }
                            }
                            fn visit_str<__E>(self, __value: &str)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    "image" =>
                                    _serde::export::Ok(__Field::__field0),
                                    "video" =>
                                    _serde::export::Ok(__Field::__field1),
                                    "gifv" =>
                                    _serde::export::Ok(__Field::__field2),
                                    "unknown" =>
                                    _serde::export::Ok(__Field::__field3),
                                    _ => {
                                        _serde::export::Err(_serde::de::Error::unknown_variant(__value,
                                                                                               VARIANTS))
                                    }
                                }
                            }
                            fn visit_bytes<__E>(self, __value: &[u8])
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    b"image" =>
                                    _serde::export::Ok(__Field::__field0),
                                    b"video" =>
                                    _serde::export::Ok(__Field::__field1),
                                    b"gifv" =>
                                    _serde::export::Ok(__Field::__field2),
                                    b"unknown" =>
                                    _serde::export::Ok(__Field::__field3),
                                    _ => {
                                        let __value =
                                            &_serde::export::from_utf8_lossy(__value);
                                        _serde::export::Err(_serde::de::Error::unknown_variant(__value,
                                                                                               VARIANTS))
                                    }
                                }
                            }
                        }
                        impl <'de> _serde::Deserialize<'de> for __Field {
                            #[inline]
                            fn deserialize<__D>(__deserializer: __D)
                             -> _serde::export::Result<Self, __D::Error> where
                             __D: _serde::Deserializer<'de> {
                                _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                             __FieldVisitor)
                            }
                        }
                        struct __Visitor<'de> {
                            marker: _serde::export::PhantomData<MediaType>,
                            lifetime: _serde::export::PhantomData<&'de ()>,
                        }
                        impl <'de> _serde::de::Visitor<'de> for __Visitor<'de>
                         {
                            type Value = MediaType;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "enum MediaType")
                            }
                            fn visit_enum<__A>(self, __data: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::EnumAccess<'de> {
                                match match _serde::de::EnumAccess::variant(__data)
                                          {
                                          _serde::export::Ok(__val) => __val,
                                          _serde::export::Err(__err) => {
                                              return _serde::export::Err(__err);
                                          }
                                      } {
                                    (__Field::__field0, __variant) => {
                                        match _serde::de::VariantAccess::unit_variant(__variant)
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        };
                                        _serde::export::Ok(MediaType::Image)
                                    }
                                    (__Field::__field1, __variant) => {
                                        match _serde::de::VariantAccess::unit_variant(__variant)
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        };
                                        _serde::export::Ok(MediaType::Video)
                                    }
                                    (__Field::__field2, __variant) => {
                                        match _serde::de::VariantAccess::unit_variant(__variant)
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        };
                                        _serde::export::Ok(MediaType::Gifv)
                                    }
                                    (__Field::__field3, __variant) => {
                                        match _serde::de::VariantAccess::unit_variant(__variant)
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        };
                                        _serde::export::Ok(MediaType::Unknown)
                                    }
                                }
                            }
                        }
                        const VARIANTS: &'static [&'static str] =
                            &["image", "video", "gifv", "unknown"];
                        _serde::Deserializer::deserialize_enum(__deserializer,
                                                               "MediaType",
                                                               VARIANTS,
                                                               __Visitor{marker:
                                                                             _serde::export::PhantomData::<MediaType>,
                                                                         lifetime:
                                                                             _serde::export::PhantomData,})
                    }
                }
            };
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for MediaType {
            #[inline]
            fn clone(&self) -> MediaType { { *self } }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::marker::Copy for MediaType { }
        impl ::core::marker::StructuralPartialEq for MediaType { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for MediaType {
            #[inline]
            fn eq(&self, other: &MediaType) -> bool {
                {
                    let __self_vi =
                        unsafe {
                            ::core::intrinsics::discriminant_value(&*self)
                        };
                    let __arg_1_vi =
                        unsafe {
                            ::core::intrinsics::discriminant_value(&*other)
                        };
                    if true && __self_vi == __arg_1_vi {
                        match (&*self, &*other) { _ => true, }
                    } else { false }
                }
            }
        }
    }
    /// Data structures for ser/de of card-related resources
    pub mod card {
        //! Module representing cards of statuses.
        /// A card of a status.
        pub struct Card {
            /// The url associated with the card.
            pub url: String,
            /// The title of the card.
            pub title: String,
            /// The card description.
            pub description: String,
            /// The image associated with the card, if any.
            pub image: Option<String>,
            /// OEmbed data
            author_name: Option<String>,
            /// OEmbed data
            author_url: Option<String>,
            /// OEmbed data
            provider_name: Option<String>,
            /// OEmbed data
            provider_url: Option<String>,
            /// OEmbed data
            html: Option<String>,
            /// OEmbed data
            width: Option<u64>,
            /// OEmbed data
            height: Option<u64>,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for Card {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    Card {
                    url: ref __self_0_0,
                    title: ref __self_0_1,
                    description: ref __self_0_2,
                    image: ref __self_0_3,
                    author_name: ref __self_0_4,
                    author_url: ref __self_0_5,
                    provider_name: ref __self_0_6,
                    provider_url: ref __self_0_7,
                    html: ref __self_0_8,
                    width: ref __self_0_9,
                    height: ref __self_0_10 } => {
                        let mut debug_trait_builder = f.debug_struct("Card");
                        let _ =
                            debug_trait_builder.field("url", &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("title",
                                                      &&(*__self_0_1));
                        let _ =
                            debug_trait_builder.field("description",
                                                      &&(*__self_0_2));
                        let _ =
                            debug_trait_builder.field("image",
                                                      &&(*__self_0_3));
                        let _ =
                            debug_trait_builder.field("author_name",
                                                      &&(*__self_0_4));
                        let _ =
                            debug_trait_builder.field("author_url",
                                                      &&(*__self_0_5));
                        let _ =
                            debug_trait_builder.field("provider_name",
                                                      &&(*__self_0_6));
                        let _ =
                            debug_trait_builder.field("provider_url",
                                                      &&(*__self_0_7));
                        let _ =
                            debug_trait_builder.field("html",
                                                      &&(*__self_0_8));
                        let _ =
                            debug_trait_builder.field("width",
                                                      &&(*__self_0_9));
                        let _ =
                            debug_trait_builder.field("height",
                                                      &&(*__self_0_10));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for Card {
            #[inline]
            fn clone(&self) -> Card {
                match *self {
                    Card {
                    url: ref __self_0_0,
                    title: ref __self_0_1,
                    description: ref __self_0_2,
                    image: ref __self_0_3,
                    author_name: ref __self_0_4,
                    author_url: ref __self_0_5,
                    provider_name: ref __self_0_6,
                    provider_url: ref __self_0_7,
                    html: ref __self_0_8,
                    width: ref __self_0_9,
                    height: ref __self_0_10 } =>
                    Card{url: ::core::clone::Clone::clone(&(*__self_0_0)),
                         title: ::core::clone::Clone::clone(&(*__self_0_1)),
                         description:
                             ::core::clone::Clone::clone(&(*__self_0_2)),
                         image: ::core::clone::Clone::clone(&(*__self_0_3)),
                         author_name:
                             ::core::clone::Clone::clone(&(*__self_0_4)),
                         author_url:
                             ::core::clone::Clone::clone(&(*__self_0_5)),
                         provider_name:
                             ::core::clone::Clone::clone(&(*__self_0_6)),
                         provider_url:
                             ::core::clone::Clone::clone(&(*__self_0_7)),
                         html: ::core::clone::Clone::clone(&(*__self_0_8)),
                         width: ::core::clone::Clone::clone(&(*__self_0_9)),
                         height:
                             ::core::clone::Clone::clone(&(*__self_0_10)),},
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_Card: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'de> _serde::Deserialize<'de> for Card {
                    fn deserialize<__D>(__deserializer: __D)
                     -> _serde::export::Result<Self, __D::Error> where
                     __D: _serde::Deserializer<'de> {
                        #[allow(non_camel_case_types)]
                        enum __Field {
                            __field0,
                            __field1,
                            __field2,
                            __field3,
                            __field4,
                            __field5,
                            __field6,
                            __field7,
                            __field8,
                            __field9,
                            __field10,
                            __ignore,
                        }
                        struct __FieldVisitor;
                        impl <'de> _serde::de::Visitor<'de> for __FieldVisitor
                         {
                            type Value = __Field;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "field identifier")
                            }
                            fn visit_u64<__E>(self, __value: u64)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    0u64 =>
                                    _serde::export::Ok(__Field::__field0),
                                    1u64 =>
                                    _serde::export::Ok(__Field::__field1),
                                    2u64 =>
                                    _serde::export::Ok(__Field::__field2),
                                    3u64 =>
                                    _serde::export::Ok(__Field::__field3),
                                    4u64 =>
                                    _serde::export::Ok(__Field::__field4),
                                    5u64 =>
                                    _serde::export::Ok(__Field::__field5),
                                    6u64 =>
                                    _serde::export::Ok(__Field::__field6),
                                    7u64 =>
                                    _serde::export::Ok(__Field::__field7),
                                    8u64 =>
                                    _serde::export::Ok(__Field::__field8),
                                    9u64 =>
                                    _serde::export::Ok(__Field::__field9),
                                    10u64 =>
                                    _serde::export::Ok(__Field::__field10),
                                    _ =>
                                    _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                         &"field index 0 <= i < 11")),
                                }
                            }
                            fn visit_str<__E>(self, __value: &str)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    "url" =>
                                    _serde::export::Ok(__Field::__field0),
                                    "title" =>
                                    _serde::export::Ok(__Field::__field1),
                                    "description" =>
                                    _serde::export::Ok(__Field::__field2),
                                    "image" =>
                                    _serde::export::Ok(__Field::__field3),
                                    "author_name" =>
                                    _serde::export::Ok(__Field::__field4),
                                    "author_url" =>
                                    _serde::export::Ok(__Field::__field5),
                                    "provider_name" =>
                                    _serde::export::Ok(__Field::__field6),
                                    "provider_url" =>
                                    _serde::export::Ok(__Field::__field7),
                                    "html" =>
                                    _serde::export::Ok(__Field::__field8),
                                    "width" =>
                                    _serde::export::Ok(__Field::__field9),
                                    "height" =>
                                    _serde::export::Ok(__Field::__field10),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                            fn visit_bytes<__E>(self, __value: &[u8])
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    b"url" =>
                                    _serde::export::Ok(__Field::__field0),
                                    b"title" =>
                                    _serde::export::Ok(__Field::__field1),
                                    b"description" =>
                                    _serde::export::Ok(__Field::__field2),
                                    b"image" =>
                                    _serde::export::Ok(__Field::__field3),
                                    b"author_name" =>
                                    _serde::export::Ok(__Field::__field4),
                                    b"author_url" =>
                                    _serde::export::Ok(__Field::__field5),
                                    b"provider_name" =>
                                    _serde::export::Ok(__Field::__field6),
                                    b"provider_url" =>
                                    _serde::export::Ok(__Field::__field7),
                                    b"html" =>
                                    _serde::export::Ok(__Field::__field8),
                                    b"width" =>
                                    _serde::export::Ok(__Field::__field9),
                                    b"height" =>
                                    _serde::export::Ok(__Field::__field10),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                        }
                        impl <'de> _serde::Deserialize<'de> for __Field {
                            #[inline]
                            fn deserialize<__D>(__deserializer: __D)
                             -> _serde::export::Result<Self, __D::Error> where
                             __D: _serde::Deserializer<'de> {
                                _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                             __FieldVisitor)
                            }
                        }
                        struct __Visitor<'de> {
                            marker: _serde::export::PhantomData<Card>,
                            lifetime: _serde::export::PhantomData<&'de ()>,
                        }
                        impl <'de> _serde::de::Visitor<'de> for __Visitor<'de>
                         {
                            type Value = Card;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "struct Card")
                            }
                            #[inline]
                            fn visit_seq<__A>(self, mut __seq: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::SeqAccess<'de> {
                                let __field0 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                         &"struct Card with 11 elements"));
                                        }
                                    };
                                let __field1 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(1usize,
                                                                                                         &"struct Card with 11 elements"));
                                        }
                                    };
                                let __field2 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(2usize,
                                                                                                         &"struct Card with 11 elements"));
                                        }
                                    };
                                let __field3 =
                                    match match _serde::de::SeqAccess::next_element::<Option<String>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(3usize,
                                                                                                         &"struct Card with 11 elements"));
                                        }
                                    };
                                let __field4 =
                                    match match _serde::de::SeqAccess::next_element::<Option<String>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(4usize,
                                                                                                         &"struct Card with 11 elements"));
                                        }
                                    };
                                let __field5 =
                                    match match _serde::de::SeqAccess::next_element::<Option<String>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(5usize,
                                                                                                         &"struct Card with 11 elements"));
                                        }
                                    };
                                let __field6 =
                                    match match _serde::de::SeqAccess::next_element::<Option<String>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(6usize,
                                                                                                         &"struct Card with 11 elements"));
                                        }
                                    };
                                let __field7 =
                                    match match _serde::de::SeqAccess::next_element::<Option<String>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(7usize,
                                                                                                         &"struct Card with 11 elements"));
                                        }
                                    };
                                let __field8 =
                                    match match _serde::de::SeqAccess::next_element::<Option<String>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(8usize,
                                                                                                         &"struct Card with 11 elements"));
                                        }
                                    };
                                let __field9 =
                                    match match _serde::de::SeqAccess::next_element::<Option<u64>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(9usize,
                                                                                                         &"struct Card with 11 elements"));
                                        }
                                    };
                                let __field10 =
                                    match match _serde::de::SeqAccess::next_element::<Option<u64>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(10usize,
                                                                                                         &"struct Card with 11 elements"));
                                        }
                                    };
                                _serde::export::Ok(Card{url: __field0,
                                                        title: __field1,
                                                        description: __field2,
                                                        image: __field3,
                                                        author_name: __field4,
                                                        author_url: __field5,
                                                        provider_name:
                                                            __field6,
                                                        provider_url:
                                                            __field7,
                                                        html: __field8,
                                                        width: __field9,
                                                        height: __field10,})
                            }
                            #[inline]
                            fn visit_map<__A>(self, mut __map: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::MapAccess<'de> {
                                let mut __field0:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field1:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field2:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field3:
                                        _serde::export::Option<Option<String>> =
                                    _serde::export::None;
                                let mut __field4:
                                        _serde::export::Option<Option<String>> =
                                    _serde::export::None;
                                let mut __field5:
                                        _serde::export::Option<Option<String>> =
                                    _serde::export::None;
                                let mut __field6:
                                        _serde::export::Option<Option<String>> =
                                    _serde::export::None;
                                let mut __field7:
                                        _serde::export::Option<Option<String>> =
                                    _serde::export::None;
                                let mut __field8:
                                        _serde::export::Option<Option<String>> =
                                    _serde::export::None;
                                let mut __field9:
                                        _serde::export::Option<Option<u64>> =
                                    _serde::export::None;
                                let mut __field10:
                                        _serde::export::Option<Option<u64>> =
                                    _serde::export::None;
                                while let _serde::export::Some(__key) =
                                          match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                    match __key {
                                        __Field::__field0 => {
                                            if _serde::export::Option::is_some(&__field0)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("url"));
                                            }
                                            __field0 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field1 => {
                                            if _serde::export::Option::is_some(&__field1)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("title"));
                                            }
                                            __field1 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field2 => {
                                            if _serde::export::Option::is_some(&__field2)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("description"));
                                            }
                                            __field2 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field3 => {
                                            if _serde::export::Option::is_some(&__field3)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("image"));
                                            }
                                            __field3 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<String>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field4 => {
                                            if _serde::export::Option::is_some(&__field4)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("author_name"));
                                            }
                                            __field4 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<String>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field5 => {
                                            if _serde::export::Option::is_some(&__field5)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("author_url"));
                                            }
                                            __field5 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<String>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field6 => {
                                            if _serde::export::Option::is_some(&__field6)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("provider_name"));
                                            }
                                            __field6 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<String>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field7 => {
                                            if _serde::export::Option::is_some(&__field7)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("provider_url"));
                                            }
                                            __field7 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<String>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field8 => {
                                            if _serde::export::Option::is_some(&__field8)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("html"));
                                            }
                                            __field8 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<String>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field9 => {
                                            if _serde::export::Option::is_some(&__field9)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("width"));
                                            }
                                            __field9 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<u64>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field10 => {
                                            if _serde::export::Option::is_some(&__field10)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("height"));
                                            }
                                            __field10 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<u64>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        _ => {
                                            let _ =
                                                match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                    {
                                                    _serde::export::Ok(__val)
                                                    => __val,
                                                    _serde::export::Err(__err)
                                                    => {
                                                        return _serde::export::Err(__err);
                                                    }
                                                };
                                        }
                                    }
                                }
                                let __field0 =
                                    match __field0 {
                                        _serde::export::Some(__field0) =>
                                        __field0,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("url")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field1 =
                                    match __field1 {
                                        _serde::export::Some(__field1) =>
                                        __field1,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("title")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field2 =
                                    match __field2 {
                                        _serde::export::Some(__field2) =>
                                        __field2,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("description")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field3 =
                                    match __field3 {
                                        _serde::export::Some(__field3) =>
                                        __field3,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("image")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field4 =
                                    match __field4 {
                                        _serde::export::Some(__field4) =>
                                        __field4,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("author_name")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field5 =
                                    match __field5 {
                                        _serde::export::Some(__field5) =>
                                        __field5,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("author_url")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field6 =
                                    match __field6 {
                                        _serde::export::Some(__field6) =>
                                        __field6,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("provider_name")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field7 =
                                    match __field7 {
                                        _serde::export::Some(__field7) =>
                                        __field7,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("provider_url")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field8 =
                                    match __field8 {
                                        _serde::export::Some(__field8) =>
                                        __field8,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("html")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field9 =
                                    match __field9 {
                                        _serde::export::Some(__field9) =>
                                        __field9,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("width")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field10 =
                                    match __field10 {
                                        _serde::export::Some(__field10) =>
                                        __field10,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("height")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                _serde::export::Ok(Card{url: __field0,
                                                        title: __field1,
                                                        description: __field2,
                                                        image: __field3,
                                                        author_name: __field4,
                                                        author_url: __field5,
                                                        provider_name:
                                                            __field6,
                                                        provider_url:
                                                            __field7,
                                                        html: __field8,
                                                        width: __field9,
                                                        height: __field10,})
                            }
                        }
                        const FIELDS: &'static [&'static str] =
                            &["url", "title", "description", "image",
                              "author_name", "author_url", "provider_name",
                              "provider_url", "html", "width", "height"];
                        _serde::Deserializer::deserialize_struct(__deserializer,
                                                                 "Card",
                                                                 FIELDS,
                                                                 __Visitor{marker:
                                                                               _serde::export::PhantomData::<Card>,
                                                                           lifetime:
                                                                               _serde::export::PhantomData,})
                    }
                }
            };
        impl ::core::marker::StructuralPartialEq for Card { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for Card {
            #[inline]
            fn eq(&self, other: &Card) -> bool {
                match *other {
                    Card {
                    url: ref __self_1_0,
                    title: ref __self_1_1,
                    description: ref __self_1_2,
                    image: ref __self_1_3,
                    author_name: ref __self_1_4,
                    author_url: ref __self_1_5,
                    provider_name: ref __self_1_6,
                    provider_url: ref __self_1_7,
                    html: ref __self_1_8,
                    width: ref __self_1_9,
                    height: ref __self_1_10 } =>
                    match *self {
                        Card {
                        url: ref __self_0_0,
                        title: ref __self_0_1,
                        description: ref __self_0_2,
                        image: ref __self_0_3,
                        author_name: ref __self_0_4,
                        author_url: ref __self_0_5,
                        provider_name: ref __self_0_6,
                        provider_url: ref __self_0_7,
                        html: ref __self_0_8,
                        width: ref __self_0_9,
                        height: ref __self_0_10 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1) &&
                            (*__self_0_2) == (*__self_1_2) &&
                            (*__self_0_3) == (*__self_1_3) &&
                            (*__self_0_4) == (*__self_1_4) &&
                            (*__self_0_5) == (*__self_1_5) &&
                            (*__self_0_6) == (*__self_1_6) &&
                            (*__self_0_7) == (*__self_1_7) &&
                            (*__self_0_8) == (*__self_1_8) &&
                            (*__self_0_9) == (*__self_1_9) &&
                            (*__self_0_10) == (*__self_1_10),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &Card) -> bool {
                match *other {
                    Card {
                    url: ref __self_1_0,
                    title: ref __self_1_1,
                    description: ref __self_1_2,
                    image: ref __self_1_3,
                    author_name: ref __self_1_4,
                    author_url: ref __self_1_5,
                    provider_name: ref __self_1_6,
                    provider_url: ref __self_1_7,
                    html: ref __self_1_8,
                    width: ref __self_1_9,
                    height: ref __self_1_10 } =>
                    match *self {
                        Card {
                        url: ref __self_0_0,
                        title: ref __self_0_1,
                        description: ref __self_0_2,
                        image: ref __self_0_3,
                        author_name: ref __self_0_4,
                        author_url: ref __self_0_5,
                        provider_name: ref __self_0_6,
                        provider_url: ref __self_0_7,
                        html: ref __self_0_8,
                        width: ref __self_0_9,
                        height: ref __self_0_10 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1) ||
                            (*__self_0_2) != (*__self_1_2) ||
                            (*__self_0_3) != (*__self_1_3) ||
                            (*__self_0_4) != (*__self_1_4) ||
                            (*__self_0_5) != (*__self_1_5) ||
                            (*__self_0_6) != (*__self_1_6) ||
                            (*__self_0_7) != (*__self_1_7) ||
                            (*__self_0_8) != (*__self_1_8) ||
                            (*__self_0_9) != (*__self_1_9) ||
                            (*__self_0_10) != (*__self_1_10),
                    },
                }
            }
        }
    }
    /// Data structures for ser/de of contetx-related resources
    pub mod context {
        //! A module about contexts of statuses.
        use super::status::Status;
        /// A context of a status returning a list of statuses it replied to and
        /// statuses replied to it.
        pub struct Context {
            /// Statuses that were replied to.
            pub ancestors: Vec<Status>,
            /// Statuses that replied to this status.
            pub descendants: Vec<Status>,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for Context {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    Context {
                    ancestors: ref __self_0_0, descendants: ref __self_0_1 }
                    => {
                        let mut debug_trait_builder =
                            f.debug_struct("Context");
                        let _ =
                            debug_trait_builder.field("ancestors",
                                                      &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("descendants",
                                                      &&(*__self_0_1));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for Context {
            #[inline]
            fn clone(&self) -> Context {
                match *self {
                    Context {
                    ancestors: ref __self_0_0, descendants: ref __self_0_1 }
                    =>
                    Context{ancestors:
                                ::core::clone::Clone::clone(&(*__self_0_0)),
                            descendants:
                                ::core::clone::Clone::clone(&(*__self_0_1)),},
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_Context: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'de> _serde::Deserialize<'de> for Context {
                    fn deserialize<__D>(__deserializer: __D)
                     -> _serde::export::Result<Self, __D::Error> where
                     __D: _serde::Deserializer<'de> {
                        #[allow(non_camel_case_types)]
                        enum __Field { __field0, __field1, __ignore, }
                        struct __FieldVisitor;
                        impl <'de> _serde::de::Visitor<'de> for __FieldVisitor
                         {
                            type Value = __Field;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "field identifier")
                            }
                            fn visit_u64<__E>(self, __value: u64)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    0u64 =>
                                    _serde::export::Ok(__Field::__field0),
                                    1u64 =>
                                    _serde::export::Ok(__Field::__field1),
                                    _ =>
                                    _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                         &"field index 0 <= i < 2")),
                                }
                            }
                            fn visit_str<__E>(self, __value: &str)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    "ancestors" =>
                                    _serde::export::Ok(__Field::__field0),
                                    "descendants" =>
                                    _serde::export::Ok(__Field::__field1),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                            fn visit_bytes<__E>(self, __value: &[u8])
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    b"ancestors" =>
                                    _serde::export::Ok(__Field::__field0),
                                    b"descendants" =>
                                    _serde::export::Ok(__Field::__field1),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                        }
                        impl <'de> _serde::Deserialize<'de> for __Field {
                            #[inline]
                            fn deserialize<__D>(__deserializer: __D)
                             -> _serde::export::Result<Self, __D::Error> where
                             __D: _serde::Deserializer<'de> {
                                _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                             __FieldVisitor)
                            }
                        }
                        struct __Visitor<'de> {
                            marker: _serde::export::PhantomData<Context>,
                            lifetime: _serde::export::PhantomData<&'de ()>,
                        }
                        impl <'de> _serde::de::Visitor<'de> for __Visitor<'de>
                         {
                            type Value = Context;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "struct Context")
                            }
                            #[inline]
                            fn visit_seq<__A>(self, mut __seq: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::SeqAccess<'de> {
                                let __field0 =
                                    match match _serde::de::SeqAccess::next_element::<Vec<Status>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                         &"struct Context with 2 elements"));
                                        }
                                    };
                                let __field1 =
                                    match match _serde::de::SeqAccess::next_element::<Vec<Status>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(1usize,
                                                                                                         &"struct Context with 2 elements"));
                                        }
                                    };
                                _serde::export::Ok(Context{ancestors:
                                                               __field0,
                                                           descendants:
                                                               __field1,})
                            }
                            #[inline]
                            fn visit_map<__A>(self, mut __map: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::MapAccess<'de> {
                                let mut __field0:
                                        _serde::export::Option<Vec<Status>> =
                                    _serde::export::None;
                                let mut __field1:
                                        _serde::export::Option<Vec<Status>> =
                                    _serde::export::None;
                                while let _serde::export::Some(__key) =
                                          match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                    match __key {
                                        __Field::__field0 => {
                                            if _serde::export::Option::is_some(&__field0)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("ancestors"));
                                            }
                                            __field0 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Vec<Status>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field1 => {
                                            if _serde::export::Option::is_some(&__field1)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("descendants"));
                                            }
                                            __field1 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Vec<Status>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        _ => {
                                            let _ =
                                                match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                    {
                                                    _serde::export::Ok(__val)
                                                    => __val,
                                                    _serde::export::Err(__err)
                                                    => {
                                                        return _serde::export::Err(__err);
                                                    }
                                                };
                                        }
                                    }
                                }
                                let __field0 =
                                    match __field0 {
                                        _serde::export::Some(__field0) =>
                                        __field0,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("ancestors")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field1 =
                                    match __field1 {
                                        _serde::export::Some(__field1) =>
                                        __field1,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("descendants")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                _serde::export::Ok(Context{ancestors:
                                                               __field0,
                                                           descendants:
                                                               __field1,})
                            }
                        }
                        const FIELDS: &'static [&'static str] =
                            &["ancestors", "descendants"];
                        _serde::Deserializer::deserialize_struct(__deserializer,
                                                                 "Context",
                                                                 FIELDS,
                                                                 __Visitor{marker:
                                                                               _serde::export::PhantomData::<Context>,
                                                                           lifetime:
                                                                               _serde::export::PhantomData,})
                    }
                }
            };
        impl ::core::marker::StructuralPartialEq for Context { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for Context {
            #[inline]
            fn eq(&self, other: &Context) -> bool {
                match *other {
                    Context {
                    ancestors: ref __self_1_0, descendants: ref __self_1_1 }
                    =>
                    match *self {
                        Context {
                        ancestors: ref __self_0_0, descendants: ref __self_0_1
                        } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &Context) -> bool {
                match *other {
                    Context {
                    ancestors: ref __self_1_0, descendants: ref __self_1_1 }
                    =>
                    match *self {
                        Context {
                        ancestors: ref __self_0_0, descendants: ref __self_0_1
                        } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1),
                    },
                }
            }
        }
    }
    /// Data structures for ser/de of streaming events
    pub mod event {
        use crate::entities::{notification::Notification, status::Status};
        /// Events that come from the /streaming/user API call
        pub enum Event {

            /// Update event
            Update(Status),

            /// Notification event
            Notification(Notification),

            /// Delete event
            Delete(String),

            /// FiltersChanged event
            FiltersChanged,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for Event {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match (&*self,) {
                    (&Event::Update(ref __self_0),) => {
                        let mut debug_trait_builder = f.debug_tuple("Update");
                        let _ = debug_trait_builder.field(&&(*__self_0));
                        debug_trait_builder.finish()
                    }
                    (&Event::Notification(ref __self_0),) => {
                        let mut debug_trait_builder =
                            f.debug_tuple("Notification");
                        let _ = debug_trait_builder.field(&&(*__self_0));
                        debug_trait_builder.finish()
                    }
                    (&Event::Delete(ref __self_0),) => {
                        let mut debug_trait_builder = f.debug_tuple("Delete");
                        let _ = debug_trait_builder.field(&&(*__self_0));
                        debug_trait_builder.finish()
                    }
                    (&Event::FiltersChanged,) => {
                        let mut debug_trait_builder =
                            f.debug_tuple("FiltersChanged");
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for Event {
            #[inline]
            fn clone(&self) -> Event {
                match (&*self,) {
                    (&Event::Update(ref __self_0),) =>
                    Event::Update(::core::clone::Clone::clone(&(*__self_0))),
                    (&Event::Notification(ref __self_0),) =>
                    Event::Notification(::core::clone::Clone::clone(&(*__self_0))),
                    (&Event::Delete(ref __self_0),) =>
                    Event::Delete(::core::clone::Clone::clone(&(*__self_0))),
                    (&Event::FiltersChanged,) => Event::FiltersChanged,
                }
            }
        }
    }
    /// Data structures for ser/de of filter-related resources
    pub mod filter {
        /// Represents a single Filter
        pub struct Filter {
            id: String,
            phrase: String,
            context: Vec<FilterContext>,
            expires_at: Option<String>,
            irreversible: bool,
            whole_word: bool,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for Filter {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    Filter {
                    id: ref __self_0_0,
                    phrase: ref __self_0_1,
                    context: ref __self_0_2,
                    expires_at: ref __self_0_3,
                    irreversible: ref __self_0_4,
                    whole_word: ref __self_0_5 } => {
                        let mut debug_trait_builder =
                            f.debug_struct("Filter");
                        let _ =
                            debug_trait_builder.field("id", &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("phrase",
                                                      &&(*__self_0_1));
                        let _ =
                            debug_trait_builder.field("context",
                                                      &&(*__self_0_2));
                        let _ =
                            debug_trait_builder.field("expires_at",
                                                      &&(*__self_0_3));
                        let _ =
                            debug_trait_builder.field("irreversible",
                                                      &&(*__self_0_4));
                        let _ =
                            debug_trait_builder.field("whole_word",
                                                      &&(*__self_0_5));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for Filter {
            #[inline]
            fn clone(&self) -> Filter {
                match *self {
                    Filter {
                    id: ref __self_0_0,
                    phrase: ref __self_0_1,
                    context: ref __self_0_2,
                    expires_at: ref __self_0_3,
                    irreversible: ref __self_0_4,
                    whole_word: ref __self_0_5 } =>
                    Filter{id: ::core::clone::Clone::clone(&(*__self_0_0)),
                           phrase:
                               ::core::clone::Clone::clone(&(*__self_0_1)),
                           context:
                               ::core::clone::Clone::clone(&(*__self_0_2)),
                           expires_at:
                               ::core::clone::Clone::clone(&(*__self_0_3)),
                           irreversible:
                               ::core::clone::Clone::clone(&(*__self_0_4)),
                           whole_word:
                               ::core::clone::Clone::clone(&(*__self_0_5)),},
                }
            }
        }
        impl ::core::marker::StructuralPartialEq for Filter { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for Filter {
            #[inline]
            fn eq(&self, other: &Filter) -> bool {
                match *other {
                    Filter {
                    id: ref __self_1_0,
                    phrase: ref __self_1_1,
                    context: ref __self_1_2,
                    expires_at: ref __self_1_3,
                    irreversible: ref __self_1_4,
                    whole_word: ref __self_1_5 } =>
                    match *self {
                        Filter {
                        id: ref __self_0_0,
                        phrase: ref __self_0_1,
                        context: ref __self_0_2,
                        expires_at: ref __self_0_3,
                        irreversible: ref __self_0_4,
                        whole_word: ref __self_0_5 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1) &&
                            (*__self_0_2) == (*__self_1_2) &&
                            (*__self_0_3) == (*__self_1_3) &&
                            (*__self_0_4) == (*__self_1_4) &&
                            (*__self_0_5) == (*__self_1_5),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &Filter) -> bool {
                match *other {
                    Filter {
                    id: ref __self_1_0,
                    phrase: ref __self_1_1,
                    context: ref __self_1_2,
                    expires_at: ref __self_1_3,
                    irreversible: ref __self_1_4,
                    whole_word: ref __self_1_5 } =>
                    match *self {
                        Filter {
                        id: ref __self_0_0,
                        phrase: ref __self_0_1,
                        context: ref __self_0_2,
                        expires_at: ref __self_0_3,
                        irreversible: ref __self_0_4,
                        whole_word: ref __self_0_5 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1) ||
                            (*__self_0_2) != (*__self_1_2) ||
                            (*__self_0_3) != (*__self_1_3) ||
                            (*__self_0_4) != (*__self_1_4) ||
                            (*__self_0_5) != (*__self_1_5),
                    },
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_SERIALIZE_FOR_Filter: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl _serde::Serialize for Filter {
                    fn serialize<__S>(&self, __serializer: __S)
                     -> _serde::export::Result<__S::Ok, __S::Error> where
                     __S: _serde::Serializer {
                        let mut __serde_state =
                            match _serde::Serializer::serialize_struct(__serializer,
                                                                       "Filter",
                                                                       false
                                                                           as
                                                                           usize
                                                                           + 1
                                                                           + 1
                                                                           + 1
                                                                           + 1
                                                                           + 1
                                                                           +
                                                                           1)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "id",
                                                                            &self.id)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "phrase",
                                                                            &self.phrase)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "context",
                                                                            &self.context)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "expires_at",
                                                                            &self.expires_at)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "irreversible",
                                                                            &self.irreversible)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "whole_word",
                                                                            &self.whole_word)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        _serde::ser::SerializeStruct::end(__serde_state)
                    }
                }
            };
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_Filter: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'de> _serde::Deserialize<'de> for Filter {
                    fn deserialize<__D>(__deserializer: __D)
                     -> _serde::export::Result<Self, __D::Error> where
                     __D: _serde::Deserializer<'de> {
                        #[allow(non_camel_case_types)]
                        enum __Field {
                            __field0,
                            __field1,
                            __field2,
                            __field3,
                            __field4,
                            __field5,
                            __ignore,
                        }
                        struct __FieldVisitor;
                        impl <'de> _serde::de::Visitor<'de> for __FieldVisitor
                         {
                            type Value = __Field;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "field identifier")
                            }
                            fn visit_u64<__E>(self, __value: u64)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    0u64 =>
                                    _serde::export::Ok(__Field::__field0),
                                    1u64 =>
                                    _serde::export::Ok(__Field::__field1),
                                    2u64 =>
                                    _serde::export::Ok(__Field::__field2),
                                    3u64 =>
                                    _serde::export::Ok(__Field::__field3),
                                    4u64 =>
                                    _serde::export::Ok(__Field::__field4),
                                    5u64 =>
                                    _serde::export::Ok(__Field::__field5),
                                    _ =>
                                    _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                         &"field index 0 <= i < 6")),
                                }
                            }
                            fn visit_str<__E>(self, __value: &str)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    "id" =>
                                    _serde::export::Ok(__Field::__field0),
                                    "phrase" =>
                                    _serde::export::Ok(__Field::__field1),
                                    "context" =>
                                    _serde::export::Ok(__Field::__field2),
                                    "expires_at" =>
                                    _serde::export::Ok(__Field::__field3),
                                    "irreversible" =>
                                    _serde::export::Ok(__Field::__field4),
                                    "whole_word" =>
                                    _serde::export::Ok(__Field::__field5),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                            fn visit_bytes<__E>(self, __value: &[u8])
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    b"id" =>
                                    _serde::export::Ok(__Field::__field0),
                                    b"phrase" =>
                                    _serde::export::Ok(__Field::__field1),
                                    b"context" =>
                                    _serde::export::Ok(__Field::__field2),
                                    b"expires_at" =>
                                    _serde::export::Ok(__Field::__field3),
                                    b"irreversible" =>
                                    _serde::export::Ok(__Field::__field4),
                                    b"whole_word" =>
                                    _serde::export::Ok(__Field::__field5),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                        }
                        impl <'de> _serde::Deserialize<'de> for __Field {
                            #[inline]
                            fn deserialize<__D>(__deserializer: __D)
                             -> _serde::export::Result<Self, __D::Error> where
                             __D: _serde::Deserializer<'de> {
                                _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                             __FieldVisitor)
                            }
                        }
                        struct __Visitor<'de> {
                            marker: _serde::export::PhantomData<Filter>,
                            lifetime: _serde::export::PhantomData<&'de ()>,
                        }
                        impl <'de> _serde::de::Visitor<'de> for __Visitor<'de>
                         {
                            type Value = Filter;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "struct Filter")
                            }
                            #[inline]
                            fn visit_seq<__A>(self, mut __seq: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::SeqAccess<'de> {
                                let __field0 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                         &"struct Filter with 6 elements"));
                                        }
                                    };
                                let __field1 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(1usize,
                                                                                                         &"struct Filter with 6 elements"));
                                        }
                                    };
                                let __field2 =
                                    match match _serde::de::SeqAccess::next_element::<Vec<FilterContext>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(2usize,
                                                                                                         &"struct Filter with 6 elements"));
                                        }
                                    };
                                let __field3 =
                                    match match _serde::de::SeqAccess::next_element::<Option<String>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(3usize,
                                                                                                         &"struct Filter with 6 elements"));
                                        }
                                    };
                                let __field4 =
                                    match match _serde::de::SeqAccess::next_element::<bool>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(4usize,
                                                                                                         &"struct Filter with 6 elements"));
                                        }
                                    };
                                let __field5 =
                                    match match _serde::de::SeqAccess::next_element::<bool>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(5usize,
                                                                                                         &"struct Filter with 6 elements"));
                                        }
                                    };
                                _serde::export::Ok(Filter{id: __field0,
                                                          phrase: __field1,
                                                          context: __field2,
                                                          expires_at:
                                                              __field3,
                                                          irreversible:
                                                              __field4,
                                                          whole_word:
                                                              __field5,})
                            }
                            #[inline]
                            fn visit_map<__A>(self, mut __map: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::MapAccess<'de> {
                                let mut __field0:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field1:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field2:
                                        _serde::export::Option<Vec<FilterContext>> =
                                    _serde::export::None;
                                let mut __field3:
                                        _serde::export::Option<Option<String>> =
                                    _serde::export::None;
                                let mut __field4:
                                        _serde::export::Option<bool> =
                                    _serde::export::None;
                                let mut __field5:
                                        _serde::export::Option<bool> =
                                    _serde::export::None;
                                while let _serde::export::Some(__key) =
                                          match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                    match __key {
                                        __Field::__field0 => {
                                            if _serde::export::Option::is_some(&__field0)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("id"));
                                            }
                                            __field0 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field1 => {
                                            if _serde::export::Option::is_some(&__field1)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("phrase"));
                                            }
                                            __field1 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field2 => {
                                            if _serde::export::Option::is_some(&__field2)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("context"));
                                            }
                                            __field2 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Vec<FilterContext>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field3 => {
                                            if _serde::export::Option::is_some(&__field3)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("expires_at"));
                                            }
                                            __field3 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<String>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field4 => {
                                            if _serde::export::Option::is_some(&__field4)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("irreversible"));
                                            }
                                            __field4 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<bool>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field5 => {
                                            if _serde::export::Option::is_some(&__field5)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("whole_word"));
                                            }
                                            __field5 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<bool>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        _ => {
                                            let _ =
                                                match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                    {
                                                    _serde::export::Ok(__val)
                                                    => __val,
                                                    _serde::export::Err(__err)
                                                    => {
                                                        return _serde::export::Err(__err);
                                                    }
                                                };
                                        }
                                    }
                                }
                                let __field0 =
                                    match __field0 {
                                        _serde::export::Some(__field0) =>
                                        __field0,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("id")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field1 =
                                    match __field1 {
                                        _serde::export::Some(__field1) =>
                                        __field1,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("phrase")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field2 =
                                    match __field2 {
                                        _serde::export::Some(__field2) =>
                                        __field2,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("context")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field3 =
                                    match __field3 {
                                        _serde::export::Some(__field3) =>
                                        __field3,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("expires_at")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field4 =
                                    match __field4 {
                                        _serde::export::Some(__field4) =>
                                        __field4,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("irreversible")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field5 =
                                    match __field5 {
                                        _serde::export::Some(__field5) =>
                                        __field5,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("whole_word")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                _serde::export::Ok(Filter{id: __field0,
                                                          phrase: __field1,
                                                          context: __field2,
                                                          expires_at:
                                                              __field3,
                                                          irreversible:
                                                              __field4,
                                                          whole_word:
                                                              __field5,})
                            }
                        }
                        const FIELDS: &'static [&'static str] =
                            &["id", "phrase", "context", "expires_at",
                              "irreversible", "whole_word"];
                        _serde::Deserializer::deserialize_struct(__deserializer,
                                                                 "Filter",
                                                                 FIELDS,
                                                                 __Visitor{marker:
                                                                               _serde::export::PhantomData::<Filter>,
                                                                           lifetime:
                                                                               _serde::export::PhantomData,})
                    }
                }
            };
        /// Represents the various types of Filter contexts
        pub enum FilterContext {

            /// Represents the "home" context
            #[serde(rename = "home")]
            Home,

            /// Represents the "notifications" context
            #[serde(rename = "notifications")]
            Notifications,

            /// Represents the "public" context
            #[serde(rename = "public")]
            Public,

            /// Represents the "thread" context
            #[serde(rename = "thread")]
            Thread,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for FilterContext {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match (&*self,) {
                    (&FilterContext::Home,) => {
                        let mut debug_trait_builder = f.debug_tuple("Home");
                        debug_trait_builder.finish()
                    }
                    (&FilterContext::Notifications,) => {
                        let mut debug_trait_builder =
                            f.debug_tuple("Notifications");
                        debug_trait_builder.finish()
                    }
                    (&FilterContext::Public,) => {
                        let mut debug_trait_builder = f.debug_tuple("Public");
                        debug_trait_builder.finish()
                    }
                    (&FilterContext::Thread,) => {
                        let mut debug_trait_builder = f.debug_tuple("Thread");
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for FilterContext {
            #[inline]
            fn clone(&self) -> FilterContext { { *self } }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::marker::Copy for FilterContext { }
        impl ::core::marker::StructuralPartialEq for FilterContext { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for FilterContext {
            #[inline]
            fn eq(&self, other: &FilterContext) -> bool {
                {
                    let __self_vi =
                        unsafe {
                            ::core::intrinsics::discriminant_value(&*self)
                        };
                    let __arg_1_vi =
                        unsafe {
                            ::core::intrinsics::discriminant_value(&*other)
                        };
                    if true && __self_vi == __arg_1_vi {
                        match (&*self, &*other) { _ => true, }
                    } else { false }
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_SERIALIZE_FOR_FilterContext: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl _serde::Serialize for FilterContext {
                    fn serialize<__S>(&self, __serializer: __S)
                     -> _serde::export::Result<__S::Ok, __S::Error> where
                     __S: _serde::Serializer {
                        match *self {
                            FilterContext::Home =>
                            _serde::Serializer::serialize_unit_variant(__serializer,
                                                                       "FilterContext",
                                                                       0u32,
                                                                       "home"),
                            FilterContext::Notifications =>
                            _serde::Serializer::serialize_unit_variant(__serializer,
                                                                       "FilterContext",
                                                                       1u32,
                                                                       "notifications"),
                            FilterContext::Public =>
                            _serde::Serializer::serialize_unit_variant(__serializer,
                                                                       "FilterContext",
                                                                       2u32,
                                                                       "public"),
                            FilterContext::Thread =>
                            _serde::Serializer::serialize_unit_variant(__serializer,
                                                                       "FilterContext",
                                                                       3u32,
                                                                       "thread"),
                        }
                    }
                }
            };
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_FilterContext: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'de> _serde::Deserialize<'de> for FilterContext {
                    fn deserialize<__D>(__deserializer: __D)
                     -> _serde::export::Result<Self, __D::Error> where
                     __D: _serde::Deserializer<'de> {
                        #[allow(non_camel_case_types)]
                        enum __Field {
                            __field0,
                            __field1,
                            __field2,
                            __field3,
                        }
                        struct __FieldVisitor;
                        impl <'de> _serde::de::Visitor<'de> for __FieldVisitor
                         {
                            type Value = __Field;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "variant identifier")
                            }
                            fn visit_u64<__E>(self, __value: u64)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    0u64 =>
                                    _serde::export::Ok(__Field::__field0),
                                    1u64 =>
                                    _serde::export::Ok(__Field::__field1),
                                    2u64 =>
                                    _serde::export::Ok(__Field::__field2),
                                    3u64 =>
                                    _serde::export::Ok(__Field::__field3),
                                    _ =>
                                    _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                         &"variant index 0 <= i < 4")),
                                }
                            }
                            fn visit_str<__E>(self, __value: &str)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    "home" =>
                                    _serde::export::Ok(__Field::__field0),
                                    "notifications" =>
                                    _serde::export::Ok(__Field::__field1),
                                    "public" =>
                                    _serde::export::Ok(__Field::__field2),
                                    "thread" =>
                                    _serde::export::Ok(__Field::__field3),
                                    _ => {
                                        _serde::export::Err(_serde::de::Error::unknown_variant(__value,
                                                                                               VARIANTS))
                                    }
                                }
                            }
                            fn visit_bytes<__E>(self, __value: &[u8])
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    b"home" =>
                                    _serde::export::Ok(__Field::__field0),
                                    b"notifications" =>
                                    _serde::export::Ok(__Field::__field1),
                                    b"public" =>
                                    _serde::export::Ok(__Field::__field2),
                                    b"thread" =>
                                    _serde::export::Ok(__Field::__field3),
                                    _ => {
                                        let __value =
                                            &_serde::export::from_utf8_lossy(__value);
                                        _serde::export::Err(_serde::de::Error::unknown_variant(__value,
                                                                                               VARIANTS))
                                    }
                                }
                            }
                        }
                        impl <'de> _serde::Deserialize<'de> for __Field {
                            #[inline]
                            fn deserialize<__D>(__deserializer: __D)
                             -> _serde::export::Result<Self, __D::Error> where
                             __D: _serde::Deserializer<'de> {
                                _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                             __FieldVisitor)
                            }
                        }
                        struct __Visitor<'de> {
                            marker: _serde::export::PhantomData<FilterContext>,
                            lifetime: _serde::export::PhantomData<&'de ()>,
                        }
                        impl <'de> _serde::de::Visitor<'de> for __Visitor<'de>
                         {
                            type Value = FilterContext;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "enum FilterContext")
                            }
                            fn visit_enum<__A>(self, __data: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::EnumAccess<'de> {
                                match match _serde::de::EnumAccess::variant(__data)
                                          {
                                          _serde::export::Ok(__val) => __val,
                                          _serde::export::Err(__err) => {
                                              return _serde::export::Err(__err);
                                          }
                                      } {
                                    (__Field::__field0, __variant) => {
                                        match _serde::de::VariantAccess::unit_variant(__variant)
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        };
                                        _serde::export::Ok(FilterContext::Home)
                                    }
                                    (__Field::__field1, __variant) => {
                                        match _serde::de::VariantAccess::unit_variant(__variant)
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        };
                                        _serde::export::Ok(FilterContext::Notifications)
                                    }
                                    (__Field::__field2, __variant) => {
                                        match _serde::de::VariantAccess::unit_variant(__variant)
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        };
                                        _serde::export::Ok(FilterContext::Public)
                                    }
                                    (__Field::__field3, __variant) => {
                                        match _serde::de::VariantAccess::unit_variant(__variant)
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        };
                                        _serde::export::Ok(FilterContext::Thread)
                                    }
                                }
                            }
                        }
                        const VARIANTS: &'static [&'static str] =
                            &["home", "notifications", "public", "thread"];
                        _serde::Deserializer::deserialize_enum(__deserializer,
                                                               "FilterContext",
                                                               VARIANTS,
                                                               __Visitor{marker:
                                                                             _serde::export::PhantomData::<FilterContext>,
                                                                         lifetime:
                                                                             _serde::export::PhantomData,})
                    }
                }
            };
    }
    /// Data structures for ser/de of instance-related resources
    pub mod instance {
        //! Module containing everything related to an instance.
        use super::account::Account;
        /// A struct containing info of an instance.
        pub struct Instance {
            /// URI of the current instance
            pub uri: String,
            /// The instance's title.
            pub title: String,
            /// A description for the instance.
            pub description: String,
            /// An email address which can be used to contact the
            /// instance administrator.
            pub email: String,
            /// The Mastodon version used by instance.
            pub version: String,
            /// Urls to the streaming api.
            pub urls: Option<StreamingApi>,
            /// Stats about the instance.
            pub stats: Option<Stats>,
            /// Thumbnail of the server image.
            pub thumbnail: Option<String>,
            /// List of languages used on the server.
            pub languages: Option<Vec<String>>,
            /// Contact account for the server.
            pub contact_account: Option<Account>,
            /// The maximum number of characters allowed in a status
            pub max_toot_chars: Option<u32>,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for Instance {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    Instance {
                    uri: ref __self_0_0,
                    title: ref __self_0_1,
                    description: ref __self_0_2,
                    email: ref __self_0_3,
                    version: ref __self_0_4,
                    urls: ref __self_0_5,
                    stats: ref __self_0_6,
                    thumbnail: ref __self_0_7,
                    languages: ref __self_0_8,
                    contact_account: ref __self_0_9,
                    max_toot_chars: ref __self_0_10 } => {
                        let mut debug_trait_builder =
                            f.debug_struct("Instance");
                        let _ =
                            debug_trait_builder.field("uri", &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("title",
                                                      &&(*__self_0_1));
                        let _ =
                            debug_trait_builder.field("description",
                                                      &&(*__self_0_2));
                        let _ =
                            debug_trait_builder.field("email",
                                                      &&(*__self_0_3));
                        let _ =
                            debug_trait_builder.field("version",
                                                      &&(*__self_0_4));
                        let _ =
                            debug_trait_builder.field("urls",
                                                      &&(*__self_0_5));
                        let _ =
                            debug_trait_builder.field("stats",
                                                      &&(*__self_0_6));
                        let _ =
                            debug_trait_builder.field("thumbnail",
                                                      &&(*__self_0_7));
                        let _ =
                            debug_trait_builder.field("languages",
                                                      &&(*__self_0_8));
                        let _ =
                            debug_trait_builder.field("contact_account",
                                                      &&(*__self_0_9));
                        let _ =
                            debug_trait_builder.field("max_toot_chars",
                                                      &&(*__self_0_10));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for Instance {
            #[inline]
            fn clone(&self) -> Instance {
                match *self {
                    Instance {
                    uri: ref __self_0_0,
                    title: ref __self_0_1,
                    description: ref __self_0_2,
                    email: ref __self_0_3,
                    version: ref __self_0_4,
                    urls: ref __self_0_5,
                    stats: ref __self_0_6,
                    thumbnail: ref __self_0_7,
                    languages: ref __self_0_8,
                    contact_account: ref __self_0_9,
                    max_toot_chars: ref __self_0_10 } =>
                    Instance{uri: ::core::clone::Clone::clone(&(*__self_0_0)),
                             title:
                                 ::core::clone::Clone::clone(&(*__self_0_1)),
                             description:
                                 ::core::clone::Clone::clone(&(*__self_0_2)),
                             email:
                                 ::core::clone::Clone::clone(&(*__self_0_3)),
                             version:
                                 ::core::clone::Clone::clone(&(*__self_0_4)),
                             urls:
                                 ::core::clone::Clone::clone(&(*__self_0_5)),
                             stats:
                                 ::core::clone::Clone::clone(&(*__self_0_6)),
                             thumbnail:
                                 ::core::clone::Clone::clone(&(*__self_0_7)),
                             languages:
                                 ::core::clone::Clone::clone(&(*__self_0_8)),
                             contact_account:
                                 ::core::clone::Clone::clone(&(*__self_0_9)),
                             max_toot_chars:
                                 ::core::clone::Clone::clone(&(*__self_0_10)),},
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_Instance: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'de> _serde::Deserialize<'de> for Instance {
                    fn deserialize<__D>(__deserializer: __D)
                     -> _serde::export::Result<Self, __D::Error> where
                     __D: _serde::Deserializer<'de> {
                        #[allow(non_camel_case_types)]
                        enum __Field {
                            __field0,
                            __field1,
                            __field2,
                            __field3,
                            __field4,
                            __field5,
                            __field6,
                            __field7,
                            __field8,
                            __field9,
                            __field10,
                            __ignore,
                        }
                        struct __FieldVisitor;
                        impl <'de> _serde::de::Visitor<'de> for __FieldVisitor
                         {
                            type Value = __Field;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "field identifier")
                            }
                            fn visit_u64<__E>(self, __value: u64)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    0u64 =>
                                    _serde::export::Ok(__Field::__field0),
                                    1u64 =>
                                    _serde::export::Ok(__Field::__field1),
                                    2u64 =>
                                    _serde::export::Ok(__Field::__field2),
                                    3u64 =>
                                    _serde::export::Ok(__Field::__field3),
                                    4u64 =>
                                    _serde::export::Ok(__Field::__field4),
                                    5u64 =>
                                    _serde::export::Ok(__Field::__field5),
                                    6u64 =>
                                    _serde::export::Ok(__Field::__field6),
                                    7u64 =>
                                    _serde::export::Ok(__Field::__field7),
                                    8u64 =>
                                    _serde::export::Ok(__Field::__field8),
                                    9u64 =>
                                    _serde::export::Ok(__Field::__field9),
                                    10u64 =>
                                    _serde::export::Ok(__Field::__field10),
                                    _ =>
                                    _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                         &"field index 0 <= i < 11")),
                                }
                            }
                            fn visit_str<__E>(self, __value: &str)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    "uri" =>
                                    _serde::export::Ok(__Field::__field0),
                                    "title" =>
                                    _serde::export::Ok(__Field::__field1),
                                    "description" =>
                                    _serde::export::Ok(__Field::__field2),
                                    "email" =>
                                    _serde::export::Ok(__Field::__field3),
                                    "version" =>
                                    _serde::export::Ok(__Field::__field4),
                                    "urls" =>
                                    _serde::export::Ok(__Field::__field5),
                                    "stats" =>
                                    _serde::export::Ok(__Field::__field6),
                                    "thumbnail" =>
                                    _serde::export::Ok(__Field::__field7),
                                    "languages" =>
                                    _serde::export::Ok(__Field::__field8),
                                    "contact_account" =>
                                    _serde::export::Ok(__Field::__field9),
                                    "max_toot_chars" =>
                                    _serde::export::Ok(__Field::__field10),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                            fn visit_bytes<__E>(self, __value: &[u8])
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    b"uri" =>
                                    _serde::export::Ok(__Field::__field0),
                                    b"title" =>
                                    _serde::export::Ok(__Field::__field1),
                                    b"description" =>
                                    _serde::export::Ok(__Field::__field2),
                                    b"email" =>
                                    _serde::export::Ok(__Field::__field3),
                                    b"version" =>
                                    _serde::export::Ok(__Field::__field4),
                                    b"urls" =>
                                    _serde::export::Ok(__Field::__field5),
                                    b"stats" =>
                                    _serde::export::Ok(__Field::__field6),
                                    b"thumbnail" =>
                                    _serde::export::Ok(__Field::__field7),
                                    b"languages" =>
                                    _serde::export::Ok(__Field::__field8),
                                    b"contact_account" =>
                                    _serde::export::Ok(__Field::__field9),
                                    b"max_toot_chars" =>
                                    _serde::export::Ok(__Field::__field10),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                        }
                        impl <'de> _serde::Deserialize<'de> for __Field {
                            #[inline]
                            fn deserialize<__D>(__deserializer: __D)
                             -> _serde::export::Result<Self, __D::Error> where
                             __D: _serde::Deserializer<'de> {
                                _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                             __FieldVisitor)
                            }
                        }
                        struct __Visitor<'de> {
                            marker: _serde::export::PhantomData<Instance>,
                            lifetime: _serde::export::PhantomData<&'de ()>,
                        }
                        impl <'de> _serde::de::Visitor<'de> for __Visitor<'de>
                         {
                            type Value = Instance;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "struct Instance")
                            }
                            #[inline]
                            fn visit_seq<__A>(self, mut __seq: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::SeqAccess<'de> {
                                let __field0 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                         &"struct Instance with 11 elements"));
                                        }
                                    };
                                let __field1 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(1usize,
                                                                                                         &"struct Instance with 11 elements"));
                                        }
                                    };
                                let __field2 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(2usize,
                                                                                                         &"struct Instance with 11 elements"));
                                        }
                                    };
                                let __field3 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(3usize,
                                                                                                         &"struct Instance with 11 elements"));
                                        }
                                    };
                                let __field4 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(4usize,
                                                                                                         &"struct Instance with 11 elements"));
                                        }
                                    };
                                let __field5 =
                                    match match _serde::de::SeqAccess::next_element::<Option<StreamingApi>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(5usize,
                                                                                                         &"struct Instance with 11 elements"));
                                        }
                                    };
                                let __field6 =
                                    match match _serde::de::SeqAccess::next_element::<Option<Stats>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(6usize,
                                                                                                         &"struct Instance with 11 elements"));
                                        }
                                    };
                                let __field7 =
                                    match match _serde::de::SeqAccess::next_element::<Option<String>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(7usize,
                                                                                                         &"struct Instance with 11 elements"));
                                        }
                                    };
                                let __field8 =
                                    match match _serde::de::SeqAccess::next_element::<Option<Vec<String>>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(8usize,
                                                                                                         &"struct Instance with 11 elements"));
                                        }
                                    };
                                let __field9 =
                                    match match _serde::de::SeqAccess::next_element::<Option<Account>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(9usize,
                                                                                                         &"struct Instance with 11 elements"));
                                        }
                                    };
                                let __field10 =
                                    match match _serde::de::SeqAccess::next_element::<Option<u32>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(10usize,
                                                                                                         &"struct Instance with 11 elements"));
                                        }
                                    };
                                _serde::export::Ok(Instance{uri: __field0,
                                                            title: __field1,
                                                            description:
                                                                __field2,
                                                            email: __field3,
                                                            version: __field4,
                                                            urls: __field5,
                                                            stats: __field6,
                                                            thumbnail:
                                                                __field7,
                                                            languages:
                                                                __field8,
                                                            contact_account:
                                                                __field9,
                                                            max_toot_chars:
                                                                __field10,})
                            }
                            #[inline]
                            fn visit_map<__A>(self, mut __map: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::MapAccess<'de> {
                                let mut __field0:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field1:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field2:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field3:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field4:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field5:
                                        _serde::export::Option<Option<StreamingApi>> =
                                    _serde::export::None;
                                let mut __field6:
                                        _serde::export::Option<Option<Stats>> =
                                    _serde::export::None;
                                let mut __field7:
                                        _serde::export::Option<Option<String>> =
                                    _serde::export::None;
                                let mut __field8:
                                        _serde::export::Option<Option<Vec<String>>> =
                                    _serde::export::None;
                                let mut __field9:
                                        _serde::export::Option<Option<Account>> =
                                    _serde::export::None;
                                let mut __field10:
                                        _serde::export::Option<Option<u32>> =
                                    _serde::export::None;
                                while let _serde::export::Some(__key) =
                                          match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                    match __key {
                                        __Field::__field0 => {
                                            if _serde::export::Option::is_some(&__field0)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("uri"));
                                            }
                                            __field0 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field1 => {
                                            if _serde::export::Option::is_some(&__field1)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("title"));
                                            }
                                            __field1 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field2 => {
                                            if _serde::export::Option::is_some(&__field2)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("description"));
                                            }
                                            __field2 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field3 => {
                                            if _serde::export::Option::is_some(&__field3)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("email"));
                                            }
                                            __field3 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field4 => {
                                            if _serde::export::Option::is_some(&__field4)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("version"));
                                            }
                                            __field4 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field5 => {
                                            if _serde::export::Option::is_some(&__field5)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("urls"));
                                            }
                                            __field5 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<StreamingApi>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field6 => {
                                            if _serde::export::Option::is_some(&__field6)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("stats"));
                                            }
                                            __field6 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<Stats>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field7 => {
                                            if _serde::export::Option::is_some(&__field7)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("thumbnail"));
                                            }
                                            __field7 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<String>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field8 => {
                                            if _serde::export::Option::is_some(&__field8)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("languages"));
                                            }
                                            __field8 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<Vec<String>>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field9 => {
                                            if _serde::export::Option::is_some(&__field9)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("contact_account"));
                                            }
                                            __field9 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<Account>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field10 => {
                                            if _serde::export::Option::is_some(&__field10)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("max_toot_chars"));
                                            }
                                            __field10 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<u32>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        _ => {
                                            let _ =
                                                match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                    {
                                                    _serde::export::Ok(__val)
                                                    => __val,
                                                    _serde::export::Err(__err)
                                                    => {
                                                        return _serde::export::Err(__err);
                                                    }
                                                };
                                        }
                                    }
                                }
                                let __field0 =
                                    match __field0 {
                                        _serde::export::Some(__field0) =>
                                        __field0,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("uri")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field1 =
                                    match __field1 {
                                        _serde::export::Some(__field1) =>
                                        __field1,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("title")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field2 =
                                    match __field2 {
                                        _serde::export::Some(__field2) =>
                                        __field2,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("description")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field3 =
                                    match __field3 {
                                        _serde::export::Some(__field3) =>
                                        __field3,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("email")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field4 =
                                    match __field4 {
                                        _serde::export::Some(__field4) =>
                                        __field4,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("version")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field5 =
                                    match __field5 {
                                        _serde::export::Some(__field5) =>
                                        __field5,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("urls")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field6 =
                                    match __field6 {
                                        _serde::export::Some(__field6) =>
                                        __field6,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("stats")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field7 =
                                    match __field7 {
                                        _serde::export::Some(__field7) =>
                                        __field7,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("thumbnail")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field8 =
                                    match __field8 {
                                        _serde::export::Some(__field8) =>
                                        __field8,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("languages")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field9 =
                                    match __field9 {
                                        _serde::export::Some(__field9) =>
                                        __field9,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("contact_account")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field10 =
                                    match __field10 {
                                        _serde::export::Some(__field10) =>
                                        __field10,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("max_toot_chars")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                _serde::export::Ok(Instance{uri: __field0,
                                                            title: __field1,
                                                            description:
                                                                __field2,
                                                            email: __field3,
                                                            version: __field4,
                                                            urls: __field5,
                                                            stats: __field6,
                                                            thumbnail:
                                                                __field7,
                                                            languages:
                                                                __field8,
                                                            contact_account:
                                                                __field9,
                                                            max_toot_chars:
                                                                __field10,})
                            }
                        }
                        const FIELDS: &'static [&'static str] =
                            &["uri", "title", "description", "email",
                              "version", "urls", "stats", "thumbnail",
                              "languages", "contact_account",
                              "max_toot_chars"];
                        _serde::Deserializer::deserialize_struct(__deserializer,
                                                                 "Instance",
                                                                 FIELDS,
                                                                 __Visitor{marker:
                                                                               _serde::export::PhantomData::<Instance>,
                                                                           lifetime:
                                                                               _serde::export::PhantomData,})
                    }
                }
            };
        impl ::core::marker::StructuralPartialEq for Instance { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for Instance {
            #[inline]
            fn eq(&self, other: &Instance) -> bool {
                match *other {
                    Instance {
                    uri: ref __self_1_0,
                    title: ref __self_1_1,
                    description: ref __self_1_2,
                    email: ref __self_1_3,
                    version: ref __self_1_4,
                    urls: ref __self_1_5,
                    stats: ref __self_1_6,
                    thumbnail: ref __self_1_7,
                    languages: ref __self_1_8,
                    contact_account: ref __self_1_9,
                    max_toot_chars: ref __self_1_10 } =>
                    match *self {
                        Instance {
                        uri: ref __self_0_0,
                        title: ref __self_0_1,
                        description: ref __self_0_2,
                        email: ref __self_0_3,
                        version: ref __self_0_4,
                        urls: ref __self_0_5,
                        stats: ref __self_0_6,
                        thumbnail: ref __self_0_7,
                        languages: ref __self_0_8,
                        contact_account: ref __self_0_9,
                        max_toot_chars: ref __self_0_10 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1) &&
                            (*__self_0_2) == (*__self_1_2) &&
                            (*__self_0_3) == (*__self_1_3) &&
                            (*__self_0_4) == (*__self_1_4) &&
                            (*__self_0_5) == (*__self_1_5) &&
                            (*__self_0_6) == (*__self_1_6) &&
                            (*__self_0_7) == (*__self_1_7) &&
                            (*__self_0_8) == (*__self_1_8) &&
                            (*__self_0_9) == (*__self_1_9) &&
                            (*__self_0_10) == (*__self_1_10),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &Instance) -> bool {
                match *other {
                    Instance {
                    uri: ref __self_1_0,
                    title: ref __self_1_1,
                    description: ref __self_1_2,
                    email: ref __self_1_3,
                    version: ref __self_1_4,
                    urls: ref __self_1_5,
                    stats: ref __self_1_6,
                    thumbnail: ref __self_1_7,
                    languages: ref __self_1_8,
                    contact_account: ref __self_1_9,
                    max_toot_chars: ref __self_1_10 } =>
                    match *self {
                        Instance {
                        uri: ref __self_0_0,
                        title: ref __self_0_1,
                        description: ref __self_0_2,
                        email: ref __self_0_3,
                        version: ref __self_0_4,
                        urls: ref __self_0_5,
                        stats: ref __self_0_6,
                        thumbnail: ref __self_0_7,
                        languages: ref __self_0_8,
                        contact_account: ref __self_0_9,
                        max_toot_chars: ref __self_0_10 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1) ||
                            (*__self_0_2) != (*__self_1_2) ||
                            (*__self_0_3) != (*__self_1_3) ||
                            (*__self_0_4) != (*__self_1_4) ||
                            (*__self_0_5) != (*__self_1_5) ||
                            (*__self_0_6) != (*__self_1_6) ||
                            (*__self_0_7) != (*__self_1_7) ||
                            (*__self_0_8) != (*__self_1_8) ||
                            (*__self_0_9) != (*__self_1_9) ||
                            (*__self_0_10) != (*__self_1_10),
                    },
                }
            }
        }
        /// Object containing url for streaming api.
        pub struct StreamingApi {
            /// Url for streaming API, typically a `wss://` url.
            pub streaming_api: String,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for StreamingApi {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    StreamingApi { streaming_api: ref __self_0_0 } => {
                        let mut debug_trait_builder =
                            f.debug_struct("StreamingApi");
                        let _ =
                            debug_trait_builder.field("streaming_api",
                                                      &&(*__self_0_0));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for StreamingApi {
            #[inline]
            fn clone(&self) -> StreamingApi {
                match *self {
                    StreamingApi { streaming_api: ref __self_0_0 } =>
                    StreamingApi{streaming_api:
                                     ::core::clone::Clone::clone(&(*__self_0_0)),},
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_StreamingApi: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'de> _serde::Deserialize<'de> for StreamingApi {
                    fn deserialize<__D>(__deserializer: __D)
                     -> _serde::export::Result<Self, __D::Error> where
                     __D: _serde::Deserializer<'de> {
                        #[allow(non_camel_case_types)]
                        enum __Field { __field0, __ignore, }
                        struct __FieldVisitor;
                        impl <'de> _serde::de::Visitor<'de> for __FieldVisitor
                         {
                            type Value = __Field;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "field identifier")
                            }
                            fn visit_u64<__E>(self, __value: u64)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    0u64 =>
                                    _serde::export::Ok(__Field::__field0),
                                    _ =>
                                    _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                         &"field index 0 <= i < 1")),
                                }
                            }
                            fn visit_str<__E>(self, __value: &str)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    "streaming_api" =>
                                    _serde::export::Ok(__Field::__field0),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                            fn visit_bytes<__E>(self, __value: &[u8])
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    b"streaming_api" =>
                                    _serde::export::Ok(__Field::__field0),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                        }
                        impl <'de> _serde::Deserialize<'de> for __Field {
                            #[inline]
                            fn deserialize<__D>(__deserializer: __D)
                             -> _serde::export::Result<Self, __D::Error> where
                             __D: _serde::Deserializer<'de> {
                                _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                             __FieldVisitor)
                            }
                        }
                        struct __Visitor<'de> {
                            marker: _serde::export::PhantomData<StreamingApi>,
                            lifetime: _serde::export::PhantomData<&'de ()>,
                        }
                        impl <'de> _serde::de::Visitor<'de> for __Visitor<'de>
                         {
                            type Value = StreamingApi;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "struct StreamingApi")
                            }
                            #[inline]
                            fn visit_seq<__A>(self, mut __seq: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::SeqAccess<'de> {
                                let __field0 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                         &"struct StreamingApi with 1 element"));
                                        }
                                    };
                                _serde::export::Ok(StreamingApi{streaming_api:
                                                                    __field0,})
                            }
                            #[inline]
                            fn visit_map<__A>(self, mut __map: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::MapAccess<'de> {
                                let mut __field0:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                while let _serde::export::Some(__key) =
                                          match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                    match __key {
                                        __Field::__field0 => {
                                            if _serde::export::Option::is_some(&__field0)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("streaming_api"));
                                            }
                                            __field0 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        _ => {
                                            let _ =
                                                match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                    {
                                                    _serde::export::Ok(__val)
                                                    => __val,
                                                    _serde::export::Err(__err)
                                                    => {
                                                        return _serde::export::Err(__err);
                                                    }
                                                };
                                        }
                                    }
                                }
                                let __field0 =
                                    match __field0 {
                                        _serde::export::Some(__field0) =>
                                        __field0,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("streaming_api")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                _serde::export::Ok(StreamingApi{streaming_api:
                                                                    __field0,})
                            }
                        }
                        const FIELDS: &'static [&'static str] =
                            &["streaming_api"];
                        _serde::Deserializer::deserialize_struct(__deserializer,
                                                                 "StreamingApi",
                                                                 FIELDS,
                                                                 __Visitor{marker:
                                                                               _serde::export::PhantomData::<StreamingApi>,
                                                                           lifetime:
                                                                               _serde::export::PhantomData,})
                    }
                }
            };
        impl ::core::marker::StructuralPartialEq for StreamingApi { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for StreamingApi {
            #[inline]
            fn eq(&self, other: &StreamingApi) -> bool {
                match *other {
                    StreamingApi { streaming_api: ref __self_1_0 } =>
                    match *self {
                        StreamingApi { streaming_api: ref __self_0_0 } =>
                        (*__self_0_0) == (*__self_1_0),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &StreamingApi) -> bool {
                match *other {
                    StreamingApi { streaming_api: ref __self_1_0 } =>
                    match *self {
                        StreamingApi { streaming_api: ref __self_0_0 } =>
                        (*__self_0_0) != (*__self_1_0),
                    },
                }
            }
        }
        /// Statistics about the Mastodon instance.
        pub struct Stats {
            user_count: u64,
            status_count: u64,
            domain_count: u64,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for Stats {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    Stats {
                    user_count: ref __self_0_0,
                    status_count: ref __self_0_1,
                    domain_count: ref __self_0_2 } => {
                        let mut debug_trait_builder = f.debug_struct("Stats");
                        let _ =
                            debug_trait_builder.field("user_count",
                                                      &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("status_count",
                                                      &&(*__self_0_1));
                        let _ =
                            debug_trait_builder.field("domain_count",
                                                      &&(*__self_0_2));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for Stats {
            #[inline]
            fn clone(&self) -> Stats {
                {
                    let _: ::core::clone::AssertParamIsClone<u64>;
                    let _: ::core::clone::AssertParamIsClone<u64>;
                    let _: ::core::clone::AssertParamIsClone<u64>;
                    *self
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::marker::Copy for Stats { }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_Stats: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'de> _serde::Deserialize<'de> for Stats {
                    fn deserialize<__D>(__deserializer: __D)
                     -> _serde::export::Result<Self, __D::Error> where
                     __D: _serde::Deserializer<'de> {
                        #[allow(non_camel_case_types)]
                        enum __Field {
                            __field0,
                            __field1,
                            __field2,
                            __ignore,
                        }
                        struct __FieldVisitor;
                        impl <'de> _serde::de::Visitor<'de> for __FieldVisitor
                         {
                            type Value = __Field;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "field identifier")
                            }
                            fn visit_u64<__E>(self, __value: u64)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    0u64 =>
                                    _serde::export::Ok(__Field::__field0),
                                    1u64 =>
                                    _serde::export::Ok(__Field::__field1),
                                    2u64 =>
                                    _serde::export::Ok(__Field::__field2),
                                    _ =>
                                    _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                         &"field index 0 <= i < 3")),
                                }
                            }
                            fn visit_str<__E>(self, __value: &str)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    "user_count" =>
                                    _serde::export::Ok(__Field::__field0),
                                    "status_count" =>
                                    _serde::export::Ok(__Field::__field1),
                                    "domain_count" =>
                                    _serde::export::Ok(__Field::__field2),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                            fn visit_bytes<__E>(self, __value: &[u8])
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    b"user_count" =>
                                    _serde::export::Ok(__Field::__field0),
                                    b"status_count" =>
                                    _serde::export::Ok(__Field::__field1),
                                    b"domain_count" =>
                                    _serde::export::Ok(__Field::__field2),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                        }
                        impl <'de> _serde::Deserialize<'de> for __Field {
                            #[inline]
                            fn deserialize<__D>(__deserializer: __D)
                             -> _serde::export::Result<Self, __D::Error> where
                             __D: _serde::Deserializer<'de> {
                                _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                             __FieldVisitor)
                            }
                        }
                        struct __Visitor<'de> {
                            marker: _serde::export::PhantomData<Stats>,
                            lifetime: _serde::export::PhantomData<&'de ()>,
                        }
                        impl <'de> _serde::de::Visitor<'de> for __Visitor<'de>
                         {
                            type Value = Stats;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "struct Stats")
                            }
                            #[inline]
                            fn visit_seq<__A>(self, mut __seq: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::SeqAccess<'de> {
                                let __field0 =
                                    match match _serde::de::SeqAccess::next_element::<u64>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                         &"struct Stats with 3 elements"));
                                        }
                                    };
                                let __field1 =
                                    match match _serde::de::SeqAccess::next_element::<u64>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(1usize,
                                                                                                         &"struct Stats with 3 elements"));
                                        }
                                    };
                                let __field2 =
                                    match match _serde::de::SeqAccess::next_element::<u64>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(2usize,
                                                                                                         &"struct Stats with 3 elements"));
                                        }
                                    };
                                _serde::export::Ok(Stats{user_count: __field0,
                                                         status_count:
                                                             __field1,
                                                         domain_count:
                                                             __field2,})
                            }
                            #[inline]
                            fn visit_map<__A>(self, mut __map: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::MapAccess<'de> {
                                let mut __field0:
                                        _serde::export::Option<u64> =
                                    _serde::export::None;
                                let mut __field1:
                                        _serde::export::Option<u64> =
                                    _serde::export::None;
                                let mut __field2:
                                        _serde::export::Option<u64> =
                                    _serde::export::None;
                                while let _serde::export::Some(__key) =
                                          match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                    match __key {
                                        __Field::__field0 => {
                                            if _serde::export::Option::is_some(&__field0)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("user_count"));
                                            }
                                            __field0 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<u64>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field1 => {
                                            if _serde::export::Option::is_some(&__field1)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("status_count"));
                                            }
                                            __field1 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<u64>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field2 => {
                                            if _serde::export::Option::is_some(&__field2)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("domain_count"));
                                            }
                                            __field2 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<u64>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        _ => {
                                            let _ =
                                                match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                    {
                                                    _serde::export::Ok(__val)
                                                    => __val,
                                                    _serde::export::Err(__err)
                                                    => {
                                                        return _serde::export::Err(__err);
                                                    }
                                                };
                                        }
                                    }
                                }
                                let __field0 =
                                    match __field0 {
                                        _serde::export::Some(__field0) =>
                                        __field0,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("user_count")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field1 =
                                    match __field1 {
                                        _serde::export::Some(__field1) =>
                                        __field1,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("status_count")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field2 =
                                    match __field2 {
                                        _serde::export::Some(__field2) =>
                                        __field2,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("domain_count")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                _serde::export::Ok(Stats{user_count: __field0,
                                                         status_count:
                                                             __field1,
                                                         domain_count:
                                                             __field2,})
                            }
                        }
                        const FIELDS: &'static [&'static str] =
                            &["user_count", "status_count", "domain_count"];
                        _serde::Deserializer::deserialize_struct(__deserializer,
                                                                 "Stats",
                                                                 FIELDS,
                                                                 __Visitor{marker:
                                                                               _serde::export::PhantomData::<Stats>,
                                                                           lifetime:
                                                                               _serde::export::PhantomData,})
                    }
                }
            };
        impl ::core::marker::StructuralPartialEq for Stats { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for Stats {
            #[inline]
            fn eq(&self, other: &Stats) -> bool {
                match *other {
                    Stats {
                    user_count: ref __self_1_0,
                    status_count: ref __self_1_1,
                    domain_count: ref __self_1_2 } =>
                    match *self {
                        Stats {
                        user_count: ref __self_0_0,
                        status_count: ref __self_0_1,
                        domain_count: ref __self_0_2 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1) &&
                            (*__self_0_2) == (*__self_1_2),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &Stats) -> bool {
                match *other {
                    Stats {
                    user_count: ref __self_1_0,
                    status_count: ref __self_1_1,
                    domain_count: ref __self_1_2 } =>
                    match *self {
                        Stats {
                        user_count: ref __self_0_0,
                        status_count: ref __self_0_1,
                        domain_count: ref __self_0_2 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1) ||
                            (*__self_0_2) != (*__self_1_2),
                    },
                }
            }
        }
    }
    /// Data structures for ser/de of list-related resources
    pub mod list {
        /// Used for ser/de of list resources
        pub struct List {
            id: String,
            title: String,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for List {
            #[inline]
            fn clone(&self) -> List {
                match *self {
                    List { id: ref __self_0_0, title: ref __self_0_1 } =>
                    List{id: ::core::clone::Clone::clone(&(*__self_0_0)),
                         title: ::core::clone::Clone::clone(&(*__self_0_1)),},
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for List {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    List { id: ref __self_0_0, title: ref __self_0_1 } => {
                        let mut debug_trait_builder = f.debug_struct("List");
                        let _ =
                            debug_trait_builder.field("id", &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("title",
                                                      &&(*__self_0_1));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_List: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'de> _serde::Deserialize<'de> for List {
                    fn deserialize<__D>(__deserializer: __D)
                     -> _serde::export::Result<Self, __D::Error> where
                     __D: _serde::Deserializer<'de> {
                        #[allow(non_camel_case_types)]
                        enum __Field { __field0, __field1, __ignore, }
                        struct __FieldVisitor;
                        impl <'de> _serde::de::Visitor<'de> for __FieldVisitor
                         {
                            type Value = __Field;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "field identifier")
                            }
                            fn visit_u64<__E>(self, __value: u64)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    0u64 =>
                                    _serde::export::Ok(__Field::__field0),
                                    1u64 =>
                                    _serde::export::Ok(__Field::__field1),
                                    _ =>
                                    _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                         &"field index 0 <= i < 2")),
                                }
                            }
                            fn visit_str<__E>(self, __value: &str)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    "id" =>
                                    _serde::export::Ok(__Field::__field0),
                                    "title" =>
                                    _serde::export::Ok(__Field::__field1),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                            fn visit_bytes<__E>(self, __value: &[u8])
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    b"id" =>
                                    _serde::export::Ok(__Field::__field0),
                                    b"title" =>
                                    _serde::export::Ok(__Field::__field1),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                        }
                        impl <'de> _serde::Deserialize<'de> for __Field {
                            #[inline]
                            fn deserialize<__D>(__deserializer: __D)
                             -> _serde::export::Result<Self, __D::Error> where
                             __D: _serde::Deserializer<'de> {
                                _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                             __FieldVisitor)
                            }
                        }
                        struct __Visitor<'de> {
                            marker: _serde::export::PhantomData<List>,
                            lifetime: _serde::export::PhantomData<&'de ()>,
                        }
                        impl <'de> _serde::de::Visitor<'de> for __Visitor<'de>
                         {
                            type Value = List;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "struct List")
                            }
                            #[inline]
                            fn visit_seq<__A>(self, mut __seq: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::SeqAccess<'de> {
                                let __field0 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                         &"struct List with 2 elements"));
                                        }
                                    };
                                let __field1 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(1usize,
                                                                                                         &"struct List with 2 elements"));
                                        }
                                    };
                                _serde::export::Ok(List{id: __field0,
                                                        title: __field1,})
                            }
                            #[inline]
                            fn visit_map<__A>(self, mut __map: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::MapAccess<'de> {
                                let mut __field0:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field1:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                while let _serde::export::Some(__key) =
                                          match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                    match __key {
                                        __Field::__field0 => {
                                            if _serde::export::Option::is_some(&__field0)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("id"));
                                            }
                                            __field0 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field1 => {
                                            if _serde::export::Option::is_some(&__field1)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("title"));
                                            }
                                            __field1 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        _ => {
                                            let _ =
                                                match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                    {
                                                    _serde::export::Ok(__val)
                                                    => __val,
                                                    _serde::export::Err(__err)
                                                    => {
                                                        return _serde::export::Err(__err);
                                                    }
                                                };
                                        }
                                    }
                                }
                                let __field0 =
                                    match __field0 {
                                        _serde::export::Some(__field0) =>
                                        __field0,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("id")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field1 =
                                    match __field1 {
                                        _serde::export::Some(__field1) =>
                                        __field1,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("title")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                _serde::export::Ok(List{id: __field0,
                                                        title: __field1,})
                            }
                        }
                        const FIELDS: &'static [&'static str] =
                            &["id", "title"];
                        _serde::Deserializer::deserialize_struct(__deserializer,
                                                                 "List",
                                                                 FIELDS,
                                                                 __Visitor{marker:
                                                                               _serde::export::PhantomData::<List>,
                                                                           lifetime:
                                                                               _serde::export::PhantomData,})
                    }
                }
            };
        impl ::core::marker::StructuralPartialEq for List { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for List {
            #[inline]
            fn eq(&self, other: &List) -> bool {
                match *other {
                    List { id: ref __self_1_0, title: ref __self_1_1 } =>
                    match *self {
                        List { id: ref __self_0_0, title: ref __self_0_1 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &List) -> bool {
                match *other {
                    List { id: ref __self_1_0, title: ref __self_1_1 } =>
                    match *self {
                        List { id: ref __self_0_0, title: ref __self_0_1 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1),
                    },
                }
            }
        }
    }
    /// Data structures for ser/de of mention-related resources
    pub mod mention {
        /// Represents a `mention` used in a status
        pub struct Mention {
            /// URL of user's profile (can be remote)
            pub url: String,
            /// The username of the account
            pub username: String,
            /// Equals username for local users, includes `@domain` for remote ones
            pub acct: String,
            /// Account ID
            pub id: String,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for Mention {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    Mention {
                    url: ref __self_0_0,
                    username: ref __self_0_1,
                    acct: ref __self_0_2,
                    id: ref __self_0_3 } => {
                        let mut debug_trait_builder =
                            f.debug_struct("Mention");
                        let _ =
                            debug_trait_builder.field("url", &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("username",
                                                      &&(*__self_0_1));
                        let _ =
                            debug_trait_builder.field("acct",
                                                      &&(*__self_0_2));
                        let _ =
                            debug_trait_builder.field("id", &&(*__self_0_3));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for Mention {
            #[inline]
            fn clone(&self) -> Mention {
                match *self {
                    Mention {
                    url: ref __self_0_0,
                    username: ref __self_0_1,
                    acct: ref __self_0_2,
                    id: ref __self_0_3 } =>
                    Mention{url: ::core::clone::Clone::clone(&(*__self_0_0)),
                            username:
                                ::core::clone::Clone::clone(&(*__self_0_1)),
                            acct: ::core::clone::Clone::clone(&(*__self_0_2)),
                            id: ::core::clone::Clone::clone(&(*__self_0_3)),},
                }
            }
        }
        impl ::core::marker::StructuralPartialEq for Mention { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for Mention {
            #[inline]
            fn eq(&self, other: &Mention) -> bool {
                match *other {
                    Mention {
                    url: ref __self_1_0,
                    username: ref __self_1_1,
                    acct: ref __self_1_2,
                    id: ref __self_1_3 } =>
                    match *self {
                        Mention {
                        url: ref __self_0_0,
                        username: ref __self_0_1,
                        acct: ref __self_0_2,
                        id: ref __self_0_3 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1) &&
                            (*__self_0_2) == (*__self_1_2) &&
                            (*__self_0_3) == (*__self_1_3),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &Mention) -> bool {
                match *other {
                    Mention {
                    url: ref __self_1_0,
                    username: ref __self_1_1,
                    acct: ref __self_1_2,
                    id: ref __self_1_3 } =>
                    match *self {
                        Mention {
                        url: ref __self_0_0,
                        username: ref __self_0_1,
                        acct: ref __self_0_2,
                        id: ref __self_0_3 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1) ||
                            (*__self_0_2) != (*__self_1_2) ||
                            (*__self_0_3) != (*__self_1_3),
                    },
                }
            }
        }
    }
    /// Data structures for ser/de of notification-related resources
    pub mod notification {
        //! Module containing all info about notifications.
        use super::{account::Account, status::Status};
        use chrono::prelude::*;
        /// A struct containing info about a notification.
        pub struct Notification {
            /// The notification ID.
            pub id: String,
            /// The type of notification.
            #[serde(rename = "type")]
            pub notification_type: NotificationType,
            /// The time the notification was created.
            pub created_at: DateTime<Utc>,
            /// The Account sending the notification to the user.
            pub account: Account,
            /// The Status associated with the notification, if applicable.
            pub status: Option<Status>,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for Notification {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    Notification {
                    id: ref __self_0_0,
                    notification_type: ref __self_0_1,
                    created_at: ref __self_0_2,
                    account: ref __self_0_3,
                    status: ref __self_0_4 } => {
                        let mut debug_trait_builder =
                            f.debug_struct("Notification");
                        let _ =
                            debug_trait_builder.field("id", &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("notification_type",
                                                      &&(*__self_0_1));
                        let _ =
                            debug_trait_builder.field("created_at",
                                                      &&(*__self_0_2));
                        let _ =
                            debug_trait_builder.field("account",
                                                      &&(*__self_0_3));
                        let _ =
                            debug_trait_builder.field("status",
                                                      &&(*__self_0_4));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for Notification {
            #[inline]
            fn clone(&self) -> Notification {
                match *self {
                    Notification {
                    id: ref __self_0_0,
                    notification_type: ref __self_0_1,
                    created_at: ref __self_0_2,
                    account: ref __self_0_3,
                    status: ref __self_0_4 } =>
                    Notification{id:
                                     ::core::clone::Clone::clone(&(*__self_0_0)),
                                 notification_type:
                                     ::core::clone::Clone::clone(&(*__self_0_1)),
                                 created_at:
                                     ::core::clone::Clone::clone(&(*__self_0_2)),
                                 account:
                                     ::core::clone::Clone::clone(&(*__self_0_3)),
                                 status:
                                     ::core::clone::Clone::clone(&(*__self_0_4)),},
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_Notification: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'de> _serde::Deserialize<'de> for Notification {
                    fn deserialize<__D>(__deserializer: __D)
                     -> _serde::export::Result<Self, __D::Error> where
                     __D: _serde::Deserializer<'de> {
                        #[allow(non_camel_case_types)]
                        enum __Field {
                            __field0,
                            __field1,
                            __field2,
                            __field3,
                            __field4,
                            __ignore,
                        }
                        struct __FieldVisitor;
                        impl <'de> _serde::de::Visitor<'de> for __FieldVisitor
                         {
                            type Value = __Field;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "field identifier")
                            }
                            fn visit_u64<__E>(self, __value: u64)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    0u64 =>
                                    _serde::export::Ok(__Field::__field0),
                                    1u64 =>
                                    _serde::export::Ok(__Field::__field1),
                                    2u64 =>
                                    _serde::export::Ok(__Field::__field2),
                                    3u64 =>
                                    _serde::export::Ok(__Field::__field3),
                                    4u64 =>
                                    _serde::export::Ok(__Field::__field4),
                                    _ =>
                                    _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                         &"field index 0 <= i < 5")),
                                }
                            }
                            fn visit_str<__E>(self, __value: &str)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    "id" =>
                                    _serde::export::Ok(__Field::__field0),
                                    "type" =>
                                    _serde::export::Ok(__Field::__field1),
                                    "created_at" =>
                                    _serde::export::Ok(__Field::__field2),
                                    "account" =>
                                    _serde::export::Ok(__Field::__field3),
                                    "status" =>
                                    _serde::export::Ok(__Field::__field4),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                            fn visit_bytes<__E>(self, __value: &[u8])
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    b"id" =>
                                    _serde::export::Ok(__Field::__field0),
                                    b"type" =>
                                    _serde::export::Ok(__Field::__field1),
                                    b"created_at" =>
                                    _serde::export::Ok(__Field::__field2),
                                    b"account" =>
                                    _serde::export::Ok(__Field::__field3),
                                    b"status" =>
                                    _serde::export::Ok(__Field::__field4),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                        }
                        impl <'de> _serde::Deserialize<'de> for __Field {
                            #[inline]
                            fn deserialize<__D>(__deserializer: __D)
                             -> _serde::export::Result<Self, __D::Error> where
                             __D: _serde::Deserializer<'de> {
                                _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                             __FieldVisitor)
                            }
                        }
                        struct __Visitor<'de> {
                            marker: _serde::export::PhantomData<Notification>,
                            lifetime: _serde::export::PhantomData<&'de ()>,
                        }
                        impl <'de> _serde::de::Visitor<'de> for __Visitor<'de>
                         {
                            type Value = Notification;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "struct Notification")
                            }
                            #[inline]
                            fn visit_seq<__A>(self, mut __seq: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::SeqAccess<'de> {
                                let __field0 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                         &"struct Notification with 5 elements"));
                                        }
                                    };
                                let __field1 =
                                    match match _serde::de::SeqAccess::next_element::<NotificationType>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(1usize,
                                                                                                         &"struct Notification with 5 elements"));
                                        }
                                    };
                                let __field2 =
                                    match match _serde::de::SeqAccess::next_element::<DateTime<Utc>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(2usize,
                                                                                                         &"struct Notification with 5 elements"));
                                        }
                                    };
                                let __field3 =
                                    match match _serde::de::SeqAccess::next_element::<Account>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(3usize,
                                                                                                         &"struct Notification with 5 elements"));
                                        }
                                    };
                                let __field4 =
                                    match match _serde::de::SeqAccess::next_element::<Option<Status>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(4usize,
                                                                                                         &"struct Notification with 5 elements"));
                                        }
                                    };
                                _serde::export::Ok(Notification{id: __field0,
                                                                notification_type:
                                                                    __field1,
                                                                created_at:
                                                                    __field2,
                                                                account:
                                                                    __field3,
                                                                status:
                                                                    __field4,})
                            }
                            #[inline]
                            fn visit_map<__A>(self, mut __map: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::MapAccess<'de> {
                                let mut __field0:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field1:
                                        _serde::export::Option<NotificationType> =
                                    _serde::export::None;
                                let mut __field2:
                                        _serde::export::Option<DateTime<Utc>> =
                                    _serde::export::None;
                                let mut __field3:
                                        _serde::export::Option<Account> =
                                    _serde::export::None;
                                let mut __field4:
                                        _serde::export::Option<Option<Status>> =
                                    _serde::export::None;
                                while let _serde::export::Some(__key) =
                                          match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                    match __key {
                                        __Field::__field0 => {
                                            if _serde::export::Option::is_some(&__field0)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("id"));
                                            }
                                            __field0 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field1 => {
                                            if _serde::export::Option::is_some(&__field1)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("type"));
                                            }
                                            __field1 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<NotificationType>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field2 => {
                                            if _serde::export::Option::is_some(&__field2)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("created_at"));
                                            }
                                            __field2 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<DateTime<Utc>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field3 => {
                                            if _serde::export::Option::is_some(&__field3)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("account"));
                                            }
                                            __field3 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Account>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field4 => {
                                            if _serde::export::Option::is_some(&__field4)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("status"));
                                            }
                                            __field4 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<Status>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        _ => {
                                            let _ =
                                                match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                    {
                                                    _serde::export::Ok(__val)
                                                    => __val,
                                                    _serde::export::Err(__err)
                                                    => {
                                                        return _serde::export::Err(__err);
                                                    }
                                                };
                                        }
                                    }
                                }
                                let __field0 =
                                    match __field0 {
                                        _serde::export::Some(__field0) =>
                                        __field0,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("id")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field1 =
                                    match __field1 {
                                        _serde::export::Some(__field1) =>
                                        __field1,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("type")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field2 =
                                    match __field2 {
                                        _serde::export::Some(__field2) =>
                                        __field2,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("created_at")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field3 =
                                    match __field3 {
                                        _serde::export::Some(__field3) =>
                                        __field3,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("account")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field4 =
                                    match __field4 {
                                        _serde::export::Some(__field4) =>
                                        __field4,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("status")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                _serde::export::Ok(Notification{id: __field0,
                                                                notification_type:
                                                                    __field1,
                                                                created_at:
                                                                    __field2,
                                                                account:
                                                                    __field3,
                                                                status:
                                                                    __field4,})
                            }
                        }
                        const FIELDS: &'static [&'static str] =
                            &["id", "type", "created_at", "account",
                              "status"];
                        _serde::Deserializer::deserialize_struct(__deserializer,
                                                                 "Notification",
                                                                 FIELDS,
                                                                 __Visitor{marker:
                                                                               _serde::export::PhantomData::<Notification>,
                                                                           lifetime:
                                                                               _serde::export::PhantomData,})
                    }
                }
            };
        impl ::core::marker::StructuralPartialEq for Notification { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for Notification {
            #[inline]
            fn eq(&self, other: &Notification) -> bool {
                match *other {
                    Notification {
                    id: ref __self_1_0,
                    notification_type: ref __self_1_1,
                    created_at: ref __self_1_2,
                    account: ref __self_1_3,
                    status: ref __self_1_4 } =>
                    match *self {
                        Notification {
                        id: ref __self_0_0,
                        notification_type: ref __self_0_1,
                        created_at: ref __self_0_2,
                        account: ref __self_0_3,
                        status: ref __self_0_4 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1) &&
                            (*__self_0_2) == (*__self_1_2) &&
                            (*__self_0_3) == (*__self_1_3) &&
                            (*__self_0_4) == (*__self_1_4),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &Notification) -> bool {
                match *other {
                    Notification {
                    id: ref __self_1_0,
                    notification_type: ref __self_1_1,
                    created_at: ref __self_1_2,
                    account: ref __self_1_3,
                    status: ref __self_1_4 } =>
                    match *self {
                        Notification {
                        id: ref __self_0_0,
                        notification_type: ref __self_0_1,
                        created_at: ref __self_0_2,
                        account: ref __self_0_3,
                        status: ref __self_0_4 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1) ||
                            (*__self_0_2) != (*__self_1_2) ||
                            (*__self_0_3) != (*__self_1_3) ||
                            (*__self_0_4) != (*__self_1_4),
                    },
                }
            }
        }
        /// The type of notification.
        #[serde(rename_all = "lowercase")]
        pub enum NotificationType {

            /// Someone mentioned the application client in another status.
            Mention,

            /// Someone reblogged one of the application client's statuses.
            Reblog,

            /// Someone favourited one of the application client's statuses.
            Favourite,

            /// Someone followed the application client.
            Follow,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for NotificationType {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match (&*self,) {
                    (&NotificationType::Mention,) => {
                        let mut debug_trait_builder =
                            f.debug_tuple("Mention");
                        debug_trait_builder.finish()
                    }
                    (&NotificationType::Reblog,) => {
                        let mut debug_trait_builder = f.debug_tuple("Reblog");
                        debug_trait_builder.finish()
                    }
                    (&NotificationType::Favourite,) => {
                        let mut debug_trait_builder =
                            f.debug_tuple("Favourite");
                        debug_trait_builder.finish()
                    }
                    (&NotificationType::Follow,) => {
                        let mut debug_trait_builder = f.debug_tuple("Follow");
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for NotificationType {
            #[inline]
            fn clone(&self) -> NotificationType { { *self } }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::marker::Copy for NotificationType { }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_NotificationType: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'de> _serde::Deserialize<'de> for NotificationType {
                    fn deserialize<__D>(__deserializer: __D)
                     -> _serde::export::Result<Self, __D::Error> where
                     __D: _serde::Deserializer<'de> {
                        #[allow(non_camel_case_types)]
                        enum __Field {
                            __field0,
                            __field1,
                            __field2,
                            __field3,
                        }
                        struct __FieldVisitor;
                        impl <'de> _serde::de::Visitor<'de> for __FieldVisitor
                         {
                            type Value = __Field;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "variant identifier")
                            }
                            fn visit_u64<__E>(self, __value: u64)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    0u64 =>
                                    _serde::export::Ok(__Field::__field0),
                                    1u64 =>
                                    _serde::export::Ok(__Field::__field1),
                                    2u64 =>
                                    _serde::export::Ok(__Field::__field2),
                                    3u64 =>
                                    _serde::export::Ok(__Field::__field3),
                                    _ =>
                                    _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                         &"variant index 0 <= i < 4")),
                                }
                            }
                            fn visit_str<__E>(self, __value: &str)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    "mention" =>
                                    _serde::export::Ok(__Field::__field0),
                                    "reblog" =>
                                    _serde::export::Ok(__Field::__field1),
                                    "favourite" =>
                                    _serde::export::Ok(__Field::__field2),
                                    "follow" =>
                                    _serde::export::Ok(__Field::__field3),
                                    _ => {
                                        _serde::export::Err(_serde::de::Error::unknown_variant(__value,
                                                                                               VARIANTS))
                                    }
                                }
                            }
                            fn visit_bytes<__E>(self, __value: &[u8])
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    b"mention" =>
                                    _serde::export::Ok(__Field::__field0),
                                    b"reblog" =>
                                    _serde::export::Ok(__Field::__field1),
                                    b"favourite" =>
                                    _serde::export::Ok(__Field::__field2),
                                    b"follow" =>
                                    _serde::export::Ok(__Field::__field3),
                                    _ => {
                                        let __value =
                                            &_serde::export::from_utf8_lossy(__value);
                                        _serde::export::Err(_serde::de::Error::unknown_variant(__value,
                                                                                               VARIANTS))
                                    }
                                }
                            }
                        }
                        impl <'de> _serde::Deserialize<'de> for __Field {
                            #[inline]
                            fn deserialize<__D>(__deserializer: __D)
                             -> _serde::export::Result<Self, __D::Error> where
                             __D: _serde::Deserializer<'de> {
                                _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                             __FieldVisitor)
                            }
                        }
                        struct __Visitor<'de> {
                            marker: _serde::export::PhantomData<NotificationType>,
                            lifetime: _serde::export::PhantomData<&'de ()>,
                        }
                        impl <'de> _serde::de::Visitor<'de> for __Visitor<'de>
                         {
                            type Value = NotificationType;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "enum NotificationType")
                            }
                            fn visit_enum<__A>(self, __data: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::EnumAccess<'de> {
                                match match _serde::de::EnumAccess::variant(__data)
                                          {
                                          _serde::export::Ok(__val) => __val,
                                          _serde::export::Err(__err) => {
                                              return _serde::export::Err(__err);
                                          }
                                      } {
                                    (__Field::__field0, __variant) => {
                                        match _serde::de::VariantAccess::unit_variant(__variant)
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        };
                                        _serde::export::Ok(NotificationType::Mention)
                                    }
                                    (__Field::__field1, __variant) => {
                                        match _serde::de::VariantAccess::unit_variant(__variant)
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        };
                                        _serde::export::Ok(NotificationType::Reblog)
                                    }
                                    (__Field::__field2, __variant) => {
                                        match _serde::de::VariantAccess::unit_variant(__variant)
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        };
                                        _serde::export::Ok(NotificationType::Favourite)
                                    }
                                    (__Field::__field3, __variant) => {
                                        match _serde::de::VariantAccess::unit_variant(__variant)
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        };
                                        _serde::export::Ok(NotificationType::Follow)
                                    }
                                }
                            }
                        }
                        const VARIANTS: &'static [&'static str] =
                            &["mention", "reblog", "favourite", "follow"];
                        _serde::Deserializer::deserialize_enum(__deserializer,
                                                               "NotificationType",
                                                               VARIANTS,
                                                               __Visitor{marker:
                                                                             _serde::export::PhantomData::<NotificationType>,
                                                                         lifetime:
                                                                             _serde::export::PhantomData,})
                    }
                }
            };
        impl ::core::marker::StructuralPartialEq for NotificationType { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for NotificationType {
            #[inline]
            fn eq(&self, other: &NotificationType) -> bool {
                {
                    let __self_vi =
                        unsafe {
                            ::core::intrinsics::discriminant_value(&*self)
                        };
                    let __arg_1_vi =
                        unsafe {
                            ::core::intrinsics::discriminant_value(&*other)
                        };
                    if true && __self_vi == __arg_1_vi {
                        match (&*self, &*other) { _ => true, }
                    } else { false }
                }
            }
        }
    }
    /// Data structures for ser/de of push-subscription-related resources
    pub mod push {
        /// Represents the `alerts` key of the `Subscription` object
        pub struct Alerts {
            /// flag for follow alerts
            pub follow: Option<bool>,
            /// flag for favourite alerts
            pub favourite: Option<bool>,
            /// flag for reblog alerts
            pub reblog: Option<bool>,
            /// flag for mention alerts
            pub mention: Option<bool>,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for Alerts {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    Alerts {
                    follow: ref __self_0_0,
                    favourite: ref __self_0_1,
                    reblog: ref __self_0_2,
                    mention: ref __self_0_3 } => {
                        let mut debug_trait_builder =
                            f.debug_struct("Alerts");
                        let _ =
                            debug_trait_builder.field("follow",
                                                      &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("favourite",
                                                      &&(*__self_0_1));
                        let _ =
                            debug_trait_builder.field("reblog",
                                                      &&(*__self_0_2));
                        let _ =
                            debug_trait_builder.field("mention",
                                                      &&(*__self_0_3));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for Alerts {
            #[inline]
            fn clone(&self) -> Alerts {
                {
                    let _: ::core::clone::AssertParamIsClone<Option<bool>>;
                    let _: ::core::clone::AssertParamIsClone<Option<bool>>;
                    let _: ::core::clone::AssertParamIsClone<Option<bool>>;
                    let _: ::core::clone::AssertParamIsClone<Option<bool>>;
                    *self
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::marker::Copy for Alerts { }
        impl ::core::marker::StructuralPartialEq for Alerts { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for Alerts {
            #[inline]
            fn eq(&self, other: &Alerts) -> bool {
                match *other {
                    Alerts {
                    follow: ref __self_1_0,
                    favourite: ref __self_1_1,
                    reblog: ref __self_1_2,
                    mention: ref __self_1_3 } =>
                    match *self {
                        Alerts {
                        follow: ref __self_0_0,
                        favourite: ref __self_0_1,
                        reblog: ref __self_0_2,
                        mention: ref __self_0_3 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1) &&
                            (*__self_0_2) == (*__self_1_2) &&
                            (*__self_0_3) == (*__self_1_3),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &Alerts) -> bool {
                match *other {
                    Alerts {
                    follow: ref __self_1_0,
                    favourite: ref __self_1_1,
                    reblog: ref __self_1_2,
                    mention: ref __self_1_3 } =>
                    match *self {
                        Alerts {
                        follow: ref __self_0_0,
                        favourite: ref __self_0_1,
                        reblog: ref __self_0_2,
                        mention: ref __self_0_3 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1) ||
                            (*__self_0_2) != (*__self_1_2) ||
                            (*__self_0_3) != (*__self_1_3),
                    },
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_SERIALIZE_FOR_Alerts: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl _serde::Serialize for Alerts {
                    fn serialize<__S>(&self, __serializer: __S)
                     -> _serde::export::Result<__S::Ok, __S::Error> where
                     __S: _serde::Serializer {
                        let mut __serde_state =
                            match _serde::Serializer::serialize_struct(__serializer,
                                                                       "Alerts",
                                                                       false
                                                                           as
                                                                           usize
                                                                           + 1
                                                                           + 1
                                                                           + 1
                                                                           +
                                                                           1)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "follow",
                                                                            &self.follow)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "favourite",
                                                                            &self.favourite)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "reblog",
                                                                            &self.reblog)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "mention",
                                                                            &self.mention)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        _serde::ser::SerializeStruct::end(__serde_state)
                    }
                }
            };
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_Alerts: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'de> _serde::Deserialize<'de> for Alerts {
                    fn deserialize<__D>(__deserializer: __D)
                     -> _serde::export::Result<Self, __D::Error> where
                     __D: _serde::Deserializer<'de> {
                        #[allow(non_camel_case_types)]
                        enum __Field {
                            __field0,
                            __field1,
                            __field2,
                            __field3,
                            __ignore,
                        }
                        struct __FieldVisitor;
                        impl <'de> _serde::de::Visitor<'de> for __FieldVisitor
                         {
                            type Value = __Field;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "field identifier")
                            }
                            fn visit_u64<__E>(self, __value: u64)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    0u64 =>
                                    _serde::export::Ok(__Field::__field0),
                                    1u64 =>
                                    _serde::export::Ok(__Field::__field1),
                                    2u64 =>
                                    _serde::export::Ok(__Field::__field2),
                                    3u64 =>
                                    _serde::export::Ok(__Field::__field3),
                                    _ =>
                                    _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                         &"field index 0 <= i < 4")),
                                }
                            }
                            fn visit_str<__E>(self, __value: &str)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    "follow" =>
                                    _serde::export::Ok(__Field::__field0),
                                    "favourite" =>
                                    _serde::export::Ok(__Field::__field1),
                                    "reblog" =>
                                    _serde::export::Ok(__Field::__field2),
                                    "mention" =>
                                    _serde::export::Ok(__Field::__field3),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                            fn visit_bytes<__E>(self, __value: &[u8])
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    b"follow" =>
                                    _serde::export::Ok(__Field::__field0),
                                    b"favourite" =>
                                    _serde::export::Ok(__Field::__field1),
                                    b"reblog" =>
                                    _serde::export::Ok(__Field::__field2),
                                    b"mention" =>
                                    _serde::export::Ok(__Field::__field3),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                        }
                        impl <'de> _serde::Deserialize<'de> for __Field {
                            #[inline]
                            fn deserialize<__D>(__deserializer: __D)
                             -> _serde::export::Result<Self, __D::Error> where
                             __D: _serde::Deserializer<'de> {
                                _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                             __FieldVisitor)
                            }
                        }
                        struct __Visitor<'de> {
                            marker: _serde::export::PhantomData<Alerts>,
                            lifetime: _serde::export::PhantomData<&'de ()>,
                        }
                        impl <'de> _serde::de::Visitor<'de> for __Visitor<'de>
                         {
                            type Value = Alerts;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "struct Alerts")
                            }
                            #[inline]
                            fn visit_seq<__A>(self, mut __seq: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::SeqAccess<'de> {
                                let __field0 =
                                    match match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                         &"struct Alerts with 4 elements"));
                                        }
                                    };
                                let __field1 =
                                    match match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(1usize,
                                                                                                         &"struct Alerts with 4 elements"));
                                        }
                                    };
                                let __field2 =
                                    match match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(2usize,
                                                                                                         &"struct Alerts with 4 elements"));
                                        }
                                    };
                                let __field3 =
                                    match match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(3usize,
                                                                                                         &"struct Alerts with 4 elements"));
                                        }
                                    };
                                _serde::export::Ok(Alerts{follow: __field0,
                                                          favourite: __field1,
                                                          reblog: __field2,
                                                          mention: __field3,})
                            }
                            #[inline]
                            fn visit_map<__A>(self, mut __map: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::MapAccess<'de> {
                                let mut __field0:
                                        _serde::export::Option<Option<bool>> =
                                    _serde::export::None;
                                let mut __field1:
                                        _serde::export::Option<Option<bool>> =
                                    _serde::export::None;
                                let mut __field2:
                                        _serde::export::Option<Option<bool>> =
                                    _serde::export::None;
                                let mut __field3:
                                        _serde::export::Option<Option<bool>> =
                                    _serde::export::None;
                                while let _serde::export::Some(__key) =
                                          match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                    match __key {
                                        __Field::__field0 => {
                                            if _serde::export::Option::is_some(&__field0)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("follow"));
                                            }
                                            __field0 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field1 => {
                                            if _serde::export::Option::is_some(&__field1)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("favourite"));
                                            }
                                            __field1 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field2 => {
                                            if _serde::export::Option::is_some(&__field2)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("reblog"));
                                            }
                                            __field2 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field3 => {
                                            if _serde::export::Option::is_some(&__field3)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("mention"));
                                            }
                                            __field3 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        _ => {
                                            let _ =
                                                match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                    {
                                                    _serde::export::Ok(__val)
                                                    => __val,
                                                    _serde::export::Err(__err)
                                                    => {
                                                        return _serde::export::Err(__err);
                                                    }
                                                };
                                        }
                                    }
                                }
                                let __field0 =
                                    match __field0 {
                                        _serde::export::Some(__field0) =>
                                        __field0,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("follow")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field1 =
                                    match __field1 {
                                        _serde::export::Some(__field1) =>
                                        __field1,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("favourite")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field2 =
                                    match __field2 {
                                        _serde::export::Some(__field2) =>
                                        __field2,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("reblog")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field3 =
                                    match __field3 {
                                        _serde::export::Some(__field3) =>
                                        __field3,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("mention")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                _serde::export::Ok(Alerts{follow: __field0,
                                                          favourite: __field1,
                                                          reblog: __field2,
                                                          mention: __field3,})
                            }
                        }
                        const FIELDS: &'static [&'static str] =
                            &["follow", "favourite", "reblog", "mention"];
                        _serde::Deserializer::deserialize_struct(__deserializer,
                                                                 "Alerts",
                                                                 FIELDS,
                                                                 __Visitor{marker:
                                                                               _serde::export::PhantomData::<Alerts>,
                                                                           lifetime:
                                                                               _serde::export::PhantomData,})
                    }
                }
            };
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::default::Default for Alerts {
            #[inline]
            fn default() -> Alerts {
                Alerts{follow: ::core::default::Default::default(),
                       favourite: ::core::default::Default::default(),
                       reblog: ::core::default::Default::default(),
                       mention: ::core::default::Default::default(),}
            }
        }
        /// Represents a new Push subscription
        pub struct Subscription {
            /// The `id` of the subscription
            pub id: String,
            /// The endpoint of the subscription
            pub endpoint: String,
            /// The server key of the subscription
            pub server_key: String,
            /// The status of the alerts for this subscription
            pub alerts: Option<Alerts>,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for Subscription {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    Subscription {
                    id: ref __self_0_0,
                    endpoint: ref __self_0_1,
                    server_key: ref __self_0_2,
                    alerts: ref __self_0_3 } => {
                        let mut debug_trait_builder =
                            f.debug_struct("Subscription");
                        let _ =
                            debug_trait_builder.field("id", &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("endpoint",
                                                      &&(*__self_0_1));
                        let _ =
                            debug_trait_builder.field("server_key",
                                                      &&(*__self_0_2));
                        let _ =
                            debug_trait_builder.field("alerts",
                                                      &&(*__self_0_3));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for Subscription {
            #[inline]
            fn clone(&self) -> Subscription {
                match *self {
                    Subscription {
                    id: ref __self_0_0,
                    endpoint: ref __self_0_1,
                    server_key: ref __self_0_2,
                    alerts: ref __self_0_3 } =>
                    Subscription{id:
                                     ::core::clone::Clone::clone(&(*__self_0_0)),
                                 endpoint:
                                     ::core::clone::Clone::clone(&(*__self_0_1)),
                                 server_key:
                                     ::core::clone::Clone::clone(&(*__self_0_2)),
                                 alerts:
                                     ::core::clone::Clone::clone(&(*__self_0_3)),},
                }
            }
        }
        impl ::core::marker::StructuralPartialEq for Subscription { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for Subscription {
            #[inline]
            fn eq(&self, other: &Subscription) -> bool {
                match *other {
                    Subscription {
                    id: ref __self_1_0,
                    endpoint: ref __self_1_1,
                    server_key: ref __self_1_2,
                    alerts: ref __self_1_3 } =>
                    match *self {
                        Subscription {
                        id: ref __self_0_0,
                        endpoint: ref __self_0_1,
                        server_key: ref __self_0_2,
                        alerts: ref __self_0_3 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1) &&
                            (*__self_0_2) == (*__self_1_2) &&
                            (*__self_0_3) == (*__self_1_3),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &Subscription) -> bool {
                match *other {
                    Subscription {
                    id: ref __self_1_0,
                    endpoint: ref __self_1_1,
                    server_key: ref __self_1_2,
                    alerts: ref __self_1_3 } =>
                    match *self {
                        Subscription {
                        id: ref __self_0_0,
                        endpoint: ref __self_0_1,
                        server_key: ref __self_0_2,
                        alerts: ref __self_0_3 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1) ||
                            (*__self_0_2) != (*__self_1_2) ||
                            (*__self_0_3) != (*__self_1_3),
                    },
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_Subscription: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'de> _serde::Deserialize<'de> for Subscription {
                    fn deserialize<__D>(__deserializer: __D)
                     -> _serde::export::Result<Self, __D::Error> where
                     __D: _serde::Deserializer<'de> {
                        #[allow(non_camel_case_types)]
                        enum __Field {
                            __field0,
                            __field1,
                            __field2,
                            __field3,
                            __ignore,
                        }
                        struct __FieldVisitor;
                        impl <'de> _serde::de::Visitor<'de> for __FieldVisitor
                         {
                            type Value = __Field;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "field identifier")
                            }
                            fn visit_u64<__E>(self, __value: u64)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    0u64 =>
                                    _serde::export::Ok(__Field::__field0),
                                    1u64 =>
                                    _serde::export::Ok(__Field::__field1),
                                    2u64 =>
                                    _serde::export::Ok(__Field::__field2),
                                    3u64 =>
                                    _serde::export::Ok(__Field::__field3),
                                    _ =>
                                    _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                         &"field index 0 <= i < 4")),
                                }
                            }
                            fn visit_str<__E>(self, __value: &str)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    "id" =>
                                    _serde::export::Ok(__Field::__field0),
                                    "endpoint" =>
                                    _serde::export::Ok(__Field::__field1),
                                    "server_key" =>
                                    _serde::export::Ok(__Field::__field2),
                                    "alerts" =>
                                    _serde::export::Ok(__Field::__field3),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                            fn visit_bytes<__E>(self, __value: &[u8])
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    b"id" =>
                                    _serde::export::Ok(__Field::__field0),
                                    b"endpoint" =>
                                    _serde::export::Ok(__Field::__field1),
                                    b"server_key" =>
                                    _serde::export::Ok(__Field::__field2),
                                    b"alerts" =>
                                    _serde::export::Ok(__Field::__field3),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                        }
                        impl <'de> _serde::Deserialize<'de> for __Field {
                            #[inline]
                            fn deserialize<__D>(__deserializer: __D)
                             -> _serde::export::Result<Self, __D::Error> where
                             __D: _serde::Deserializer<'de> {
                                _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                             __FieldVisitor)
                            }
                        }
                        struct __Visitor<'de> {
                            marker: _serde::export::PhantomData<Subscription>,
                            lifetime: _serde::export::PhantomData<&'de ()>,
                        }
                        impl <'de> _serde::de::Visitor<'de> for __Visitor<'de>
                         {
                            type Value = Subscription;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "struct Subscription")
                            }
                            #[inline]
                            fn visit_seq<__A>(self, mut __seq: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::SeqAccess<'de> {
                                let __field0 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                         &"struct Subscription with 4 elements"));
                                        }
                                    };
                                let __field1 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(1usize,
                                                                                                         &"struct Subscription with 4 elements"));
                                        }
                                    };
                                let __field2 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(2usize,
                                                                                                         &"struct Subscription with 4 elements"));
                                        }
                                    };
                                let __field3 =
                                    match match _serde::de::SeqAccess::next_element::<Option<Alerts>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(3usize,
                                                                                                         &"struct Subscription with 4 elements"));
                                        }
                                    };
                                _serde::export::Ok(Subscription{id: __field0,
                                                                endpoint:
                                                                    __field1,
                                                                server_key:
                                                                    __field2,
                                                                alerts:
                                                                    __field3,})
                            }
                            #[inline]
                            fn visit_map<__A>(self, mut __map: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::MapAccess<'de> {
                                let mut __field0:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field1:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field2:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field3:
                                        _serde::export::Option<Option<Alerts>> =
                                    _serde::export::None;
                                while let _serde::export::Some(__key) =
                                          match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                    match __key {
                                        __Field::__field0 => {
                                            if _serde::export::Option::is_some(&__field0)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("id"));
                                            }
                                            __field0 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field1 => {
                                            if _serde::export::Option::is_some(&__field1)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("endpoint"));
                                            }
                                            __field1 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field2 => {
                                            if _serde::export::Option::is_some(&__field2)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("server_key"));
                                            }
                                            __field2 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field3 => {
                                            if _serde::export::Option::is_some(&__field3)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("alerts"));
                                            }
                                            __field3 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<Alerts>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        _ => {
                                            let _ =
                                                match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                    {
                                                    _serde::export::Ok(__val)
                                                    => __val,
                                                    _serde::export::Err(__err)
                                                    => {
                                                        return _serde::export::Err(__err);
                                                    }
                                                };
                                        }
                                    }
                                }
                                let __field0 =
                                    match __field0 {
                                        _serde::export::Some(__field0) =>
                                        __field0,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("id")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field1 =
                                    match __field1 {
                                        _serde::export::Some(__field1) =>
                                        __field1,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("endpoint")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field2 =
                                    match __field2 {
                                        _serde::export::Some(__field2) =>
                                        __field2,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("server_key")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field3 =
                                    match __field3 {
                                        _serde::export::Some(__field3) =>
                                        __field3,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("alerts")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                _serde::export::Ok(Subscription{id: __field0,
                                                                endpoint:
                                                                    __field1,
                                                                server_key:
                                                                    __field2,
                                                                alerts:
                                                                    __field3,})
                            }
                        }
                        const FIELDS: &'static [&'static str] =
                            &["id", "endpoint", "server_key", "alerts"];
                        _serde::Deserializer::deserialize_struct(__deserializer,
                                                                 "Subscription",
                                                                 FIELDS,
                                                                 __Visitor{marker:
                                                                               _serde::export::PhantomData::<Subscription>,
                                                                           lifetime:
                                                                               _serde::export::PhantomData,})
                    }
                }
            };
        pub(crate) mod add_subscription {
            use super::Alerts;
            pub(crate) struct Form {
                pub(crate) subscription: Subscription,
                pub(crate) data: Option<Data>,
            }
            #[automatically_derived]
            #[allow(unused_qualifications)]
            impl ::core::fmt::Debug for Form {
                fn fmt(&self, f: &mut ::core::fmt::Formatter)
                 -> ::core::fmt::Result {
                    match *self {
                        Form {
                        subscription: ref __self_0_0, data: ref __self_0_1 }
                        => {
                            let mut debug_trait_builder =
                                f.debug_struct("Form");
                            let _ =
                                debug_trait_builder.field("subscription",
                                                          &&(*__self_0_0));
                            let _ =
                                debug_trait_builder.field("data",
                                                          &&(*__self_0_1));
                            debug_trait_builder.finish()
                        }
                    }
                }
            }
            #[automatically_derived]
            #[allow(unused_qualifications)]
            impl ::core::clone::Clone for Form {
                #[inline]
                fn clone(&self) -> Form {
                    match *self {
                        Form {
                        subscription: ref __self_0_0, data: ref __self_0_1 }
                        =>
                        Form{subscription:
                                 ::core::clone::Clone::clone(&(*__self_0_0)),
                             data:
                                 ::core::clone::Clone::clone(&(*__self_0_1)),},
                    }
                }
            }
            impl ::core::marker::StructuralPartialEq for Form { }
            #[automatically_derived]
            #[allow(unused_qualifications)]
            impl ::core::cmp::PartialEq for Form {
                #[inline]
                fn eq(&self, other: &Form) -> bool {
                    match *other {
                        Form {
                        subscription: ref __self_1_0, data: ref __self_1_1 }
                        =>
                        match *self {
                            Form {
                            subscription: ref __self_0_0, data: ref __self_0_1
                            } =>
                            (*__self_0_0) == (*__self_1_0) &&
                                (*__self_0_1) == (*__self_1_1),
                        },
                    }
                }
                #[inline]
                fn ne(&self, other: &Form) -> bool {
                    match *other {
                        Form {
                        subscription: ref __self_1_0, data: ref __self_1_1 }
                        =>
                        match *self {
                            Form {
                            subscription: ref __self_0_0, data: ref __self_0_1
                            } =>
                            (*__self_0_0) != (*__self_1_0) ||
                                (*__self_0_1) != (*__self_1_1),
                        },
                    }
                }
            }
            #[doc(hidden)]
            #[allow(non_upper_case_globals, unused_attributes,
                    unused_qualifications)]
            const _IMPL_SERIALIZE_FOR_Form: () =
                {
                    #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                    extern crate serde as _serde;
                    #[allow(unused_macros)]
                    macro_rules! try {
                        ($ __expr : expr) =>
                        {
                            match $ __expr
                            {
                                _serde :: export :: Ok(__val) => __val, _serde
                                :: export :: Err(__err) =>
                                { return _serde :: export :: Err(__err) ; }
                            }
                        }
                    }
                    #[automatically_derived]
                    impl _serde::Serialize for Form {
                        fn serialize<__S>(&self, __serializer: __S)
                         -> _serde::export::Result<__S::Ok, __S::Error> where
                         __S: _serde::Serializer {
                            let mut __serde_state =
                                match _serde::Serializer::serialize_struct(__serializer,
                                                                           "Form",
                                                                           false
                                                                               as
                                                                               usize
                                                                               +
                                                                               1
                                                                               +
                                                                               1)
                                    {
                                    _serde::export::Ok(__val) => __val,
                                    _serde::export::Err(__err) => {
                                        return _serde::export::Err(__err);
                                    }
                                };
                            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                "subscription",
                                                                                &self.subscription)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                "data",
                                                                                &self.data)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                            _serde::ser::SerializeStruct::end(__serde_state)
                        }
                    }
                };
            #[automatically_derived]
            #[allow(unused_qualifications)]
            impl ::core::default::Default for Form {
                #[inline]
                fn default() -> Form {
                    Form{subscription: ::core::default::Default::default(),
                         data: ::core::default::Default::default(),}
                }
            }
            pub(crate) struct Subscription {
                pub(crate) endpoint: String,
                pub(crate) keys: Keys,
            }
            #[automatically_derived]
            #[allow(unused_qualifications)]
            impl ::core::fmt::Debug for Subscription {
                fn fmt(&self, f: &mut ::core::fmt::Formatter)
                 -> ::core::fmt::Result {
                    match *self {
                        Subscription {
                        endpoint: ref __self_0_0, keys: ref __self_0_1 } => {
                            let mut debug_trait_builder =
                                f.debug_struct("Subscription");
                            let _ =
                                debug_trait_builder.field("endpoint",
                                                          &&(*__self_0_0));
                            let _ =
                                debug_trait_builder.field("keys",
                                                          &&(*__self_0_1));
                            debug_trait_builder.finish()
                        }
                    }
                }
            }
            #[automatically_derived]
            #[allow(unused_qualifications)]
            impl ::core::clone::Clone for Subscription {
                #[inline]
                fn clone(&self) -> Subscription {
                    match *self {
                        Subscription {
                        endpoint: ref __self_0_0, keys: ref __self_0_1 } =>
                        Subscription{endpoint:
                                         ::core::clone::Clone::clone(&(*__self_0_0)),
                                     keys:
                                         ::core::clone::Clone::clone(&(*__self_0_1)),},
                    }
                }
            }
            impl ::core::marker::StructuralPartialEq for Subscription { }
            #[automatically_derived]
            #[allow(unused_qualifications)]
            impl ::core::cmp::PartialEq for Subscription {
                #[inline]
                fn eq(&self, other: &Subscription) -> bool {
                    match *other {
                        Subscription {
                        endpoint: ref __self_1_0, keys: ref __self_1_1 } =>
                        match *self {
                            Subscription {
                            endpoint: ref __self_0_0, keys: ref __self_0_1 }
                            =>
                            (*__self_0_0) == (*__self_1_0) &&
                                (*__self_0_1) == (*__self_1_1),
                        },
                    }
                }
                #[inline]
                fn ne(&self, other: &Subscription) -> bool {
                    match *other {
                        Subscription {
                        endpoint: ref __self_1_0, keys: ref __self_1_1 } =>
                        match *self {
                            Subscription {
                            endpoint: ref __self_0_0, keys: ref __self_0_1 }
                            =>
                            (*__self_0_0) != (*__self_1_0) ||
                                (*__self_0_1) != (*__self_1_1),
                        },
                    }
                }
            }
            #[doc(hidden)]
            #[allow(non_upper_case_globals, unused_attributes,
                    unused_qualifications)]
            const _IMPL_SERIALIZE_FOR_Subscription: () =
                {
                    #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                    extern crate serde as _serde;
                    #[allow(unused_macros)]
                    macro_rules! try {
                        ($ __expr : expr) =>
                        {
                            match $ __expr
                            {
                                _serde :: export :: Ok(__val) => __val, _serde
                                :: export :: Err(__err) =>
                                { return _serde :: export :: Err(__err) ; }
                            }
                        }
                    }
                    #[automatically_derived]
                    impl _serde::Serialize for Subscription {
                        fn serialize<__S>(&self, __serializer: __S)
                         -> _serde::export::Result<__S::Ok, __S::Error> where
                         __S: _serde::Serializer {
                            let mut __serde_state =
                                match _serde::Serializer::serialize_struct(__serializer,
                                                                           "Subscription",
                                                                           false
                                                                               as
                                                                               usize
                                                                               +
                                                                               1
                                                                               +
                                                                               1)
                                    {
                                    _serde::export::Ok(__val) => __val,
                                    _serde::export::Err(__err) => {
                                        return _serde::export::Err(__err);
                                    }
                                };
                            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                "endpoint",
                                                                                &self.endpoint)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                "keys",
                                                                                &self.keys)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                            _serde::ser::SerializeStruct::end(__serde_state)
                        }
                    }
                };
            #[automatically_derived]
            #[allow(unused_qualifications)]
            impl ::core::default::Default for Subscription {
                #[inline]
                fn default() -> Subscription {
                    Subscription{endpoint:
                                     ::core::default::Default::default(),
                                 keys: ::core::default::Default::default(),}
                }
            }
            pub(crate) struct Keys {
                pub(crate) p256dh: String,
                pub(crate) auth: String,
            }
            #[automatically_derived]
            #[allow(unused_qualifications)]
            impl ::core::fmt::Debug for Keys {
                fn fmt(&self, f: &mut ::core::fmt::Formatter)
                 -> ::core::fmt::Result {
                    match *self {
                        Keys { p256dh: ref __self_0_0, auth: ref __self_0_1 }
                        => {
                            let mut debug_trait_builder =
                                f.debug_struct("Keys");
                            let _ =
                                debug_trait_builder.field("p256dh",
                                                          &&(*__self_0_0));
                            let _ =
                                debug_trait_builder.field("auth",
                                                          &&(*__self_0_1));
                            debug_trait_builder.finish()
                        }
                    }
                }
            }
            #[automatically_derived]
            #[allow(unused_qualifications)]
            impl ::core::clone::Clone for Keys {
                #[inline]
                fn clone(&self) -> Keys {
                    match *self {
                        Keys { p256dh: ref __self_0_0, auth: ref __self_0_1 }
                        =>
                        Keys{p256dh:
                                 ::core::clone::Clone::clone(&(*__self_0_0)),
                             auth:
                                 ::core::clone::Clone::clone(&(*__self_0_1)),},
                    }
                }
            }
            impl ::core::marker::StructuralPartialEq for Keys { }
            #[automatically_derived]
            #[allow(unused_qualifications)]
            impl ::core::cmp::PartialEq for Keys {
                #[inline]
                fn eq(&self, other: &Keys) -> bool {
                    match *other {
                        Keys { p256dh: ref __self_1_0, auth: ref __self_1_1 }
                        =>
                        match *self {
                            Keys {
                            p256dh: ref __self_0_0, auth: ref __self_0_1 } =>
                            (*__self_0_0) == (*__self_1_0) &&
                                (*__self_0_1) == (*__self_1_1),
                        },
                    }
                }
                #[inline]
                fn ne(&self, other: &Keys) -> bool {
                    match *other {
                        Keys { p256dh: ref __self_1_0, auth: ref __self_1_1 }
                        =>
                        match *self {
                            Keys {
                            p256dh: ref __self_0_0, auth: ref __self_0_1 } =>
                            (*__self_0_0) != (*__self_1_0) ||
                                (*__self_0_1) != (*__self_1_1),
                        },
                    }
                }
            }
            #[doc(hidden)]
            #[allow(non_upper_case_globals, unused_attributes,
                    unused_qualifications)]
            const _IMPL_SERIALIZE_FOR_Keys: () =
                {
                    #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                    extern crate serde as _serde;
                    #[allow(unused_macros)]
                    macro_rules! try {
                        ($ __expr : expr) =>
                        {
                            match $ __expr
                            {
                                _serde :: export :: Ok(__val) => __val, _serde
                                :: export :: Err(__err) =>
                                { return _serde :: export :: Err(__err) ; }
                            }
                        }
                    }
                    #[automatically_derived]
                    impl _serde::Serialize for Keys {
                        fn serialize<__S>(&self, __serializer: __S)
                         -> _serde::export::Result<__S::Ok, __S::Error> where
                         __S: _serde::Serializer {
                            let mut __serde_state =
                                match _serde::Serializer::serialize_struct(__serializer,
                                                                           "Keys",
                                                                           false
                                                                               as
                                                                               usize
                                                                               +
                                                                               1
                                                                               +
                                                                               1)
                                    {
                                    _serde::export::Ok(__val) => __val,
                                    _serde::export::Err(__err) => {
                                        return _serde::export::Err(__err);
                                    }
                                };
                            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                "p256dh",
                                                                                &self.p256dh)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                "auth",
                                                                                &self.auth)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                            _serde::ser::SerializeStruct::end(__serde_state)
                        }
                    }
                };
            #[automatically_derived]
            #[allow(unused_qualifications)]
            impl ::core::default::Default for Keys {
                #[inline]
                fn default() -> Keys {
                    Keys{p256dh: ::core::default::Default::default(),
                         auth: ::core::default::Default::default(),}
                }
            }
            pub(crate) struct Data {
                pub(crate) alerts: Option<Alerts>,
            }
            #[automatically_derived]
            #[allow(unused_qualifications)]
            impl ::core::fmt::Debug for Data {
                fn fmt(&self, f: &mut ::core::fmt::Formatter)
                 -> ::core::fmt::Result {
                    match *self {
                        Data { alerts: ref __self_0_0 } => {
                            let mut debug_trait_builder =
                                f.debug_struct("Data");
                            let _ =
                                debug_trait_builder.field("alerts",
                                                          &&(*__self_0_0));
                            debug_trait_builder.finish()
                        }
                    }
                }
            }
            #[automatically_derived]
            #[allow(unused_qualifications)]
            impl ::core::clone::Clone for Data {
                #[inline]
                fn clone(&self) -> Data {
                    match *self {
                        Data { alerts: ref __self_0_0 } =>
                        Data{alerts:
                                 ::core::clone::Clone::clone(&(*__self_0_0)),},
                    }
                }
            }
            impl ::core::marker::StructuralPartialEq for Data { }
            #[automatically_derived]
            #[allow(unused_qualifications)]
            impl ::core::cmp::PartialEq for Data {
                #[inline]
                fn eq(&self, other: &Data) -> bool {
                    match *other {
                        Data { alerts: ref __self_1_0 } =>
                        match *self {
                            Data { alerts: ref __self_0_0 } =>
                            (*__self_0_0) == (*__self_1_0),
                        },
                    }
                }
                #[inline]
                fn ne(&self, other: &Data) -> bool {
                    match *other {
                        Data { alerts: ref __self_1_0 } =>
                        match *self {
                            Data { alerts: ref __self_0_0 } =>
                            (*__self_0_0) != (*__self_1_0),
                        },
                    }
                }
            }
            #[doc(hidden)]
            #[allow(non_upper_case_globals, unused_attributes,
                    unused_qualifications)]
            const _IMPL_SERIALIZE_FOR_Data: () =
                {
                    #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                    extern crate serde as _serde;
                    #[allow(unused_macros)]
                    macro_rules! try {
                        ($ __expr : expr) =>
                        {
                            match $ __expr
                            {
                                _serde :: export :: Ok(__val) => __val, _serde
                                :: export :: Err(__err) =>
                                { return _serde :: export :: Err(__err) ; }
                            }
                        }
                    }
                    #[automatically_derived]
                    impl _serde::Serialize for Data {
                        fn serialize<__S>(&self, __serializer: __S)
                         -> _serde::export::Result<__S::Ok, __S::Error> where
                         __S: _serde::Serializer {
                            let mut __serde_state =
                                match _serde::Serializer::serialize_struct(__serializer,
                                                                           "Data",
                                                                           false
                                                                               as
                                                                               usize
                                                                               +
                                                                               1)
                                    {
                                    _serde::export::Ok(__val) => __val,
                                    _serde::export::Err(__err) => {
                                        return _serde::export::Err(__err);
                                    }
                                };
                            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                "alerts",
                                                                                &self.alerts)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                            _serde::ser::SerializeStruct::end(__serde_state)
                        }
                    }
                };
            #[automatically_derived]
            #[allow(unused_qualifications)]
            impl ::core::default::Default for Data {
                #[inline]
                fn default() -> Data {
                    Data{alerts: ::core::default::Default::default(),}
                }
            }
        }
        pub(crate) mod update_data {
            use super::Alerts;
            pub(crate) struct Data {
                pub(crate) alerts: Option<Alerts>,
            }
            #[automatically_derived]
            #[allow(unused_qualifications)]
            impl ::core::fmt::Debug for Data {
                fn fmt(&self, f: &mut ::core::fmt::Formatter)
                 -> ::core::fmt::Result {
                    match *self {
                        Data { alerts: ref __self_0_0 } => {
                            let mut debug_trait_builder =
                                f.debug_struct("Data");
                            let _ =
                                debug_trait_builder.field("alerts",
                                                          &&(*__self_0_0));
                            debug_trait_builder.finish()
                        }
                    }
                }
            }
            #[automatically_derived]
            #[allow(unused_qualifications)]
            impl ::core::clone::Clone for Data {
                #[inline]
                fn clone(&self) -> Data {
                    match *self {
                        Data { alerts: ref __self_0_0 } =>
                        Data{alerts:
                                 ::core::clone::Clone::clone(&(*__self_0_0)),},
                    }
                }
            }
            impl ::core::marker::StructuralPartialEq for Data { }
            #[automatically_derived]
            #[allow(unused_qualifications)]
            impl ::core::cmp::PartialEq for Data {
                #[inline]
                fn eq(&self, other: &Data) -> bool {
                    match *other {
                        Data { alerts: ref __self_1_0 } =>
                        match *self {
                            Data { alerts: ref __self_0_0 } =>
                            (*__self_0_0) == (*__self_1_0),
                        },
                    }
                }
                #[inline]
                fn ne(&self, other: &Data) -> bool {
                    match *other {
                        Data { alerts: ref __self_1_0 } =>
                        match *self {
                            Data { alerts: ref __self_0_0 } =>
                            (*__self_0_0) != (*__self_1_0),
                        },
                    }
                }
            }
            #[doc(hidden)]
            #[allow(non_upper_case_globals, unused_attributes,
                    unused_qualifications)]
            const _IMPL_SERIALIZE_FOR_Data: () =
                {
                    #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                    extern crate serde as _serde;
                    #[allow(unused_macros)]
                    macro_rules! try {
                        ($ __expr : expr) =>
                        {
                            match $ __expr
                            {
                                _serde :: export :: Ok(__val) => __val, _serde
                                :: export :: Err(__err) =>
                                { return _serde :: export :: Err(__err) ; }
                            }
                        }
                    }
                    #[automatically_derived]
                    impl _serde::Serialize for Data {
                        fn serialize<__S>(&self, __serializer: __S)
                         -> _serde::export::Result<__S::Ok, __S::Error> where
                         __S: _serde::Serializer {
                            let mut __serde_state =
                                match _serde::Serializer::serialize_struct(__serializer,
                                                                           "Data",
                                                                           false
                                                                               as
                                                                               usize
                                                                               +
                                                                               1)
                                    {
                                    _serde::export::Ok(__val) => __val,
                                    _serde::export::Err(__err) => {
                                        return _serde::export::Err(__err);
                                    }
                                };
                            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                "alerts",
                                                                                &self.alerts)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                            _serde::ser::SerializeStruct::end(__serde_state)
                        }
                    }
                };
            #[automatically_derived]
            #[allow(unused_qualifications)]
            impl ::core::default::Default for Data {
                #[inline]
                fn default() -> Data {
                    Data{alerts: ::core::default::Default::default(),}
                }
            }
            pub(crate) struct Form {
                pub(crate) id: String,
                pub(crate) data: Data,
            }
            #[automatically_derived]
            #[allow(unused_qualifications)]
            impl ::core::fmt::Debug for Form {
                fn fmt(&self, f: &mut ::core::fmt::Formatter)
                 -> ::core::fmt::Result {
                    match *self {
                        Form { id: ref __self_0_0, data: ref __self_0_1 } => {
                            let mut debug_trait_builder =
                                f.debug_struct("Form");
                            let _ =
                                debug_trait_builder.field("id",
                                                          &&(*__self_0_0));
                            let _ =
                                debug_trait_builder.field("data",
                                                          &&(*__self_0_1));
                            debug_trait_builder.finish()
                        }
                    }
                }
            }
            #[automatically_derived]
            #[allow(unused_qualifications)]
            impl ::core::clone::Clone for Form {
                #[inline]
                fn clone(&self) -> Form {
                    match *self {
                        Form { id: ref __self_0_0, data: ref __self_0_1 } =>
                        Form{id: ::core::clone::Clone::clone(&(*__self_0_0)),
                             data:
                                 ::core::clone::Clone::clone(&(*__self_0_1)),},
                    }
                }
            }
            impl ::core::marker::StructuralPartialEq for Form { }
            #[automatically_derived]
            #[allow(unused_qualifications)]
            impl ::core::cmp::PartialEq for Form {
                #[inline]
                fn eq(&self, other: &Form) -> bool {
                    match *other {
                        Form { id: ref __self_1_0, data: ref __self_1_1 } =>
                        match *self {
                            Form { id: ref __self_0_0, data: ref __self_0_1 }
                            =>
                            (*__self_0_0) == (*__self_1_0) &&
                                (*__self_0_1) == (*__self_1_1),
                        },
                    }
                }
                #[inline]
                fn ne(&self, other: &Form) -> bool {
                    match *other {
                        Form { id: ref __self_1_0, data: ref __self_1_1 } =>
                        match *self {
                            Form { id: ref __self_0_0, data: ref __self_0_1 }
                            =>
                            (*__self_0_0) != (*__self_1_0) ||
                                (*__self_0_1) != (*__self_1_1),
                        },
                    }
                }
            }
            #[doc(hidden)]
            #[allow(non_upper_case_globals, unused_attributes,
                    unused_qualifications)]
            const _IMPL_SERIALIZE_FOR_Form: () =
                {
                    #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                    extern crate serde as _serde;
                    #[allow(unused_macros)]
                    macro_rules! try {
                        ($ __expr : expr) =>
                        {
                            match $ __expr
                            {
                                _serde :: export :: Ok(__val) => __val, _serde
                                :: export :: Err(__err) =>
                                { return _serde :: export :: Err(__err) ; }
                            }
                        }
                    }
                    #[automatically_derived]
                    impl _serde::Serialize for Form {
                        fn serialize<__S>(&self, __serializer: __S)
                         -> _serde::export::Result<__S::Ok, __S::Error> where
                         __S: _serde::Serializer {
                            let mut __serde_state =
                                match _serde::Serializer::serialize_struct(__serializer,
                                                                           "Form",
                                                                           false
                                                                               as
                                                                               usize
                                                                               +
                                                                               1
                                                                               +
                                                                               1)
                                    {
                                    _serde::export::Ok(__val) => __val,
                                    _serde::export::Err(__err) => {
                                        return _serde::export::Err(__err);
                                    }
                                };
                            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                "id",
                                                                                &self.id)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                "data",
                                                                                &self.data)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                            _serde::ser::SerializeStruct::end(__serde_state)
                        }
                    }
                };
            #[automatically_derived]
            #[allow(unused_qualifications)]
            impl ::core::default::Default for Form {
                #[inline]
                fn default() -> Form {
                    Form{id: ::core::default::Default::default(),
                         data: ::core::default::Default::default(),}
                }
            }
        }
    }
    /// Data structures for ser/de of relationship-related resources
    pub mod relationship {
        //! module containing everything relating to a relationship with
        //! another account.
        /// A struct containing information about a relationship with another account.
        pub struct Relationship {
            /// Target account id
            pub id: String,
            /// Whether the application client follows the account.
            pub following: bool,
            /// Whether the account follows the application client.
            pub followed_by: bool,
            /// Whether the application client blocks the account.
            pub blocking: bool,
            /// Whether the application client blocks the account.
            pub muting: bool,
            /// Whether the application client has requested to follow the account.
            pub requested: bool,
            /// Whether the user is also muting notifications
            pub muting_notifications: bool,
            /// Whether the user is currently blocking the accounts's domain
            pub domain_blocking: bool,
            /// Whether the user's reblogs will show up in the home timeline
            pub showing_reblogs: bool,
            /// Whether the user is currently endorsing the account
            ///
            /// This field is not techincally nullable with mastodon >= 2.5.0, but
            /// making it `Option<bool>` here means we shouldn't get deser errors when
            /// making calls to pleroma or mastodon<2.5.0 instances
            pub endorsed: Option<bool>,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for Relationship {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    Relationship {
                    id: ref __self_0_0,
                    following: ref __self_0_1,
                    followed_by: ref __self_0_2,
                    blocking: ref __self_0_3,
                    muting: ref __self_0_4,
                    requested: ref __self_0_5,
                    muting_notifications: ref __self_0_6,
                    domain_blocking: ref __self_0_7,
                    showing_reblogs: ref __self_0_8,
                    endorsed: ref __self_0_9 } => {
                        let mut debug_trait_builder =
                            f.debug_struct("Relationship");
                        let _ =
                            debug_trait_builder.field("id", &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("following",
                                                      &&(*__self_0_1));
                        let _ =
                            debug_trait_builder.field("followed_by",
                                                      &&(*__self_0_2));
                        let _ =
                            debug_trait_builder.field("blocking",
                                                      &&(*__self_0_3));
                        let _ =
                            debug_trait_builder.field("muting",
                                                      &&(*__self_0_4));
                        let _ =
                            debug_trait_builder.field("requested",
                                                      &&(*__self_0_5));
                        let _ =
                            debug_trait_builder.field("muting_notifications",
                                                      &&(*__self_0_6));
                        let _ =
                            debug_trait_builder.field("domain_blocking",
                                                      &&(*__self_0_7));
                        let _ =
                            debug_trait_builder.field("showing_reblogs",
                                                      &&(*__self_0_8));
                        let _ =
                            debug_trait_builder.field("endorsed",
                                                      &&(*__self_0_9));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for Relationship {
            #[inline]
            fn clone(&self) -> Relationship {
                match *self {
                    Relationship {
                    id: ref __self_0_0,
                    following: ref __self_0_1,
                    followed_by: ref __self_0_2,
                    blocking: ref __self_0_3,
                    muting: ref __self_0_4,
                    requested: ref __self_0_5,
                    muting_notifications: ref __self_0_6,
                    domain_blocking: ref __self_0_7,
                    showing_reblogs: ref __self_0_8,
                    endorsed: ref __self_0_9 } =>
                    Relationship{id:
                                     ::core::clone::Clone::clone(&(*__self_0_0)),
                                 following:
                                     ::core::clone::Clone::clone(&(*__self_0_1)),
                                 followed_by:
                                     ::core::clone::Clone::clone(&(*__self_0_2)),
                                 blocking:
                                     ::core::clone::Clone::clone(&(*__self_0_3)),
                                 muting:
                                     ::core::clone::Clone::clone(&(*__self_0_4)),
                                 requested:
                                     ::core::clone::Clone::clone(&(*__self_0_5)),
                                 muting_notifications:
                                     ::core::clone::Clone::clone(&(*__self_0_6)),
                                 domain_blocking:
                                     ::core::clone::Clone::clone(&(*__self_0_7)),
                                 showing_reblogs:
                                     ::core::clone::Clone::clone(&(*__self_0_8)),
                                 endorsed:
                                     ::core::clone::Clone::clone(&(*__self_0_9)),},
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_Relationship: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'de> _serde::Deserialize<'de> for Relationship {
                    fn deserialize<__D>(__deserializer: __D)
                     -> _serde::export::Result<Self, __D::Error> where
                     __D: _serde::Deserializer<'de> {
                        #[allow(non_camel_case_types)]
                        enum __Field {
                            __field0,
                            __field1,
                            __field2,
                            __field3,
                            __field4,
                            __field5,
                            __field6,
                            __field7,
                            __field8,
                            __field9,
                            __ignore,
                        }
                        struct __FieldVisitor;
                        impl <'de> _serde::de::Visitor<'de> for __FieldVisitor
                         {
                            type Value = __Field;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "field identifier")
                            }
                            fn visit_u64<__E>(self, __value: u64)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    0u64 =>
                                    _serde::export::Ok(__Field::__field0),
                                    1u64 =>
                                    _serde::export::Ok(__Field::__field1),
                                    2u64 =>
                                    _serde::export::Ok(__Field::__field2),
                                    3u64 =>
                                    _serde::export::Ok(__Field::__field3),
                                    4u64 =>
                                    _serde::export::Ok(__Field::__field4),
                                    5u64 =>
                                    _serde::export::Ok(__Field::__field5),
                                    6u64 =>
                                    _serde::export::Ok(__Field::__field6),
                                    7u64 =>
                                    _serde::export::Ok(__Field::__field7),
                                    8u64 =>
                                    _serde::export::Ok(__Field::__field8),
                                    9u64 =>
                                    _serde::export::Ok(__Field::__field9),
                                    _ =>
                                    _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                         &"field index 0 <= i < 10")),
                                }
                            }
                            fn visit_str<__E>(self, __value: &str)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    "id" =>
                                    _serde::export::Ok(__Field::__field0),
                                    "following" =>
                                    _serde::export::Ok(__Field::__field1),
                                    "followed_by" =>
                                    _serde::export::Ok(__Field::__field2),
                                    "blocking" =>
                                    _serde::export::Ok(__Field::__field3),
                                    "muting" =>
                                    _serde::export::Ok(__Field::__field4),
                                    "requested" =>
                                    _serde::export::Ok(__Field::__field5),
                                    "muting_notifications" =>
                                    _serde::export::Ok(__Field::__field6),
                                    "domain_blocking" =>
                                    _serde::export::Ok(__Field::__field7),
                                    "showing_reblogs" =>
                                    _serde::export::Ok(__Field::__field8),
                                    "endorsed" =>
                                    _serde::export::Ok(__Field::__field9),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                            fn visit_bytes<__E>(self, __value: &[u8])
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    b"id" =>
                                    _serde::export::Ok(__Field::__field0),
                                    b"following" =>
                                    _serde::export::Ok(__Field::__field1),
                                    b"followed_by" =>
                                    _serde::export::Ok(__Field::__field2),
                                    b"blocking" =>
                                    _serde::export::Ok(__Field::__field3),
                                    b"muting" =>
                                    _serde::export::Ok(__Field::__field4),
                                    b"requested" =>
                                    _serde::export::Ok(__Field::__field5),
                                    b"muting_notifications" =>
                                    _serde::export::Ok(__Field::__field6),
                                    b"domain_blocking" =>
                                    _serde::export::Ok(__Field::__field7),
                                    b"showing_reblogs" =>
                                    _serde::export::Ok(__Field::__field8),
                                    b"endorsed" =>
                                    _serde::export::Ok(__Field::__field9),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                        }
                        impl <'de> _serde::Deserialize<'de> for __Field {
                            #[inline]
                            fn deserialize<__D>(__deserializer: __D)
                             -> _serde::export::Result<Self, __D::Error> where
                             __D: _serde::Deserializer<'de> {
                                _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                             __FieldVisitor)
                            }
                        }
                        struct __Visitor<'de> {
                            marker: _serde::export::PhantomData<Relationship>,
                            lifetime: _serde::export::PhantomData<&'de ()>,
                        }
                        impl <'de> _serde::de::Visitor<'de> for __Visitor<'de>
                         {
                            type Value = Relationship;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "struct Relationship")
                            }
                            #[inline]
                            fn visit_seq<__A>(self, mut __seq: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::SeqAccess<'de> {
                                let __field0 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                         &"struct Relationship with 10 elements"));
                                        }
                                    };
                                let __field1 =
                                    match match _serde::de::SeqAccess::next_element::<bool>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(1usize,
                                                                                                         &"struct Relationship with 10 elements"));
                                        }
                                    };
                                let __field2 =
                                    match match _serde::de::SeqAccess::next_element::<bool>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(2usize,
                                                                                                         &"struct Relationship with 10 elements"));
                                        }
                                    };
                                let __field3 =
                                    match match _serde::de::SeqAccess::next_element::<bool>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(3usize,
                                                                                                         &"struct Relationship with 10 elements"));
                                        }
                                    };
                                let __field4 =
                                    match match _serde::de::SeqAccess::next_element::<bool>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(4usize,
                                                                                                         &"struct Relationship with 10 elements"));
                                        }
                                    };
                                let __field5 =
                                    match match _serde::de::SeqAccess::next_element::<bool>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(5usize,
                                                                                                         &"struct Relationship with 10 elements"));
                                        }
                                    };
                                let __field6 =
                                    match match _serde::de::SeqAccess::next_element::<bool>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(6usize,
                                                                                                         &"struct Relationship with 10 elements"));
                                        }
                                    };
                                let __field7 =
                                    match match _serde::de::SeqAccess::next_element::<bool>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(7usize,
                                                                                                         &"struct Relationship with 10 elements"));
                                        }
                                    };
                                let __field8 =
                                    match match _serde::de::SeqAccess::next_element::<bool>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(8usize,
                                                                                                         &"struct Relationship with 10 elements"));
                                        }
                                    };
                                let __field9 =
                                    match match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(9usize,
                                                                                                         &"struct Relationship with 10 elements"));
                                        }
                                    };
                                _serde::export::Ok(Relationship{id: __field0,
                                                                following:
                                                                    __field1,
                                                                followed_by:
                                                                    __field2,
                                                                blocking:
                                                                    __field3,
                                                                muting:
                                                                    __field4,
                                                                requested:
                                                                    __field5,
                                                                muting_notifications:
                                                                    __field6,
                                                                domain_blocking:
                                                                    __field7,
                                                                showing_reblogs:
                                                                    __field8,
                                                                endorsed:
                                                                    __field9,})
                            }
                            #[inline]
                            fn visit_map<__A>(self, mut __map: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::MapAccess<'de> {
                                let mut __field0:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field1:
                                        _serde::export::Option<bool> =
                                    _serde::export::None;
                                let mut __field2:
                                        _serde::export::Option<bool> =
                                    _serde::export::None;
                                let mut __field3:
                                        _serde::export::Option<bool> =
                                    _serde::export::None;
                                let mut __field4:
                                        _serde::export::Option<bool> =
                                    _serde::export::None;
                                let mut __field5:
                                        _serde::export::Option<bool> =
                                    _serde::export::None;
                                let mut __field6:
                                        _serde::export::Option<bool> =
                                    _serde::export::None;
                                let mut __field7:
                                        _serde::export::Option<bool> =
                                    _serde::export::None;
                                let mut __field8:
                                        _serde::export::Option<bool> =
                                    _serde::export::None;
                                let mut __field9:
                                        _serde::export::Option<Option<bool>> =
                                    _serde::export::None;
                                while let _serde::export::Some(__key) =
                                          match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                    match __key {
                                        __Field::__field0 => {
                                            if _serde::export::Option::is_some(&__field0)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("id"));
                                            }
                                            __field0 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field1 => {
                                            if _serde::export::Option::is_some(&__field1)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("following"));
                                            }
                                            __field1 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<bool>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field2 => {
                                            if _serde::export::Option::is_some(&__field2)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("followed_by"));
                                            }
                                            __field2 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<bool>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field3 => {
                                            if _serde::export::Option::is_some(&__field3)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("blocking"));
                                            }
                                            __field3 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<bool>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field4 => {
                                            if _serde::export::Option::is_some(&__field4)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("muting"));
                                            }
                                            __field4 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<bool>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field5 => {
                                            if _serde::export::Option::is_some(&__field5)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("requested"));
                                            }
                                            __field5 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<bool>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field6 => {
                                            if _serde::export::Option::is_some(&__field6)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("muting_notifications"));
                                            }
                                            __field6 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<bool>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field7 => {
                                            if _serde::export::Option::is_some(&__field7)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("domain_blocking"));
                                            }
                                            __field7 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<bool>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field8 => {
                                            if _serde::export::Option::is_some(&__field8)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("showing_reblogs"));
                                            }
                                            __field8 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<bool>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field9 => {
                                            if _serde::export::Option::is_some(&__field9)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("endorsed"));
                                            }
                                            __field9 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        _ => {
                                            let _ =
                                                match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                    {
                                                    _serde::export::Ok(__val)
                                                    => __val,
                                                    _serde::export::Err(__err)
                                                    => {
                                                        return _serde::export::Err(__err);
                                                    }
                                                };
                                        }
                                    }
                                }
                                let __field0 =
                                    match __field0 {
                                        _serde::export::Some(__field0) =>
                                        __field0,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("id")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field1 =
                                    match __field1 {
                                        _serde::export::Some(__field1) =>
                                        __field1,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("following")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field2 =
                                    match __field2 {
                                        _serde::export::Some(__field2) =>
                                        __field2,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("followed_by")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field3 =
                                    match __field3 {
                                        _serde::export::Some(__field3) =>
                                        __field3,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("blocking")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field4 =
                                    match __field4 {
                                        _serde::export::Some(__field4) =>
                                        __field4,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("muting")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field5 =
                                    match __field5 {
                                        _serde::export::Some(__field5) =>
                                        __field5,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("requested")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field6 =
                                    match __field6 {
                                        _serde::export::Some(__field6) =>
                                        __field6,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("muting_notifications")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field7 =
                                    match __field7 {
                                        _serde::export::Some(__field7) =>
                                        __field7,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("domain_blocking")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field8 =
                                    match __field8 {
                                        _serde::export::Some(__field8) =>
                                        __field8,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("showing_reblogs")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field9 =
                                    match __field9 {
                                        _serde::export::Some(__field9) =>
                                        __field9,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("endorsed")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                _serde::export::Ok(Relationship{id: __field0,
                                                                following:
                                                                    __field1,
                                                                followed_by:
                                                                    __field2,
                                                                blocking:
                                                                    __field3,
                                                                muting:
                                                                    __field4,
                                                                requested:
                                                                    __field5,
                                                                muting_notifications:
                                                                    __field6,
                                                                domain_blocking:
                                                                    __field7,
                                                                showing_reblogs:
                                                                    __field8,
                                                                endorsed:
                                                                    __field9,})
                            }
                        }
                        const FIELDS: &'static [&'static str] =
                            &["id", "following", "followed_by", "blocking",
                              "muting", "requested", "muting_notifications",
                              "domain_blocking", "showing_reblogs",
                              "endorsed"];
                        _serde::Deserializer::deserialize_struct(__deserializer,
                                                                 "Relationship",
                                                                 FIELDS,
                                                                 __Visitor{marker:
                                                                               _serde::export::PhantomData::<Relationship>,
                                                                           lifetime:
                                                                               _serde::export::PhantomData,})
                    }
                }
            };
        impl ::core::marker::StructuralPartialEq for Relationship { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for Relationship {
            #[inline]
            fn eq(&self, other: &Relationship) -> bool {
                match *other {
                    Relationship {
                    id: ref __self_1_0,
                    following: ref __self_1_1,
                    followed_by: ref __self_1_2,
                    blocking: ref __self_1_3,
                    muting: ref __self_1_4,
                    requested: ref __self_1_5,
                    muting_notifications: ref __self_1_6,
                    domain_blocking: ref __self_1_7,
                    showing_reblogs: ref __self_1_8,
                    endorsed: ref __self_1_9 } =>
                    match *self {
                        Relationship {
                        id: ref __self_0_0,
                        following: ref __self_0_1,
                        followed_by: ref __self_0_2,
                        blocking: ref __self_0_3,
                        muting: ref __self_0_4,
                        requested: ref __self_0_5,
                        muting_notifications: ref __self_0_6,
                        domain_blocking: ref __self_0_7,
                        showing_reblogs: ref __self_0_8,
                        endorsed: ref __self_0_9 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1) &&
                            (*__self_0_2) == (*__self_1_2) &&
                            (*__self_0_3) == (*__self_1_3) &&
                            (*__self_0_4) == (*__self_1_4) &&
                            (*__self_0_5) == (*__self_1_5) &&
                            (*__self_0_6) == (*__self_1_6) &&
                            (*__self_0_7) == (*__self_1_7) &&
                            (*__self_0_8) == (*__self_1_8) &&
                            (*__self_0_9) == (*__self_1_9),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &Relationship) -> bool {
                match *other {
                    Relationship {
                    id: ref __self_1_0,
                    following: ref __self_1_1,
                    followed_by: ref __self_1_2,
                    blocking: ref __self_1_3,
                    muting: ref __self_1_4,
                    requested: ref __self_1_5,
                    muting_notifications: ref __self_1_6,
                    domain_blocking: ref __self_1_7,
                    showing_reblogs: ref __self_1_8,
                    endorsed: ref __self_1_9 } =>
                    match *self {
                        Relationship {
                        id: ref __self_0_0,
                        following: ref __self_0_1,
                        followed_by: ref __self_0_2,
                        blocking: ref __self_0_3,
                        muting: ref __self_0_4,
                        requested: ref __self_0_5,
                        muting_notifications: ref __self_0_6,
                        domain_blocking: ref __self_0_7,
                        showing_reblogs: ref __self_0_8,
                        endorsed: ref __self_0_9 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1) ||
                            (*__self_0_2) != (*__self_1_2) ||
                            (*__self_0_3) != (*__self_1_3) ||
                            (*__self_0_4) != (*__self_1_4) ||
                            (*__self_0_5) != (*__self_1_5) ||
                            (*__self_0_6) != (*__self_1_6) ||
                            (*__self_0_7) != (*__self_1_7) ||
                            (*__self_0_8) != (*__self_1_8) ||
                            (*__self_0_9) != (*__self_1_9),
                    },
                }
            }
        }
    }
    /// Data structures for ser/de of report-related resources
    pub mod report {
        //! module containing information about a finished report of a user.
        /// A struct containing info about a report.
        pub struct Report {
            /// The ID of the report.
            pub id: String,
            /// The action taken in response to the report.
            pub action_taken: String,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for Report {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    Report { id: ref __self_0_0, action_taken: ref __self_0_1
                    } => {
                        let mut debug_trait_builder =
                            f.debug_struct("Report");
                        let _ =
                            debug_trait_builder.field("id", &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("action_taken",
                                                      &&(*__self_0_1));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for Report {
            #[inline]
            fn clone(&self) -> Report {
                match *self {
                    Report { id: ref __self_0_0, action_taken: ref __self_0_1
                    } =>
                    Report{id: ::core::clone::Clone::clone(&(*__self_0_0)),
                           action_taken:
                               ::core::clone::Clone::clone(&(*__self_0_1)),},
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_Report: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'de> _serde::Deserialize<'de> for Report {
                    fn deserialize<__D>(__deserializer: __D)
                     -> _serde::export::Result<Self, __D::Error> where
                     __D: _serde::Deserializer<'de> {
                        #[allow(non_camel_case_types)]
                        enum __Field { __field0, __field1, __ignore, }
                        struct __FieldVisitor;
                        impl <'de> _serde::de::Visitor<'de> for __FieldVisitor
                         {
                            type Value = __Field;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "field identifier")
                            }
                            fn visit_u64<__E>(self, __value: u64)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    0u64 =>
                                    _serde::export::Ok(__Field::__field0),
                                    1u64 =>
                                    _serde::export::Ok(__Field::__field1),
                                    _ =>
                                    _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                         &"field index 0 <= i < 2")),
                                }
                            }
                            fn visit_str<__E>(self, __value: &str)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    "id" =>
                                    _serde::export::Ok(__Field::__field0),
                                    "action_taken" =>
                                    _serde::export::Ok(__Field::__field1),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                            fn visit_bytes<__E>(self, __value: &[u8])
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    b"id" =>
                                    _serde::export::Ok(__Field::__field0),
                                    b"action_taken" =>
                                    _serde::export::Ok(__Field::__field1),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                        }
                        impl <'de> _serde::Deserialize<'de> for __Field {
                            #[inline]
                            fn deserialize<__D>(__deserializer: __D)
                             -> _serde::export::Result<Self, __D::Error> where
                             __D: _serde::Deserializer<'de> {
                                _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                             __FieldVisitor)
                            }
                        }
                        struct __Visitor<'de> {
                            marker: _serde::export::PhantomData<Report>,
                            lifetime: _serde::export::PhantomData<&'de ()>,
                        }
                        impl <'de> _serde::de::Visitor<'de> for __Visitor<'de>
                         {
                            type Value = Report;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "struct Report")
                            }
                            #[inline]
                            fn visit_seq<__A>(self, mut __seq: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::SeqAccess<'de> {
                                let __field0 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                         &"struct Report with 2 elements"));
                                        }
                                    };
                                let __field1 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(1usize,
                                                                                                         &"struct Report with 2 elements"));
                                        }
                                    };
                                _serde::export::Ok(Report{id: __field0,
                                                          action_taken:
                                                              __field1,})
                            }
                            #[inline]
                            fn visit_map<__A>(self, mut __map: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::MapAccess<'de> {
                                let mut __field0:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field1:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                while let _serde::export::Some(__key) =
                                          match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                    match __key {
                                        __Field::__field0 => {
                                            if _serde::export::Option::is_some(&__field0)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("id"));
                                            }
                                            __field0 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field1 => {
                                            if _serde::export::Option::is_some(&__field1)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("action_taken"));
                                            }
                                            __field1 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        _ => {
                                            let _ =
                                                match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                    {
                                                    _serde::export::Ok(__val)
                                                    => __val,
                                                    _serde::export::Err(__err)
                                                    => {
                                                        return _serde::export::Err(__err);
                                                    }
                                                };
                                        }
                                    }
                                }
                                let __field0 =
                                    match __field0 {
                                        _serde::export::Some(__field0) =>
                                        __field0,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("id")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field1 =
                                    match __field1 {
                                        _serde::export::Some(__field1) =>
                                        __field1,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("action_taken")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                _serde::export::Ok(Report{id: __field0,
                                                          action_taken:
                                                              __field1,})
                            }
                        }
                        const FIELDS: &'static [&'static str] =
                            &["id", "action_taken"];
                        _serde::Deserializer::deserialize_struct(__deserializer,
                                                                 "Report",
                                                                 FIELDS,
                                                                 __Visitor{marker:
                                                                               _serde::export::PhantomData::<Report>,
                                                                           lifetime:
                                                                               _serde::export::PhantomData,})
                    }
                }
            };
        impl ::core::marker::StructuralPartialEq for Report { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for Report {
            #[inline]
            fn eq(&self, other: &Report) -> bool {
                match *other {
                    Report { id: ref __self_1_0, action_taken: ref __self_1_1
                    } =>
                    match *self {
                        Report {
                        id: ref __self_0_0, action_taken: ref __self_0_1 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &Report) -> bool {
                match *other {
                    Report { id: ref __self_1_0, action_taken: ref __self_1_1
                    } =>
                    match *self {
                        Report {
                        id: ref __self_0_0, action_taken: ref __self_0_1 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1),
                    },
                }
            }
        }
    }
    /// Data structures for ser/de of search-related resources
    pub mod search_result {
        //! A module containing info relating to a search result.
        use super::{prelude::{Account, Status}, status::Tag};
        /// A struct containing results of a search.
        pub struct SearchResult {
            /// An array of matched Accounts.
            pub accounts: Vec<Account>,
            /// An array of matched Statuses.
            pub statuses: Vec<Status>,
            /// An array of matched hashtags, as strings.
            pub hashtags: Vec<String>,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for SearchResult {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    SearchResult {
                    accounts: ref __self_0_0,
                    statuses: ref __self_0_1,
                    hashtags: ref __self_0_2 } => {
                        let mut debug_trait_builder =
                            f.debug_struct("SearchResult");
                        let _ =
                            debug_trait_builder.field("accounts",
                                                      &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("statuses",
                                                      &&(*__self_0_1));
                        let _ =
                            debug_trait_builder.field("hashtags",
                                                      &&(*__self_0_2));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for SearchResult {
            #[inline]
            fn clone(&self) -> SearchResult {
                match *self {
                    SearchResult {
                    accounts: ref __self_0_0,
                    statuses: ref __self_0_1,
                    hashtags: ref __self_0_2 } =>
                    SearchResult{accounts:
                                     ::core::clone::Clone::clone(&(*__self_0_0)),
                                 statuses:
                                     ::core::clone::Clone::clone(&(*__self_0_1)),
                                 hashtags:
                                     ::core::clone::Clone::clone(&(*__self_0_2)),},
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_SearchResult: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'de> _serde::Deserialize<'de> for SearchResult {
                    fn deserialize<__D>(__deserializer: __D)
                     -> _serde::export::Result<Self, __D::Error> where
                     __D: _serde::Deserializer<'de> {
                        #[allow(non_camel_case_types)]
                        enum __Field {
                            __field0,
                            __field1,
                            __field2,
                            __ignore,
                        }
                        struct __FieldVisitor;
                        impl <'de> _serde::de::Visitor<'de> for __FieldVisitor
                         {
                            type Value = __Field;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "field identifier")
                            }
                            fn visit_u64<__E>(self, __value: u64)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    0u64 =>
                                    _serde::export::Ok(__Field::__field0),
                                    1u64 =>
                                    _serde::export::Ok(__Field::__field1),
                                    2u64 =>
                                    _serde::export::Ok(__Field::__field2),
                                    _ =>
                                    _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                         &"field index 0 <= i < 3")),
                                }
                            }
                            fn visit_str<__E>(self, __value: &str)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    "accounts" =>
                                    _serde::export::Ok(__Field::__field0),
                                    "statuses" =>
                                    _serde::export::Ok(__Field::__field1),
                                    "hashtags" =>
                                    _serde::export::Ok(__Field::__field2),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                            fn visit_bytes<__E>(self, __value: &[u8])
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    b"accounts" =>
                                    _serde::export::Ok(__Field::__field0),
                                    b"statuses" =>
                                    _serde::export::Ok(__Field::__field1),
                                    b"hashtags" =>
                                    _serde::export::Ok(__Field::__field2),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                        }
                        impl <'de> _serde::Deserialize<'de> for __Field {
                            #[inline]
                            fn deserialize<__D>(__deserializer: __D)
                             -> _serde::export::Result<Self, __D::Error> where
                             __D: _serde::Deserializer<'de> {
                                _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                             __FieldVisitor)
                            }
                        }
                        struct __Visitor<'de> {
                            marker: _serde::export::PhantomData<SearchResult>,
                            lifetime: _serde::export::PhantomData<&'de ()>,
                        }
                        impl <'de> _serde::de::Visitor<'de> for __Visitor<'de>
                         {
                            type Value = SearchResult;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "struct SearchResult")
                            }
                            #[inline]
                            fn visit_seq<__A>(self, mut __seq: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::SeqAccess<'de> {
                                let __field0 =
                                    match match _serde::de::SeqAccess::next_element::<Vec<Account>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                         &"struct SearchResult with 3 elements"));
                                        }
                                    };
                                let __field1 =
                                    match match _serde::de::SeqAccess::next_element::<Vec<Status>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(1usize,
                                                                                                         &"struct SearchResult with 3 elements"));
                                        }
                                    };
                                let __field2 =
                                    match match _serde::de::SeqAccess::next_element::<Vec<String>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(2usize,
                                                                                                         &"struct SearchResult with 3 elements"));
                                        }
                                    };
                                _serde::export::Ok(SearchResult{accounts:
                                                                    __field0,
                                                                statuses:
                                                                    __field1,
                                                                hashtags:
                                                                    __field2,})
                            }
                            #[inline]
                            fn visit_map<__A>(self, mut __map: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::MapAccess<'de> {
                                let mut __field0:
                                        _serde::export::Option<Vec<Account>> =
                                    _serde::export::None;
                                let mut __field1:
                                        _serde::export::Option<Vec<Status>> =
                                    _serde::export::None;
                                let mut __field2:
                                        _serde::export::Option<Vec<String>> =
                                    _serde::export::None;
                                while let _serde::export::Some(__key) =
                                          match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                    match __key {
                                        __Field::__field0 => {
                                            if _serde::export::Option::is_some(&__field0)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("accounts"));
                                            }
                                            __field0 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Vec<Account>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field1 => {
                                            if _serde::export::Option::is_some(&__field1)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("statuses"));
                                            }
                                            __field1 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Vec<Status>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field2 => {
                                            if _serde::export::Option::is_some(&__field2)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("hashtags"));
                                            }
                                            __field2 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Vec<String>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        _ => {
                                            let _ =
                                                match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                    {
                                                    _serde::export::Ok(__val)
                                                    => __val,
                                                    _serde::export::Err(__err)
                                                    => {
                                                        return _serde::export::Err(__err);
                                                    }
                                                };
                                        }
                                    }
                                }
                                let __field0 =
                                    match __field0 {
                                        _serde::export::Some(__field0) =>
                                        __field0,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("accounts")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field1 =
                                    match __field1 {
                                        _serde::export::Some(__field1) =>
                                        __field1,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("statuses")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field2 =
                                    match __field2 {
                                        _serde::export::Some(__field2) =>
                                        __field2,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("hashtags")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                _serde::export::Ok(SearchResult{accounts:
                                                                    __field0,
                                                                statuses:
                                                                    __field1,
                                                                hashtags:
                                                                    __field2,})
                            }
                        }
                        const FIELDS: &'static [&'static str] =
                            &["accounts", "statuses", "hashtags"];
                        _serde::Deserializer::deserialize_struct(__deserializer,
                                                                 "SearchResult",
                                                                 FIELDS,
                                                                 __Visitor{marker:
                                                                               _serde::export::PhantomData::<SearchResult>,
                                                                           lifetime:
                                                                               _serde::export::PhantomData,})
                    }
                }
            };
        impl ::core::marker::StructuralPartialEq for SearchResult { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for SearchResult {
            #[inline]
            fn eq(&self, other: &SearchResult) -> bool {
                match *other {
                    SearchResult {
                    accounts: ref __self_1_0,
                    statuses: ref __self_1_1,
                    hashtags: ref __self_1_2 } =>
                    match *self {
                        SearchResult {
                        accounts: ref __self_0_0,
                        statuses: ref __self_0_1,
                        hashtags: ref __self_0_2 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1) &&
                            (*__self_0_2) == (*__self_1_2),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &SearchResult) -> bool {
                match *other {
                    SearchResult {
                    accounts: ref __self_1_0,
                    statuses: ref __self_1_1,
                    hashtags: ref __self_1_2 } =>
                    match *self {
                        SearchResult {
                        accounts: ref __self_0_0,
                        statuses: ref __self_0_1,
                        hashtags: ref __self_0_2 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1) ||
                            (*__self_0_2) != (*__self_1_2),
                    },
                }
            }
        }
        /// A struct containing results of a search, with `Tag` objects in the
        /// `hashtags` field
        pub struct SearchResultV2 {
            /// An array of matched Accounts.
            pub accounts: Vec<Account>,
            /// An array of matched Statuses.
            pub statuses: Vec<Status>,
            /// An array of matched hashtags, as `Tag` objects.
            pub hashtags: Vec<Tag>,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for SearchResultV2 {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    SearchResultV2 {
                    accounts: ref __self_0_0,
                    statuses: ref __self_0_1,
                    hashtags: ref __self_0_2 } => {
                        let mut debug_trait_builder =
                            f.debug_struct("SearchResultV2");
                        let _ =
                            debug_trait_builder.field("accounts",
                                                      &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("statuses",
                                                      &&(*__self_0_1));
                        let _ =
                            debug_trait_builder.field("hashtags",
                                                      &&(*__self_0_2));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for SearchResultV2 {
            #[inline]
            fn clone(&self) -> SearchResultV2 {
                match *self {
                    SearchResultV2 {
                    accounts: ref __self_0_0,
                    statuses: ref __self_0_1,
                    hashtags: ref __self_0_2 } =>
                    SearchResultV2{accounts:
                                       ::core::clone::Clone::clone(&(*__self_0_0)),
                                   statuses:
                                       ::core::clone::Clone::clone(&(*__self_0_1)),
                                   hashtags:
                                       ::core::clone::Clone::clone(&(*__self_0_2)),},
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_SearchResultV2: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'de> _serde::Deserialize<'de> for SearchResultV2 {
                    fn deserialize<__D>(__deserializer: __D)
                     -> _serde::export::Result<Self, __D::Error> where
                     __D: _serde::Deserializer<'de> {
                        #[allow(non_camel_case_types)]
                        enum __Field {
                            __field0,
                            __field1,
                            __field2,
                            __ignore,
                        }
                        struct __FieldVisitor;
                        impl <'de> _serde::de::Visitor<'de> for __FieldVisitor
                         {
                            type Value = __Field;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "field identifier")
                            }
                            fn visit_u64<__E>(self, __value: u64)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    0u64 =>
                                    _serde::export::Ok(__Field::__field0),
                                    1u64 =>
                                    _serde::export::Ok(__Field::__field1),
                                    2u64 =>
                                    _serde::export::Ok(__Field::__field2),
                                    _ =>
                                    _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                         &"field index 0 <= i < 3")),
                                }
                            }
                            fn visit_str<__E>(self, __value: &str)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    "accounts" =>
                                    _serde::export::Ok(__Field::__field0),
                                    "statuses" =>
                                    _serde::export::Ok(__Field::__field1),
                                    "hashtags" =>
                                    _serde::export::Ok(__Field::__field2),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                            fn visit_bytes<__E>(self, __value: &[u8])
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    b"accounts" =>
                                    _serde::export::Ok(__Field::__field0),
                                    b"statuses" =>
                                    _serde::export::Ok(__Field::__field1),
                                    b"hashtags" =>
                                    _serde::export::Ok(__Field::__field2),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                        }
                        impl <'de> _serde::Deserialize<'de> for __Field {
                            #[inline]
                            fn deserialize<__D>(__deserializer: __D)
                             -> _serde::export::Result<Self, __D::Error> where
                             __D: _serde::Deserializer<'de> {
                                _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                             __FieldVisitor)
                            }
                        }
                        struct __Visitor<'de> {
                            marker: _serde::export::PhantomData<SearchResultV2>,
                            lifetime: _serde::export::PhantomData<&'de ()>,
                        }
                        impl <'de> _serde::de::Visitor<'de> for __Visitor<'de>
                         {
                            type Value = SearchResultV2;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "struct SearchResultV2")
                            }
                            #[inline]
                            fn visit_seq<__A>(self, mut __seq: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::SeqAccess<'de> {
                                let __field0 =
                                    match match _serde::de::SeqAccess::next_element::<Vec<Account>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                         &"struct SearchResultV2 with 3 elements"));
                                        }
                                    };
                                let __field1 =
                                    match match _serde::de::SeqAccess::next_element::<Vec<Status>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(1usize,
                                                                                                         &"struct SearchResultV2 with 3 elements"));
                                        }
                                    };
                                let __field2 =
                                    match match _serde::de::SeqAccess::next_element::<Vec<Tag>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(2usize,
                                                                                                         &"struct SearchResultV2 with 3 elements"));
                                        }
                                    };
                                _serde::export::Ok(SearchResultV2{accounts:
                                                                      __field0,
                                                                  statuses:
                                                                      __field1,
                                                                  hashtags:
                                                                      __field2,})
                            }
                            #[inline]
                            fn visit_map<__A>(self, mut __map: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::MapAccess<'de> {
                                let mut __field0:
                                        _serde::export::Option<Vec<Account>> =
                                    _serde::export::None;
                                let mut __field1:
                                        _serde::export::Option<Vec<Status>> =
                                    _serde::export::None;
                                let mut __field2:
                                        _serde::export::Option<Vec<Tag>> =
                                    _serde::export::None;
                                while let _serde::export::Some(__key) =
                                          match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                    match __key {
                                        __Field::__field0 => {
                                            if _serde::export::Option::is_some(&__field0)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("accounts"));
                                            }
                                            __field0 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Vec<Account>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field1 => {
                                            if _serde::export::Option::is_some(&__field1)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("statuses"));
                                            }
                                            __field1 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Vec<Status>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field2 => {
                                            if _serde::export::Option::is_some(&__field2)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("hashtags"));
                                            }
                                            __field2 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Vec<Tag>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        _ => {
                                            let _ =
                                                match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                    {
                                                    _serde::export::Ok(__val)
                                                    => __val,
                                                    _serde::export::Err(__err)
                                                    => {
                                                        return _serde::export::Err(__err);
                                                    }
                                                };
                                        }
                                    }
                                }
                                let __field0 =
                                    match __field0 {
                                        _serde::export::Some(__field0) =>
                                        __field0,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("accounts")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field1 =
                                    match __field1 {
                                        _serde::export::Some(__field1) =>
                                        __field1,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("statuses")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field2 =
                                    match __field2 {
                                        _serde::export::Some(__field2) =>
                                        __field2,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("hashtags")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                _serde::export::Ok(SearchResultV2{accounts:
                                                                      __field0,
                                                                  statuses:
                                                                      __field1,
                                                                  hashtags:
                                                                      __field2,})
                            }
                        }
                        const FIELDS: &'static [&'static str] =
                            &["accounts", "statuses", "hashtags"];
                        _serde::Deserializer::deserialize_struct(__deserializer,
                                                                 "SearchResultV2",
                                                                 FIELDS,
                                                                 __Visitor{marker:
                                                                               _serde::export::PhantomData::<SearchResultV2>,
                                                                           lifetime:
                                                                               _serde::export::PhantomData,})
                    }
                }
            };
        impl ::core::marker::StructuralPartialEq for SearchResultV2 { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for SearchResultV2 {
            #[inline]
            fn eq(&self, other: &SearchResultV2) -> bool {
                match *other {
                    SearchResultV2 {
                    accounts: ref __self_1_0,
                    statuses: ref __self_1_1,
                    hashtags: ref __self_1_2 } =>
                    match *self {
                        SearchResultV2 {
                        accounts: ref __self_0_0,
                        statuses: ref __self_0_1,
                        hashtags: ref __self_0_2 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1) &&
                            (*__self_0_2) == (*__self_1_2),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &SearchResultV2) -> bool {
                match *other {
                    SearchResultV2 {
                    accounts: ref __self_1_0,
                    statuses: ref __self_1_1,
                    hashtags: ref __self_1_2 } =>
                    match *self {
                        SearchResultV2 {
                        accounts: ref __self_0_0,
                        statuses: ref __self_0_1,
                        hashtags: ref __self_0_2 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1) ||
                            (*__self_0_2) != (*__self_1_2),
                    },
                }
            }
        }
    }
    /// Data structures for ser/de of status-related resources
    pub mod status {
        //! Module containing all info relating to a status.
        use super::prelude::*;
        use chrono::prelude::*;
        use crate::entities::card::Card;
        use crate::status_builder::Visibility;
        /// A status from the instance.
        pub struct Status {
            /// The ID of the status.
            pub id: String,
            /// A Fediverse-unique resource ID.
            pub uri: String,
            /// URL to the status page (can be remote)
            pub url: Option<String>,
            /// The Account which posted the status.
            pub account: Account,
            /// The ID of the status this status is replying to, if the status is
            /// a reply.
            pub in_reply_to_id: Option<String>,
            /// The ID of the account this status is replying to, if the status is
            /// a reply.
            pub in_reply_to_account_id: Option<String>,
            /// If this status is a reblogged Status of another User.
            pub reblog: Option<Box<Status>>,
            /// Body of the status; this will contain HTML
            /// (remote HTML already sanitized)
            pub content: String,
            /// The time the status was created.
            pub created_at: DateTime<Utc>,
            /// An array of Emoji
            pub emojis: Vec<Emoji>,
            /// The numbef or replies to this status.
            pub replies_count: Option<u64>,
            /// The number of reblogs for the status.
            pub reblogs_count: u64,
            /// The number of favourites for the status.
            pub favourites_count: u64,
            /// Whether the application client has reblogged the status.
            pub reblogged: Option<bool>,
            /// Whether the application client has favourited the status.
            pub favourited: Option<bool>,
            /// Whether media attachments should be hidden by default.
            pub sensitive: bool,
            /// If not empty, warning text that should be displayed before the actual
            /// content.
            pub spoiler_text: String,
            /// The visibilty of the status.
            pub visibility: Visibility,
            /// An array of attachments.
            pub media_attachments: Vec<Attachment>,
            /// An array of mentions.
            pub mentions: Vec<Mention>,
            /// An array of tags.
            pub tags: Vec<Tag>,
            /// The associated card
            pub card: Option<Card>,
            /// Name of application used to post status.
            pub application: Option<Application>,
            /// The detected language for the status, if detected.
            pub language: Option<String>,
            /// Whether this is the pinned status for the account that posted it.
            pub pinned: Option<bool>,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for Status {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    Status {
                    id: ref __self_0_0,
                    uri: ref __self_0_1,
                    url: ref __self_0_2,
                    account: ref __self_0_3,
                    in_reply_to_id: ref __self_0_4,
                    in_reply_to_account_id: ref __self_0_5,
                    reblog: ref __self_0_6,
                    content: ref __self_0_7,
                    created_at: ref __self_0_8,
                    emojis: ref __self_0_9,
                    replies_count: ref __self_0_10,
                    reblogs_count: ref __self_0_11,
                    favourites_count: ref __self_0_12,
                    reblogged: ref __self_0_13,
                    favourited: ref __self_0_14,
                    sensitive: ref __self_0_15,
                    spoiler_text: ref __self_0_16,
                    visibility: ref __self_0_17,
                    media_attachments: ref __self_0_18,
                    mentions: ref __self_0_19,
                    tags: ref __self_0_20,
                    card: ref __self_0_21,
                    application: ref __self_0_22,
                    language: ref __self_0_23,
                    pinned: ref __self_0_24 } => {
                        let mut debug_trait_builder =
                            f.debug_struct("Status");
                        let _ =
                            debug_trait_builder.field("id", &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("uri", &&(*__self_0_1));
                        let _ =
                            debug_trait_builder.field("url", &&(*__self_0_2));
                        let _ =
                            debug_trait_builder.field("account",
                                                      &&(*__self_0_3));
                        let _ =
                            debug_trait_builder.field("in_reply_to_id",
                                                      &&(*__self_0_4));
                        let _ =
                            debug_trait_builder.field("in_reply_to_account_id",
                                                      &&(*__self_0_5));
                        let _ =
                            debug_trait_builder.field("reblog",
                                                      &&(*__self_0_6));
                        let _ =
                            debug_trait_builder.field("content",
                                                      &&(*__self_0_7));
                        let _ =
                            debug_trait_builder.field("created_at",
                                                      &&(*__self_0_8));
                        let _ =
                            debug_trait_builder.field("emojis",
                                                      &&(*__self_0_9));
                        let _ =
                            debug_trait_builder.field("replies_count",
                                                      &&(*__self_0_10));
                        let _ =
                            debug_trait_builder.field("reblogs_count",
                                                      &&(*__self_0_11));
                        let _ =
                            debug_trait_builder.field("favourites_count",
                                                      &&(*__self_0_12));
                        let _ =
                            debug_trait_builder.field("reblogged",
                                                      &&(*__self_0_13));
                        let _ =
                            debug_trait_builder.field("favourited",
                                                      &&(*__self_0_14));
                        let _ =
                            debug_trait_builder.field("sensitive",
                                                      &&(*__self_0_15));
                        let _ =
                            debug_trait_builder.field("spoiler_text",
                                                      &&(*__self_0_16));
                        let _ =
                            debug_trait_builder.field("visibility",
                                                      &&(*__self_0_17));
                        let _ =
                            debug_trait_builder.field("media_attachments",
                                                      &&(*__self_0_18));
                        let _ =
                            debug_trait_builder.field("mentions",
                                                      &&(*__self_0_19));
                        let _ =
                            debug_trait_builder.field("tags",
                                                      &&(*__self_0_20));
                        let _ =
                            debug_trait_builder.field("card",
                                                      &&(*__self_0_21));
                        let _ =
                            debug_trait_builder.field("application",
                                                      &&(*__self_0_22));
                        let _ =
                            debug_trait_builder.field("language",
                                                      &&(*__self_0_23));
                        let _ =
                            debug_trait_builder.field("pinned",
                                                      &&(*__self_0_24));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for Status {
            #[inline]
            fn clone(&self) -> Status {
                match *self {
                    Status {
                    id: ref __self_0_0,
                    uri: ref __self_0_1,
                    url: ref __self_0_2,
                    account: ref __self_0_3,
                    in_reply_to_id: ref __self_0_4,
                    in_reply_to_account_id: ref __self_0_5,
                    reblog: ref __self_0_6,
                    content: ref __self_0_7,
                    created_at: ref __self_0_8,
                    emojis: ref __self_0_9,
                    replies_count: ref __self_0_10,
                    reblogs_count: ref __self_0_11,
                    favourites_count: ref __self_0_12,
                    reblogged: ref __self_0_13,
                    favourited: ref __self_0_14,
                    sensitive: ref __self_0_15,
                    spoiler_text: ref __self_0_16,
                    visibility: ref __self_0_17,
                    media_attachments: ref __self_0_18,
                    mentions: ref __self_0_19,
                    tags: ref __self_0_20,
                    card: ref __self_0_21,
                    application: ref __self_0_22,
                    language: ref __self_0_23,
                    pinned: ref __self_0_24 } =>
                    Status{id: ::core::clone::Clone::clone(&(*__self_0_0)),
                           uri: ::core::clone::Clone::clone(&(*__self_0_1)),
                           url: ::core::clone::Clone::clone(&(*__self_0_2)),
                           account:
                               ::core::clone::Clone::clone(&(*__self_0_3)),
                           in_reply_to_id:
                               ::core::clone::Clone::clone(&(*__self_0_4)),
                           in_reply_to_account_id:
                               ::core::clone::Clone::clone(&(*__self_0_5)),
                           reblog:
                               ::core::clone::Clone::clone(&(*__self_0_6)),
                           content:
                               ::core::clone::Clone::clone(&(*__self_0_7)),
                           created_at:
                               ::core::clone::Clone::clone(&(*__self_0_8)),
                           emojis:
                               ::core::clone::Clone::clone(&(*__self_0_9)),
                           replies_count:
                               ::core::clone::Clone::clone(&(*__self_0_10)),
                           reblogs_count:
                               ::core::clone::Clone::clone(&(*__self_0_11)),
                           favourites_count:
                               ::core::clone::Clone::clone(&(*__self_0_12)),
                           reblogged:
                               ::core::clone::Clone::clone(&(*__self_0_13)),
                           favourited:
                               ::core::clone::Clone::clone(&(*__self_0_14)),
                           sensitive:
                               ::core::clone::Clone::clone(&(*__self_0_15)),
                           spoiler_text:
                               ::core::clone::Clone::clone(&(*__self_0_16)),
                           visibility:
                               ::core::clone::Clone::clone(&(*__self_0_17)),
                           media_attachments:
                               ::core::clone::Clone::clone(&(*__self_0_18)),
                           mentions:
                               ::core::clone::Clone::clone(&(*__self_0_19)),
                           tags: ::core::clone::Clone::clone(&(*__self_0_20)),
                           card: ::core::clone::Clone::clone(&(*__self_0_21)),
                           application:
                               ::core::clone::Clone::clone(&(*__self_0_22)),
                           language:
                               ::core::clone::Clone::clone(&(*__self_0_23)),
                           pinned:
                               ::core::clone::Clone::clone(&(*__self_0_24)),},
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_Status: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'de> _serde::Deserialize<'de> for Status {
                    fn deserialize<__D>(__deserializer: __D)
                     -> _serde::export::Result<Self, __D::Error> where
                     __D: _serde::Deserializer<'de> {
                        #[allow(non_camel_case_types)]
                        enum __Field {
                            __field0,
                            __field1,
                            __field2,
                            __field3,
                            __field4,
                            __field5,
                            __field6,
                            __field7,
                            __field8,
                            __field9,
                            __field10,
                            __field11,
                            __field12,
                            __field13,
                            __field14,
                            __field15,
                            __field16,
                            __field17,
                            __field18,
                            __field19,
                            __field20,
                            __field21,
                            __field22,
                            __field23,
                            __field24,
                            __ignore,
                        }
                        struct __FieldVisitor;
                        impl <'de> _serde::de::Visitor<'de> for __FieldVisitor
                         {
                            type Value = __Field;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "field identifier")
                            }
                            fn visit_u64<__E>(self, __value: u64)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    0u64 =>
                                    _serde::export::Ok(__Field::__field0),
                                    1u64 =>
                                    _serde::export::Ok(__Field::__field1),
                                    2u64 =>
                                    _serde::export::Ok(__Field::__field2),
                                    3u64 =>
                                    _serde::export::Ok(__Field::__field3),
                                    4u64 =>
                                    _serde::export::Ok(__Field::__field4),
                                    5u64 =>
                                    _serde::export::Ok(__Field::__field5),
                                    6u64 =>
                                    _serde::export::Ok(__Field::__field6),
                                    7u64 =>
                                    _serde::export::Ok(__Field::__field7),
                                    8u64 =>
                                    _serde::export::Ok(__Field::__field8),
                                    9u64 =>
                                    _serde::export::Ok(__Field::__field9),
                                    10u64 =>
                                    _serde::export::Ok(__Field::__field10),
                                    11u64 =>
                                    _serde::export::Ok(__Field::__field11),
                                    12u64 =>
                                    _serde::export::Ok(__Field::__field12),
                                    13u64 =>
                                    _serde::export::Ok(__Field::__field13),
                                    14u64 =>
                                    _serde::export::Ok(__Field::__field14),
                                    15u64 =>
                                    _serde::export::Ok(__Field::__field15),
                                    16u64 =>
                                    _serde::export::Ok(__Field::__field16),
                                    17u64 =>
                                    _serde::export::Ok(__Field::__field17),
                                    18u64 =>
                                    _serde::export::Ok(__Field::__field18),
                                    19u64 =>
                                    _serde::export::Ok(__Field::__field19),
                                    20u64 =>
                                    _serde::export::Ok(__Field::__field20),
                                    21u64 =>
                                    _serde::export::Ok(__Field::__field21),
                                    22u64 =>
                                    _serde::export::Ok(__Field::__field22),
                                    23u64 =>
                                    _serde::export::Ok(__Field::__field23),
                                    24u64 =>
                                    _serde::export::Ok(__Field::__field24),
                                    _ =>
                                    _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                         &"field index 0 <= i < 25")),
                                }
                            }
                            fn visit_str<__E>(self, __value: &str)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    "id" =>
                                    _serde::export::Ok(__Field::__field0),
                                    "uri" =>
                                    _serde::export::Ok(__Field::__field1),
                                    "url" =>
                                    _serde::export::Ok(__Field::__field2),
                                    "account" =>
                                    _serde::export::Ok(__Field::__field3),
                                    "in_reply_to_id" =>
                                    _serde::export::Ok(__Field::__field4),
                                    "in_reply_to_account_id" =>
                                    _serde::export::Ok(__Field::__field5),
                                    "reblog" =>
                                    _serde::export::Ok(__Field::__field6),
                                    "content" =>
                                    _serde::export::Ok(__Field::__field7),
                                    "created_at" =>
                                    _serde::export::Ok(__Field::__field8),
                                    "emojis" =>
                                    _serde::export::Ok(__Field::__field9),
                                    "replies_count" =>
                                    _serde::export::Ok(__Field::__field10),
                                    "reblogs_count" =>
                                    _serde::export::Ok(__Field::__field11),
                                    "favourites_count" =>
                                    _serde::export::Ok(__Field::__field12),
                                    "reblogged" =>
                                    _serde::export::Ok(__Field::__field13),
                                    "favourited" =>
                                    _serde::export::Ok(__Field::__field14),
                                    "sensitive" =>
                                    _serde::export::Ok(__Field::__field15),
                                    "spoiler_text" =>
                                    _serde::export::Ok(__Field::__field16),
                                    "visibility" =>
                                    _serde::export::Ok(__Field::__field17),
                                    "media_attachments" =>
                                    _serde::export::Ok(__Field::__field18),
                                    "mentions" =>
                                    _serde::export::Ok(__Field::__field19),
                                    "tags" =>
                                    _serde::export::Ok(__Field::__field20),
                                    "card" =>
                                    _serde::export::Ok(__Field::__field21),
                                    "application" =>
                                    _serde::export::Ok(__Field::__field22),
                                    "language" =>
                                    _serde::export::Ok(__Field::__field23),
                                    "pinned" =>
                                    _serde::export::Ok(__Field::__field24),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                            fn visit_bytes<__E>(self, __value: &[u8])
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    b"id" =>
                                    _serde::export::Ok(__Field::__field0),
                                    b"uri" =>
                                    _serde::export::Ok(__Field::__field1),
                                    b"url" =>
                                    _serde::export::Ok(__Field::__field2),
                                    b"account" =>
                                    _serde::export::Ok(__Field::__field3),
                                    b"in_reply_to_id" =>
                                    _serde::export::Ok(__Field::__field4),
                                    b"in_reply_to_account_id" =>
                                    _serde::export::Ok(__Field::__field5),
                                    b"reblog" =>
                                    _serde::export::Ok(__Field::__field6),
                                    b"content" =>
                                    _serde::export::Ok(__Field::__field7),
                                    b"created_at" =>
                                    _serde::export::Ok(__Field::__field8),
                                    b"emojis" =>
                                    _serde::export::Ok(__Field::__field9),
                                    b"replies_count" =>
                                    _serde::export::Ok(__Field::__field10),
                                    b"reblogs_count" =>
                                    _serde::export::Ok(__Field::__field11),
                                    b"favourites_count" =>
                                    _serde::export::Ok(__Field::__field12),
                                    b"reblogged" =>
                                    _serde::export::Ok(__Field::__field13),
                                    b"favourited" =>
                                    _serde::export::Ok(__Field::__field14),
                                    b"sensitive" =>
                                    _serde::export::Ok(__Field::__field15),
                                    b"spoiler_text" =>
                                    _serde::export::Ok(__Field::__field16),
                                    b"visibility" =>
                                    _serde::export::Ok(__Field::__field17),
                                    b"media_attachments" =>
                                    _serde::export::Ok(__Field::__field18),
                                    b"mentions" =>
                                    _serde::export::Ok(__Field::__field19),
                                    b"tags" =>
                                    _serde::export::Ok(__Field::__field20),
                                    b"card" =>
                                    _serde::export::Ok(__Field::__field21),
                                    b"application" =>
                                    _serde::export::Ok(__Field::__field22),
                                    b"language" =>
                                    _serde::export::Ok(__Field::__field23),
                                    b"pinned" =>
                                    _serde::export::Ok(__Field::__field24),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                        }
                        impl <'de> _serde::Deserialize<'de> for __Field {
                            #[inline]
                            fn deserialize<__D>(__deserializer: __D)
                             -> _serde::export::Result<Self, __D::Error> where
                             __D: _serde::Deserializer<'de> {
                                _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                             __FieldVisitor)
                            }
                        }
                        struct __Visitor<'de> {
                            marker: _serde::export::PhantomData<Status>,
                            lifetime: _serde::export::PhantomData<&'de ()>,
                        }
                        impl <'de> _serde::de::Visitor<'de> for __Visitor<'de>
                         {
                            type Value = Status;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "struct Status")
                            }
                            #[inline]
                            fn visit_seq<__A>(self, mut __seq: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::SeqAccess<'de> {
                                let __field0 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                         &"struct Status with 25 elements"));
                                        }
                                    };
                                let __field1 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(1usize,
                                                                                                         &"struct Status with 25 elements"));
                                        }
                                    };
                                let __field2 =
                                    match match _serde::de::SeqAccess::next_element::<Option<String>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(2usize,
                                                                                                         &"struct Status with 25 elements"));
                                        }
                                    };
                                let __field3 =
                                    match match _serde::de::SeqAccess::next_element::<Account>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(3usize,
                                                                                                         &"struct Status with 25 elements"));
                                        }
                                    };
                                let __field4 =
                                    match match _serde::de::SeqAccess::next_element::<Option<String>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(4usize,
                                                                                                         &"struct Status with 25 elements"));
                                        }
                                    };
                                let __field5 =
                                    match match _serde::de::SeqAccess::next_element::<Option<String>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(5usize,
                                                                                                         &"struct Status with 25 elements"));
                                        }
                                    };
                                let __field6 =
                                    match match _serde::de::SeqAccess::next_element::<Option<Box<Status>>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(6usize,
                                                                                                         &"struct Status with 25 elements"));
                                        }
                                    };
                                let __field7 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(7usize,
                                                                                                         &"struct Status with 25 elements"));
                                        }
                                    };
                                let __field8 =
                                    match match _serde::de::SeqAccess::next_element::<DateTime<Utc>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(8usize,
                                                                                                         &"struct Status with 25 elements"));
                                        }
                                    };
                                let __field9 =
                                    match match _serde::de::SeqAccess::next_element::<Vec<Emoji>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(9usize,
                                                                                                         &"struct Status with 25 elements"));
                                        }
                                    };
                                let __field10 =
                                    match match _serde::de::SeqAccess::next_element::<Option<u64>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(10usize,
                                                                                                         &"struct Status with 25 elements"));
                                        }
                                    };
                                let __field11 =
                                    match match _serde::de::SeqAccess::next_element::<u64>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(11usize,
                                                                                                         &"struct Status with 25 elements"));
                                        }
                                    };
                                let __field12 =
                                    match match _serde::de::SeqAccess::next_element::<u64>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(12usize,
                                                                                                         &"struct Status with 25 elements"));
                                        }
                                    };
                                let __field13 =
                                    match match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(13usize,
                                                                                                         &"struct Status with 25 elements"));
                                        }
                                    };
                                let __field14 =
                                    match match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(14usize,
                                                                                                         &"struct Status with 25 elements"));
                                        }
                                    };
                                let __field15 =
                                    match match _serde::de::SeqAccess::next_element::<bool>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(15usize,
                                                                                                         &"struct Status with 25 elements"));
                                        }
                                    };
                                let __field16 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(16usize,
                                                                                                         &"struct Status with 25 elements"));
                                        }
                                    };
                                let __field17 =
                                    match match _serde::de::SeqAccess::next_element::<Visibility>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(17usize,
                                                                                                         &"struct Status with 25 elements"));
                                        }
                                    };
                                let __field18 =
                                    match match _serde::de::SeqAccess::next_element::<Vec<Attachment>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(18usize,
                                                                                                         &"struct Status with 25 elements"));
                                        }
                                    };
                                let __field19 =
                                    match match _serde::de::SeqAccess::next_element::<Vec<Mention>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(19usize,
                                                                                                         &"struct Status with 25 elements"));
                                        }
                                    };
                                let __field20 =
                                    match match _serde::de::SeqAccess::next_element::<Vec<Tag>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(20usize,
                                                                                                         &"struct Status with 25 elements"));
                                        }
                                    };
                                let __field21 =
                                    match match _serde::de::SeqAccess::next_element::<Option<Card>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(21usize,
                                                                                                         &"struct Status with 25 elements"));
                                        }
                                    };
                                let __field22 =
                                    match match _serde::de::SeqAccess::next_element::<Option<Application>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(22usize,
                                                                                                         &"struct Status with 25 elements"));
                                        }
                                    };
                                let __field23 =
                                    match match _serde::de::SeqAccess::next_element::<Option<String>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(23usize,
                                                                                                         &"struct Status with 25 elements"));
                                        }
                                    };
                                let __field24 =
                                    match match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(24usize,
                                                                                                         &"struct Status with 25 elements"));
                                        }
                                    };
                                _serde::export::Ok(Status{id: __field0,
                                                          uri: __field1,
                                                          url: __field2,
                                                          account: __field3,
                                                          in_reply_to_id:
                                                              __field4,
                                                          in_reply_to_account_id:
                                                              __field5,
                                                          reblog: __field6,
                                                          content: __field7,
                                                          created_at:
                                                              __field8,
                                                          emojis: __field9,
                                                          replies_count:
                                                              __field10,
                                                          reblogs_count:
                                                              __field11,
                                                          favourites_count:
                                                              __field12,
                                                          reblogged:
                                                              __field13,
                                                          favourited:
                                                              __field14,
                                                          sensitive:
                                                              __field15,
                                                          spoiler_text:
                                                              __field16,
                                                          visibility:
                                                              __field17,
                                                          media_attachments:
                                                              __field18,
                                                          mentions: __field19,
                                                          tags: __field20,
                                                          card: __field21,
                                                          application:
                                                              __field22,
                                                          language: __field23,
                                                          pinned: __field24,})
                            }
                            #[inline]
                            fn visit_map<__A>(self, mut __map: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::MapAccess<'de> {
                                let mut __field0:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field1:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field2:
                                        _serde::export::Option<Option<String>> =
                                    _serde::export::None;
                                let mut __field3:
                                        _serde::export::Option<Account> =
                                    _serde::export::None;
                                let mut __field4:
                                        _serde::export::Option<Option<String>> =
                                    _serde::export::None;
                                let mut __field5:
                                        _serde::export::Option<Option<String>> =
                                    _serde::export::None;
                                let mut __field6:
                                        _serde::export::Option<Option<Box<Status>>> =
                                    _serde::export::None;
                                let mut __field7:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field8:
                                        _serde::export::Option<DateTime<Utc>> =
                                    _serde::export::None;
                                let mut __field9:
                                        _serde::export::Option<Vec<Emoji>> =
                                    _serde::export::None;
                                let mut __field10:
                                        _serde::export::Option<Option<u64>> =
                                    _serde::export::None;
                                let mut __field11:
                                        _serde::export::Option<u64> =
                                    _serde::export::None;
                                let mut __field12:
                                        _serde::export::Option<u64> =
                                    _serde::export::None;
                                let mut __field13:
                                        _serde::export::Option<Option<bool>> =
                                    _serde::export::None;
                                let mut __field14:
                                        _serde::export::Option<Option<bool>> =
                                    _serde::export::None;
                                let mut __field15:
                                        _serde::export::Option<bool> =
                                    _serde::export::None;
                                let mut __field16:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field17:
                                        _serde::export::Option<Visibility> =
                                    _serde::export::None;
                                let mut __field18:
                                        _serde::export::Option<Vec<Attachment>> =
                                    _serde::export::None;
                                let mut __field19:
                                        _serde::export::Option<Vec<Mention>> =
                                    _serde::export::None;
                                let mut __field20:
                                        _serde::export::Option<Vec<Tag>> =
                                    _serde::export::None;
                                let mut __field21:
                                        _serde::export::Option<Option<Card>> =
                                    _serde::export::None;
                                let mut __field22:
                                        _serde::export::Option<Option<Application>> =
                                    _serde::export::None;
                                let mut __field23:
                                        _serde::export::Option<Option<String>> =
                                    _serde::export::None;
                                let mut __field24:
                                        _serde::export::Option<Option<bool>> =
                                    _serde::export::None;
                                while let _serde::export::Some(__key) =
                                          match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                    match __key {
                                        __Field::__field0 => {
                                            if _serde::export::Option::is_some(&__field0)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("id"));
                                            }
                                            __field0 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field1 => {
                                            if _serde::export::Option::is_some(&__field1)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("uri"));
                                            }
                                            __field1 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field2 => {
                                            if _serde::export::Option::is_some(&__field2)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("url"));
                                            }
                                            __field2 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<String>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field3 => {
                                            if _serde::export::Option::is_some(&__field3)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("account"));
                                            }
                                            __field3 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Account>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field4 => {
                                            if _serde::export::Option::is_some(&__field4)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("in_reply_to_id"));
                                            }
                                            __field4 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<String>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field5 => {
                                            if _serde::export::Option::is_some(&__field5)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("in_reply_to_account_id"));
                                            }
                                            __field5 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<String>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field6 => {
                                            if _serde::export::Option::is_some(&__field6)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("reblog"));
                                            }
                                            __field6 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<Box<Status>>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field7 => {
                                            if _serde::export::Option::is_some(&__field7)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("content"));
                                            }
                                            __field7 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field8 => {
                                            if _serde::export::Option::is_some(&__field8)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("created_at"));
                                            }
                                            __field8 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<DateTime<Utc>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field9 => {
                                            if _serde::export::Option::is_some(&__field9)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("emojis"));
                                            }
                                            __field9 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Vec<Emoji>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field10 => {
                                            if _serde::export::Option::is_some(&__field10)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("replies_count"));
                                            }
                                            __field10 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<u64>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field11 => {
                                            if _serde::export::Option::is_some(&__field11)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("reblogs_count"));
                                            }
                                            __field11 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<u64>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field12 => {
                                            if _serde::export::Option::is_some(&__field12)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("favourites_count"));
                                            }
                                            __field12 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<u64>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field13 => {
                                            if _serde::export::Option::is_some(&__field13)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("reblogged"));
                                            }
                                            __field13 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field14 => {
                                            if _serde::export::Option::is_some(&__field14)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("favourited"));
                                            }
                                            __field14 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field15 => {
                                            if _serde::export::Option::is_some(&__field15)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("sensitive"));
                                            }
                                            __field15 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<bool>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field16 => {
                                            if _serde::export::Option::is_some(&__field16)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("spoiler_text"));
                                            }
                                            __field16 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field17 => {
                                            if _serde::export::Option::is_some(&__field17)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("visibility"));
                                            }
                                            __field17 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Visibility>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field18 => {
                                            if _serde::export::Option::is_some(&__field18)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("media_attachments"));
                                            }
                                            __field18 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Vec<Attachment>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field19 => {
                                            if _serde::export::Option::is_some(&__field19)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("mentions"));
                                            }
                                            __field19 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Vec<Mention>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field20 => {
                                            if _serde::export::Option::is_some(&__field20)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("tags"));
                                            }
                                            __field20 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Vec<Tag>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field21 => {
                                            if _serde::export::Option::is_some(&__field21)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("card"));
                                            }
                                            __field21 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<Card>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field22 => {
                                            if _serde::export::Option::is_some(&__field22)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("application"));
                                            }
                                            __field22 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<Application>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field23 => {
                                            if _serde::export::Option::is_some(&__field23)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("language"));
                                            }
                                            __field23 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<String>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field24 => {
                                            if _serde::export::Option::is_some(&__field24)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("pinned"));
                                            }
                                            __field24 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        _ => {
                                            let _ =
                                                match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                    {
                                                    _serde::export::Ok(__val)
                                                    => __val,
                                                    _serde::export::Err(__err)
                                                    => {
                                                        return _serde::export::Err(__err);
                                                    }
                                                };
                                        }
                                    }
                                }
                                let __field0 =
                                    match __field0 {
                                        _serde::export::Some(__field0) =>
                                        __field0,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("id")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field1 =
                                    match __field1 {
                                        _serde::export::Some(__field1) =>
                                        __field1,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("uri")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field2 =
                                    match __field2 {
                                        _serde::export::Some(__field2) =>
                                        __field2,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("url")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field3 =
                                    match __field3 {
                                        _serde::export::Some(__field3) =>
                                        __field3,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("account")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field4 =
                                    match __field4 {
                                        _serde::export::Some(__field4) =>
                                        __field4,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("in_reply_to_id")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field5 =
                                    match __field5 {
                                        _serde::export::Some(__field5) =>
                                        __field5,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("in_reply_to_account_id")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field6 =
                                    match __field6 {
                                        _serde::export::Some(__field6) =>
                                        __field6,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("reblog")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field7 =
                                    match __field7 {
                                        _serde::export::Some(__field7) =>
                                        __field7,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("content")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field8 =
                                    match __field8 {
                                        _serde::export::Some(__field8) =>
                                        __field8,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("created_at")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field9 =
                                    match __field9 {
                                        _serde::export::Some(__field9) =>
                                        __field9,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("emojis")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field10 =
                                    match __field10 {
                                        _serde::export::Some(__field10) =>
                                        __field10,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("replies_count")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field11 =
                                    match __field11 {
                                        _serde::export::Some(__field11) =>
                                        __field11,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("reblogs_count")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field12 =
                                    match __field12 {
                                        _serde::export::Some(__field12) =>
                                        __field12,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("favourites_count")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field13 =
                                    match __field13 {
                                        _serde::export::Some(__field13) =>
                                        __field13,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("reblogged")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field14 =
                                    match __field14 {
                                        _serde::export::Some(__field14) =>
                                        __field14,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("favourited")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field15 =
                                    match __field15 {
                                        _serde::export::Some(__field15) =>
                                        __field15,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("sensitive")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field16 =
                                    match __field16 {
                                        _serde::export::Some(__field16) =>
                                        __field16,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("spoiler_text")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field17 =
                                    match __field17 {
                                        _serde::export::Some(__field17) =>
                                        __field17,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("visibility")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field18 =
                                    match __field18 {
                                        _serde::export::Some(__field18) =>
                                        __field18,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("media_attachments")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field19 =
                                    match __field19 {
                                        _serde::export::Some(__field19) =>
                                        __field19,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("mentions")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field20 =
                                    match __field20 {
                                        _serde::export::Some(__field20) =>
                                        __field20,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("tags")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field21 =
                                    match __field21 {
                                        _serde::export::Some(__field21) =>
                                        __field21,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("card")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field22 =
                                    match __field22 {
                                        _serde::export::Some(__field22) =>
                                        __field22,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("application")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field23 =
                                    match __field23 {
                                        _serde::export::Some(__field23) =>
                                        __field23,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("language")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field24 =
                                    match __field24 {
                                        _serde::export::Some(__field24) =>
                                        __field24,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("pinned")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                _serde::export::Ok(Status{id: __field0,
                                                          uri: __field1,
                                                          url: __field2,
                                                          account: __field3,
                                                          in_reply_to_id:
                                                              __field4,
                                                          in_reply_to_account_id:
                                                              __field5,
                                                          reblog: __field6,
                                                          content: __field7,
                                                          created_at:
                                                              __field8,
                                                          emojis: __field9,
                                                          replies_count:
                                                              __field10,
                                                          reblogs_count:
                                                              __field11,
                                                          favourites_count:
                                                              __field12,
                                                          reblogged:
                                                              __field13,
                                                          favourited:
                                                              __field14,
                                                          sensitive:
                                                              __field15,
                                                          spoiler_text:
                                                              __field16,
                                                          visibility:
                                                              __field17,
                                                          media_attachments:
                                                              __field18,
                                                          mentions: __field19,
                                                          tags: __field20,
                                                          card: __field21,
                                                          application:
                                                              __field22,
                                                          language: __field23,
                                                          pinned: __field24,})
                            }
                        }
                        const FIELDS: &'static [&'static str] =
                            &["id", "uri", "url", "account", "in_reply_to_id",
                              "in_reply_to_account_id", "reblog", "content",
                              "created_at", "emojis", "replies_count",
                              "reblogs_count", "favourites_count",
                              "reblogged", "favourited", "sensitive",
                              "spoiler_text", "visibility",
                              "media_attachments", "mentions", "tags", "card",
                              "application", "language", "pinned"];
                        _serde::Deserializer::deserialize_struct(__deserializer,
                                                                 "Status",
                                                                 FIELDS,
                                                                 __Visitor{marker:
                                                                               _serde::export::PhantomData::<Status>,
                                                                           lifetime:
                                                                               _serde::export::PhantomData,})
                    }
                }
            };
        impl ::core::marker::StructuralPartialEq for Status { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for Status {
            #[inline]
            fn eq(&self, other: &Status) -> bool {
                match *other {
                    Status {
                    id: ref __self_1_0,
                    uri: ref __self_1_1,
                    url: ref __self_1_2,
                    account: ref __self_1_3,
                    in_reply_to_id: ref __self_1_4,
                    in_reply_to_account_id: ref __self_1_5,
                    reblog: ref __self_1_6,
                    content: ref __self_1_7,
                    created_at: ref __self_1_8,
                    emojis: ref __self_1_9,
                    replies_count: ref __self_1_10,
                    reblogs_count: ref __self_1_11,
                    favourites_count: ref __self_1_12,
                    reblogged: ref __self_1_13,
                    favourited: ref __self_1_14,
                    sensitive: ref __self_1_15,
                    spoiler_text: ref __self_1_16,
                    visibility: ref __self_1_17,
                    media_attachments: ref __self_1_18,
                    mentions: ref __self_1_19,
                    tags: ref __self_1_20,
                    card: ref __self_1_21,
                    application: ref __self_1_22,
                    language: ref __self_1_23,
                    pinned: ref __self_1_24 } =>
                    match *self {
                        Status {
                        id: ref __self_0_0,
                        uri: ref __self_0_1,
                        url: ref __self_0_2,
                        account: ref __self_0_3,
                        in_reply_to_id: ref __self_0_4,
                        in_reply_to_account_id: ref __self_0_5,
                        reblog: ref __self_0_6,
                        content: ref __self_0_7,
                        created_at: ref __self_0_8,
                        emojis: ref __self_0_9,
                        replies_count: ref __self_0_10,
                        reblogs_count: ref __self_0_11,
                        favourites_count: ref __self_0_12,
                        reblogged: ref __self_0_13,
                        favourited: ref __self_0_14,
                        sensitive: ref __self_0_15,
                        spoiler_text: ref __self_0_16,
                        visibility: ref __self_0_17,
                        media_attachments: ref __self_0_18,
                        mentions: ref __self_0_19,
                        tags: ref __self_0_20,
                        card: ref __self_0_21,
                        application: ref __self_0_22,
                        language: ref __self_0_23,
                        pinned: ref __self_0_24 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1) &&
                            (*__self_0_2) == (*__self_1_2) &&
                            (*__self_0_3) == (*__self_1_3) &&
                            (*__self_0_4) == (*__self_1_4) &&
                            (*__self_0_5) == (*__self_1_5) &&
                            (*__self_0_6) == (*__self_1_6) &&
                            (*__self_0_7) == (*__self_1_7) &&
                            (*__self_0_8) == (*__self_1_8) &&
                            (*__self_0_9) == (*__self_1_9) &&
                            (*__self_0_10) == (*__self_1_10) &&
                            (*__self_0_11) == (*__self_1_11) &&
                            (*__self_0_12) == (*__self_1_12) &&
                            (*__self_0_13) == (*__self_1_13) &&
                            (*__self_0_14) == (*__self_1_14) &&
                            (*__self_0_15) == (*__self_1_15) &&
                            (*__self_0_16) == (*__self_1_16) &&
                            (*__self_0_17) == (*__self_1_17) &&
                            (*__self_0_18) == (*__self_1_18) &&
                            (*__self_0_19) == (*__self_1_19) &&
                            (*__self_0_20) == (*__self_1_20) &&
                            (*__self_0_21) == (*__self_1_21) &&
                            (*__self_0_22) == (*__self_1_22) &&
                            (*__self_0_23) == (*__self_1_23) &&
                            (*__self_0_24) == (*__self_1_24),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &Status) -> bool {
                match *other {
                    Status {
                    id: ref __self_1_0,
                    uri: ref __self_1_1,
                    url: ref __self_1_2,
                    account: ref __self_1_3,
                    in_reply_to_id: ref __self_1_4,
                    in_reply_to_account_id: ref __self_1_5,
                    reblog: ref __self_1_6,
                    content: ref __self_1_7,
                    created_at: ref __self_1_8,
                    emojis: ref __self_1_9,
                    replies_count: ref __self_1_10,
                    reblogs_count: ref __self_1_11,
                    favourites_count: ref __self_1_12,
                    reblogged: ref __self_1_13,
                    favourited: ref __self_1_14,
                    sensitive: ref __self_1_15,
                    spoiler_text: ref __self_1_16,
                    visibility: ref __self_1_17,
                    media_attachments: ref __self_1_18,
                    mentions: ref __self_1_19,
                    tags: ref __self_1_20,
                    card: ref __self_1_21,
                    application: ref __self_1_22,
                    language: ref __self_1_23,
                    pinned: ref __self_1_24 } =>
                    match *self {
                        Status {
                        id: ref __self_0_0,
                        uri: ref __self_0_1,
                        url: ref __self_0_2,
                        account: ref __self_0_3,
                        in_reply_to_id: ref __self_0_4,
                        in_reply_to_account_id: ref __self_0_5,
                        reblog: ref __self_0_6,
                        content: ref __self_0_7,
                        created_at: ref __self_0_8,
                        emojis: ref __self_0_9,
                        replies_count: ref __self_0_10,
                        reblogs_count: ref __self_0_11,
                        favourites_count: ref __self_0_12,
                        reblogged: ref __self_0_13,
                        favourited: ref __self_0_14,
                        sensitive: ref __self_0_15,
                        spoiler_text: ref __self_0_16,
                        visibility: ref __self_0_17,
                        media_attachments: ref __self_0_18,
                        mentions: ref __self_0_19,
                        tags: ref __self_0_20,
                        card: ref __self_0_21,
                        application: ref __self_0_22,
                        language: ref __self_0_23,
                        pinned: ref __self_0_24 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1) ||
                            (*__self_0_2) != (*__self_1_2) ||
                            (*__self_0_3) != (*__self_1_3) ||
                            (*__self_0_4) != (*__self_1_4) ||
                            (*__self_0_5) != (*__self_1_5) ||
                            (*__self_0_6) != (*__self_1_6) ||
                            (*__self_0_7) != (*__self_1_7) ||
                            (*__self_0_8) != (*__self_1_8) ||
                            (*__self_0_9) != (*__self_1_9) ||
                            (*__self_0_10) != (*__self_1_10) ||
                            (*__self_0_11) != (*__self_1_11) ||
                            (*__self_0_12) != (*__self_1_12) ||
                            (*__self_0_13) != (*__self_1_13) ||
                            (*__self_0_14) != (*__self_1_14) ||
                            (*__self_0_15) != (*__self_1_15) ||
                            (*__self_0_16) != (*__self_1_16) ||
                            (*__self_0_17) != (*__self_1_17) ||
                            (*__self_0_18) != (*__self_1_18) ||
                            (*__self_0_19) != (*__self_1_19) ||
                            (*__self_0_20) != (*__self_1_20) ||
                            (*__self_0_21) != (*__self_1_21) ||
                            (*__self_0_22) != (*__self_1_22) ||
                            (*__self_0_23) != (*__self_1_23) ||
                            (*__self_0_24) != (*__self_1_24),
                    },
                }
            }
        }
        /// A mention of another user.
        pub struct Mention {
            /// URL of user's profile (can be remote).
            pub url: String,
            /// The username of the account.
            pub username: String,
            /// Equals `username` for local users, includes `@domain` for remote ones.
            pub acct: String,
            /// Account ID.
            pub id: String,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for Mention {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    Mention {
                    url: ref __self_0_0,
                    username: ref __self_0_1,
                    acct: ref __self_0_2,
                    id: ref __self_0_3 } => {
                        let mut debug_trait_builder =
                            f.debug_struct("Mention");
                        let _ =
                            debug_trait_builder.field("url", &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("username",
                                                      &&(*__self_0_1));
                        let _ =
                            debug_trait_builder.field("acct",
                                                      &&(*__self_0_2));
                        let _ =
                            debug_trait_builder.field("id", &&(*__self_0_3));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for Mention {
            #[inline]
            fn clone(&self) -> Mention {
                match *self {
                    Mention {
                    url: ref __self_0_0,
                    username: ref __self_0_1,
                    acct: ref __self_0_2,
                    id: ref __self_0_3 } =>
                    Mention{url: ::core::clone::Clone::clone(&(*__self_0_0)),
                            username:
                                ::core::clone::Clone::clone(&(*__self_0_1)),
                            acct: ::core::clone::Clone::clone(&(*__self_0_2)),
                            id: ::core::clone::Clone::clone(&(*__self_0_3)),},
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_Mention: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'de> _serde::Deserialize<'de> for Mention {
                    fn deserialize<__D>(__deserializer: __D)
                     -> _serde::export::Result<Self, __D::Error> where
                     __D: _serde::Deserializer<'de> {
                        #[allow(non_camel_case_types)]
                        enum __Field {
                            __field0,
                            __field1,
                            __field2,
                            __field3,
                            __ignore,
                        }
                        struct __FieldVisitor;
                        impl <'de> _serde::de::Visitor<'de> for __FieldVisitor
                         {
                            type Value = __Field;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "field identifier")
                            }
                            fn visit_u64<__E>(self, __value: u64)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    0u64 =>
                                    _serde::export::Ok(__Field::__field0),
                                    1u64 =>
                                    _serde::export::Ok(__Field::__field1),
                                    2u64 =>
                                    _serde::export::Ok(__Field::__field2),
                                    3u64 =>
                                    _serde::export::Ok(__Field::__field3),
                                    _ =>
                                    _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                         &"field index 0 <= i < 4")),
                                }
                            }
                            fn visit_str<__E>(self, __value: &str)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    "url" =>
                                    _serde::export::Ok(__Field::__field0),
                                    "username" =>
                                    _serde::export::Ok(__Field::__field1),
                                    "acct" =>
                                    _serde::export::Ok(__Field::__field2),
                                    "id" =>
                                    _serde::export::Ok(__Field::__field3),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                            fn visit_bytes<__E>(self, __value: &[u8])
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    b"url" =>
                                    _serde::export::Ok(__Field::__field0),
                                    b"username" =>
                                    _serde::export::Ok(__Field::__field1),
                                    b"acct" =>
                                    _serde::export::Ok(__Field::__field2),
                                    b"id" =>
                                    _serde::export::Ok(__Field::__field3),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                        }
                        impl <'de> _serde::Deserialize<'de> for __Field {
                            #[inline]
                            fn deserialize<__D>(__deserializer: __D)
                             -> _serde::export::Result<Self, __D::Error> where
                             __D: _serde::Deserializer<'de> {
                                _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                             __FieldVisitor)
                            }
                        }
                        struct __Visitor<'de> {
                            marker: _serde::export::PhantomData<Mention>,
                            lifetime: _serde::export::PhantomData<&'de ()>,
                        }
                        impl <'de> _serde::de::Visitor<'de> for __Visitor<'de>
                         {
                            type Value = Mention;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "struct Mention")
                            }
                            #[inline]
                            fn visit_seq<__A>(self, mut __seq: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::SeqAccess<'de> {
                                let __field0 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                         &"struct Mention with 4 elements"));
                                        }
                                    };
                                let __field1 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(1usize,
                                                                                                         &"struct Mention with 4 elements"));
                                        }
                                    };
                                let __field2 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(2usize,
                                                                                                         &"struct Mention with 4 elements"));
                                        }
                                    };
                                let __field3 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(3usize,
                                                                                                         &"struct Mention with 4 elements"));
                                        }
                                    };
                                _serde::export::Ok(Mention{url: __field0,
                                                           username: __field1,
                                                           acct: __field2,
                                                           id: __field3,})
                            }
                            #[inline]
                            fn visit_map<__A>(self, mut __map: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::MapAccess<'de> {
                                let mut __field0:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field1:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field2:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field3:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                while let _serde::export::Some(__key) =
                                          match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                    match __key {
                                        __Field::__field0 => {
                                            if _serde::export::Option::is_some(&__field0)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("url"));
                                            }
                                            __field0 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field1 => {
                                            if _serde::export::Option::is_some(&__field1)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("username"));
                                            }
                                            __field1 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field2 => {
                                            if _serde::export::Option::is_some(&__field2)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("acct"));
                                            }
                                            __field2 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field3 => {
                                            if _serde::export::Option::is_some(&__field3)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("id"));
                                            }
                                            __field3 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        _ => {
                                            let _ =
                                                match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                    {
                                                    _serde::export::Ok(__val)
                                                    => __val,
                                                    _serde::export::Err(__err)
                                                    => {
                                                        return _serde::export::Err(__err);
                                                    }
                                                };
                                        }
                                    }
                                }
                                let __field0 =
                                    match __field0 {
                                        _serde::export::Some(__field0) =>
                                        __field0,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("url")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field1 =
                                    match __field1 {
                                        _serde::export::Some(__field1) =>
                                        __field1,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("username")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field2 =
                                    match __field2 {
                                        _serde::export::Some(__field2) =>
                                        __field2,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("acct")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field3 =
                                    match __field3 {
                                        _serde::export::Some(__field3) =>
                                        __field3,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("id")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                _serde::export::Ok(Mention{url: __field0,
                                                           username: __field1,
                                                           acct: __field2,
                                                           id: __field3,})
                            }
                        }
                        const FIELDS: &'static [&'static str] =
                            &["url", "username", "acct", "id"];
                        _serde::Deserializer::deserialize_struct(__deserializer,
                                                                 "Mention",
                                                                 FIELDS,
                                                                 __Visitor{marker:
                                                                               _serde::export::PhantomData::<Mention>,
                                                                           lifetime:
                                                                               _serde::export::PhantomData,})
                    }
                }
            };
        impl ::core::marker::StructuralPartialEq for Mention { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for Mention {
            #[inline]
            fn eq(&self, other: &Mention) -> bool {
                match *other {
                    Mention {
                    url: ref __self_1_0,
                    username: ref __self_1_1,
                    acct: ref __self_1_2,
                    id: ref __self_1_3 } =>
                    match *self {
                        Mention {
                        url: ref __self_0_0,
                        username: ref __self_0_1,
                        acct: ref __self_0_2,
                        id: ref __self_0_3 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1) &&
                            (*__self_0_2) == (*__self_1_2) &&
                            (*__self_0_3) == (*__self_1_3),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &Mention) -> bool {
                match *other {
                    Mention {
                    url: ref __self_1_0,
                    username: ref __self_1_1,
                    acct: ref __self_1_2,
                    id: ref __self_1_3 } =>
                    match *self {
                        Mention {
                        url: ref __self_0_0,
                        username: ref __self_0_1,
                        acct: ref __self_0_2,
                        id: ref __self_0_3 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1) ||
                            (*__self_0_2) != (*__self_1_2) ||
                            (*__self_0_3) != (*__self_1_3),
                    },
                }
            }
        }
        /// Struct representing an emoji within text.
        pub struct Emoji {
            /// The shortcode of the emoji
            pub shortcode: String,
            /// URL to the emoji static image
            pub static_url: String,
            /// URL to the emoji image
            pub url: String,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for Emoji {
            #[inline]
            fn clone(&self) -> Emoji {
                match *self {
                    Emoji {
                    shortcode: ref __self_0_0,
                    static_url: ref __self_0_1,
                    url: ref __self_0_2 } =>
                    Emoji{shortcode:
                              ::core::clone::Clone::clone(&(*__self_0_0)),
                          static_url:
                              ::core::clone::Clone::clone(&(*__self_0_1)),
                          url: ::core::clone::Clone::clone(&(*__self_0_2)),},
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for Emoji {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    Emoji {
                    shortcode: ref __self_0_0,
                    static_url: ref __self_0_1,
                    url: ref __self_0_2 } => {
                        let mut debug_trait_builder = f.debug_struct("Emoji");
                        let _ =
                            debug_trait_builder.field("shortcode",
                                                      &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("static_url",
                                                      &&(*__self_0_1));
                        let _ =
                            debug_trait_builder.field("url", &&(*__self_0_2));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_Emoji: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'de> _serde::Deserialize<'de> for Emoji {
                    fn deserialize<__D>(__deserializer: __D)
                     -> _serde::export::Result<Self, __D::Error> where
                     __D: _serde::Deserializer<'de> {
                        #[allow(non_camel_case_types)]
                        enum __Field {
                            __field0,
                            __field1,
                            __field2,
                            __ignore,
                        }
                        struct __FieldVisitor;
                        impl <'de> _serde::de::Visitor<'de> for __FieldVisitor
                         {
                            type Value = __Field;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "field identifier")
                            }
                            fn visit_u64<__E>(self, __value: u64)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    0u64 =>
                                    _serde::export::Ok(__Field::__field0),
                                    1u64 =>
                                    _serde::export::Ok(__Field::__field1),
                                    2u64 =>
                                    _serde::export::Ok(__Field::__field2),
                                    _ =>
                                    _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                         &"field index 0 <= i < 3")),
                                }
                            }
                            fn visit_str<__E>(self, __value: &str)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    "shortcode" =>
                                    _serde::export::Ok(__Field::__field0),
                                    "static_url" =>
                                    _serde::export::Ok(__Field::__field1),
                                    "url" =>
                                    _serde::export::Ok(__Field::__field2),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                            fn visit_bytes<__E>(self, __value: &[u8])
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    b"shortcode" =>
                                    _serde::export::Ok(__Field::__field0),
                                    b"static_url" =>
                                    _serde::export::Ok(__Field::__field1),
                                    b"url" =>
                                    _serde::export::Ok(__Field::__field2),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                        }
                        impl <'de> _serde::Deserialize<'de> for __Field {
                            #[inline]
                            fn deserialize<__D>(__deserializer: __D)
                             -> _serde::export::Result<Self, __D::Error> where
                             __D: _serde::Deserializer<'de> {
                                _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                             __FieldVisitor)
                            }
                        }
                        struct __Visitor<'de> {
                            marker: _serde::export::PhantomData<Emoji>,
                            lifetime: _serde::export::PhantomData<&'de ()>,
                        }
                        impl <'de> _serde::de::Visitor<'de> for __Visitor<'de>
                         {
                            type Value = Emoji;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "struct Emoji")
                            }
                            #[inline]
                            fn visit_seq<__A>(self, mut __seq: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::SeqAccess<'de> {
                                let __field0 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                         &"struct Emoji with 3 elements"));
                                        }
                                    };
                                let __field1 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(1usize,
                                                                                                         &"struct Emoji with 3 elements"));
                                        }
                                    };
                                let __field2 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(2usize,
                                                                                                         &"struct Emoji with 3 elements"));
                                        }
                                    };
                                _serde::export::Ok(Emoji{shortcode: __field0,
                                                         static_url: __field1,
                                                         url: __field2,})
                            }
                            #[inline]
                            fn visit_map<__A>(self, mut __map: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::MapAccess<'de> {
                                let mut __field0:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field1:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field2:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                while let _serde::export::Some(__key) =
                                          match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                    match __key {
                                        __Field::__field0 => {
                                            if _serde::export::Option::is_some(&__field0)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("shortcode"));
                                            }
                                            __field0 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field1 => {
                                            if _serde::export::Option::is_some(&__field1)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("static_url"));
                                            }
                                            __field1 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field2 => {
                                            if _serde::export::Option::is_some(&__field2)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("url"));
                                            }
                                            __field2 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        _ => {
                                            let _ =
                                                match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                    {
                                                    _serde::export::Ok(__val)
                                                    => __val,
                                                    _serde::export::Err(__err)
                                                    => {
                                                        return _serde::export::Err(__err);
                                                    }
                                                };
                                        }
                                    }
                                }
                                let __field0 =
                                    match __field0 {
                                        _serde::export::Some(__field0) =>
                                        __field0,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("shortcode")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field1 =
                                    match __field1 {
                                        _serde::export::Some(__field1) =>
                                        __field1,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("static_url")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field2 =
                                    match __field2 {
                                        _serde::export::Some(__field2) =>
                                        __field2,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("url")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                _serde::export::Ok(Emoji{shortcode: __field0,
                                                         static_url: __field1,
                                                         url: __field2,})
                            }
                        }
                        const FIELDS: &'static [&'static str] =
                            &["shortcode", "static_url", "url"];
                        _serde::Deserializer::deserialize_struct(__deserializer,
                                                                 "Emoji",
                                                                 FIELDS,
                                                                 __Visitor{marker:
                                                                               _serde::export::PhantomData::<Emoji>,
                                                                           lifetime:
                                                                               _serde::export::PhantomData,})
                    }
                }
            };
        impl ::core::marker::StructuralPartialEq for Emoji { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for Emoji {
            #[inline]
            fn eq(&self, other: &Emoji) -> bool {
                match *other {
                    Emoji {
                    shortcode: ref __self_1_0,
                    static_url: ref __self_1_1,
                    url: ref __self_1_2 } =>
                    match *self {
                        Emoji {
                        shortcode: ref __self_0_0,
                        static_url: ref __self_0_1,
                        url: ref __self_0_2 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1) &&
                            (*__self_0_2) == (*__self_1_2),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &Emoji) -> bool {
                match *other {
                    Emoji {
                    shortcode: ref __self_1_0,
                    static_url: ref __self_1_1,
                    url: ref __self_1_2 } =>
                    match *self {
                        Emoji {
                        shortcode: ref __self_0_0,
                        static_url: ref __self_0_1,
                        url: ref __self_0_2 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1) ||
                            (*__self_0_2) != (*__self_1_2),
                    },
                }
            }
        }
        /// Hashtags in the status.
        pub struct Tag {
            /// The hashtag, not including the preceding `#`.
            pub name: String,
            /// The URL of the hashtag.
            pub url: String,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for Tag {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    Tag { name: ref __self_0_0, url: ref __self_0_1 } => {
                        let mut debug_trait_builder = f.debug_struct("Tag");
                        let _ =
                            debug_trait_builder.field("name",
                                                      &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("url", &&(*__self_0_1));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for Tag {
            #[inline]
            fn clone(&self) -> Tag {
                match *self {
                    Tag { name: ref __self_0_0, url: ref __self_0_1 } =>
                    Tag{name: ::core::clone::Clone::clone(&(*__self_0_0)),
                        url: ::core::clone::Clone::clone(&(*__self_0_1)),},
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_Tag: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'de> _serde::Deserialize<'de> for Tag {
                    fn deserialize<__D>(__deserializer: __D)
                     -> _serde::export::Result<Self, __D::Error> where
                     __D: _serde::Deserializer<'de> {
                        #[allow(non_camel_case_types)]
                        enum __Field { __field0, __field1, __ignore, }
                        struct __FieldVisitor;
                        impl <'de> _serde::de::Visitor<'de> for __FieldVisitor
                         {
                            type Value = __Field;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "field identifier")
                            }
                            fn visit_u64<__E>(self, __value: u64)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    0u64 =>
                                    _serde::export::Ok(__Field::__field0),
                                    1u64 =>
                                    _serde::export::Ok(__Field::__field1),
                                    _ =>
                                    _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                         &"field index 0 <= i < 2")),
                                }
                            }
                            fn visit_str<__E>(self, __value: &str)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    "name" =>
                                    _serde::export::Ok(__Field::__field0),
                                    "url" =>
                                    _serde::export::Ok(__Field::__field1),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                            fn visit_bytes<__E>(self, __value: &[u8])
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    b"name" =>
                                    _serde::export::Ok(__Field::__field0),
                                    b"url" =>
                                    _serde::export::Ok(__Field::__field1),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                        }
                        impl <'de> _serde::Deserialize<'de> for __Field {
                            #[inline]
                            fn deserialize<__D>(__deserializer: __D)
                             -> _serde::export::Result<Self, __D::Error> where
                             __D: _serde::Deserializer<'de> {
                                _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                             __FieldVisitor)
                            }
                        }
                        struct __Visitor<'de> {
                            marker: _serde::export::PhantomData<Tag>,
                            lifetime: _serde::export::PhantomData<&'de ()>,
                        }
                        impl <'de> _serde::de::Visitor<'de> for __Visitor<'de>
                         {
                            type Value = Tag;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "struct Tag")
                            }
                            #[inline]
                            fn visit_seq<__A>(self, mut __seq: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::SeqAccess<'de> {
                                let __field0 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                         &"struct Tag with 2 elements"));
                                        }
                                    };
                                let __field1 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(1usize,
                                                                                                         &"struct Tag with 2 elements"));
                                        }
                                    };
                                _serde::export::Ok(Tag{name: __field0,
                                                       url: __field1,})
                            }
                            #[inline]
                            fn visit_map<__A>(self, mut __map: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::MapAccess<'de> {
                                let mut __field0:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field1:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                while let _serde::export::Some(__key) =
                                          match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                    match __key {
                                        __Field::__field0 => {
                                            if _serde::export::Option::is_some(&__field0)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("name"));
                                            }
                                            __field0 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field1 => {
                                            if _serde::export::Option::is_some(&__field1)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("url"));
                                            }
                                            __field1 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        _ => {
                                            let _ =
                                                match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                    {
                                                    _serde::export::Ok(__val)
                                                    => __val,
                                                    _serde::export::Err(__err)
                                                    => {
                                                        return _serde::export::Err(__err);
                                                    }
                                                };
                                        }
                                    }
                                }
                                let __field0 =
                                    match __field0 {
                                        _serde::export::Some(__field0) =>
                                        __field0,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("name")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field1 =
                                    match __field1 {
                                        _serde::export::Some(__field1) =>
                                        __field1,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("url")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                _serde::export::Ok(Tag{name: __field0,
                                                       url: __field1,})
                            }
                        }
                        const FIELDS: &'static [&'static str] =
                            &["name", "url"];
                        _serde::Deserializer::deserialize_struct(__deserializer,
                                                                 "Tag",
                                                                 FIELDS,
                                                                 __Visitor{marker:
                                                                               _serde::export::PhantomData::<Tag>,
                                                                           lifetime:
                                                                               _serde::export::PhantomData,})
                    }
                }
            };
        impl ::core::marker::StructuralPartialEq for Tag { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for Tag {
            #[inline]
            fn eq(&self, other: &Tag) -> bool {
                match *other {
                    Tag { name: ref __self_1_0, url: ref __self_1_1 } =>
                    match *self {
                        Tag { name: ref __self_0_0, url: ref __self_0_1 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &Tag) -> bool {
                match *other {
                    Tag { name: ref __self_1_0, url: ref __self_1_1 } =>
                    match *self {
                        Tag { name: ref __self_0_0, url: ref __self_0_1 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1),
                    },
                }
            }
        }
        /// Application details.
        pub struct Application {
            /// Name of the application.
            pub name: String,
            /// Homepage URL of the application.
            pub website: Option<String>,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for Application {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    Application {
                    name: ref __self_0_0, website: ref __self_0_1 } => {
                        let mut debug_trait_builder =
                            f.debug_struct("Application");
                        let _ =
                            debug_trait_builder.field("name",
                                                      &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("website",
                                                      &&(*__self_0_1));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for Application {
            #[inline]
            fn clone(&self) -> Application {
                match *self {
                    Application {
                    name: ref __self_0_0, website: ref __self_0_1 } =>
                    Application{name:
                                    ::core::clone::Clone::clone(&(*__self_0_0)),
                                website:
                                    ::core::clone::Clone::clone(&(*__self_0_1)),},
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_Application: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'de> _serde::Deserialize<'de> for Application {
                    fn deserialize<__D>(__deserializer: __D)
                     -> _serde::export::Result<Self, __D::Error> where
                     __D: _serde::Deserializer<'de> {
                        #[allow(non_camel_case_types)]
                        enum __Field { __field0, __field1, __ignore, }
                        struct __FieldVisitor;
                        impl <'de> _serde::de::Visitor<'de> for __FieldVisitor
                         {
                            type Value = __Field;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "field identifier")
                            }
                            fn visit_u64<__E>(self, __value: u64)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    0u64 =>
                                    _serde::export::Ok(__Field::__field0),
                                    1u64 =>
                                    _serde::export::Ok(__Field::__field1),
                                    _ =>
                                    _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                         &"field index 0 <= i < 2")),
                                }
                            }
                            fn visit_str<__E>(self, __value: &str)
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    "name" =>
                                    _serde::export::Ok(__Field::__field0),
                                    "website" =>
                                    _serde::export::Ok(__Field::__field1),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                            fn visit_bytes<__E>(self, __value: &[u8])
                             -> _serde::export::Result<Self::Value, __E> where
                             __E: _serde::de::Error {
                                match __value {
                                    b"name" =>
                                    _serde::export::Ok(__Field::__field0),
                                    b"website" =>
                                    _serde::export::Ok(__Field::__field1),
                                    _ => {
                                        _serde::export::Ok(__Field::__ignore)
                                    }
                                }
                            }
                        }
                        impl <'de> _serde::Deserialize<'de> for __Field {
                            #[inline]
                            fn deserialize<__D>(__deserializer: __D)
                             -> _serde::export::Result<Self, __D::Error> where
                             __D: _serde::Deserializer<'de> {
                                _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                             __FieldVisitor)
                            }
                        }
                        struct __Visitor<'de> {
                            marker: _serde::export::PhantomData<Application>,
                            lifetime: _serde::export::PhantomData<&'de ()>,
                        }
                        impl <'de> _serde::de::Visitor<'de> for __Visitor<'de>
                         {
                            type Value = Application;
                            fn expecting(&self,
                                         __formatter:
                                             &mut _serde::export::Formatter)
                             -> _serde::export::fmt::Result {
                                _serde::export::Formatter::write_str(__formatter,
                                                                     "struct Application")
                            }
                            #[inline]
                            fn visit_seq<__A>(self, mut __seq: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::SeqAccess<'de> {
                                let __field0 =
                                    match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                         &"struct Application with 2 elements"));
                                        }
                                    };
                                let __field1 =
                                    match match _serde::de::SeqAccess::next_element::<Option<String>>(&mut __seq)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                        _serde::export::Some(__value) =>
                                        __value,
                                        _serde::export::None => {
                                            return _serde::export::Err(_serde::de::Error::invalid_length(1usize,
                                                                                                         &"struct Application with 2 elements"));
                                        }
                                    };
                                _serde::export::Ok(Application{name: __field0,
                                                               website:
                                                                   __field1,})
                            }
                            #[inline]
                            fn visit_map<__A>(self, mut __map: __A)
                             ->
                                 _serde::export::Result<Self::Value,
                                                        __A::Error> where
                             __A: _serde::de::MapAccess<'de> {
                                let mut __field0:
                                        _serde::export::Option<String> =
                                    _serde::export::None;
                                let mut __field1:
                                        _serde::export::Option<Option<String>> =
                                    _serde::export::None;
                                while let _serde::export::Some(__key) =
                                          match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                              {
                                              _serde::export::Ok(__val) =>
                                              __val,
                                              _serde::export::Err(__err) => {
                                                  return _serde::export::Err(__err);
                                              }
                                          } {
                                    match __key {
                                        __Field::__field0 => {
                                            if _serde::export::Option::is_some(&__field0)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("name"));
                                            }
                                            __field0 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        __Field::__field1 => {
                                            if _serde::export::Option::is_some(&__field1)
                                               {
                                                return _serde::export::Err(<__A::Error
                                                                               as
                                                                               _serde::de::Error>::duplicate_field("website"));
                                            }
                                            __field1 =
                                                _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<String>>(&mut __map)
                                                                         {
                                                                         _serde::export::Ok(__val)
                                                                         =>
                                                                         __val,
                                                                         _serde::export::Err(__err)
                                                                         => {
                                                                             return _serde::export::Err(__err);
                                                                         }
                                                                     });
                                        }
                                        _ => {
                                            let _ =
                                                match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                    {
                                                    _serde::export::Ok(__val)
                                                    => __val,
                                                    _serde::export::Err(__err)
                                                    => {
                                                        return _serde::export::Err(__err);
                                                    }
                                                };
                                        }
                                    }
                                }
                                let __field0 =
                                    match __field0 {
                                        _serde::export::Some(__field0) =>
                                        __field0,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("name")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                let __field1 =
                                    match __field1 {
                                        _serde::export::Some(__field1) =>
                                        __field1,
                                        _serde::export::None =>
                                        match _serde::private::de::missing_field("website")
                                            {
                                            _serde::export::Ok(__val) =>
                                            __val,
                                            _serde::export::Err(__err) => {
                                                return _serde::export::Err(__err);
                                            }
                                        },
                                    };
                                _serde::export::Ok(Application{name: __field0,
                                                               website:
                                                                   __field1,})
                            }
                        }
                        const FIELDS: &'static [&'static str] =
                            &["name", "website"];
                        _serde::Deserializer::deserialize_struct(__deserializer,
                                                                 "Application",
                                                                 FIELDS,
                                                                 __Visitor{marker:
                                                                               _serde::export::PhantomData::<Application>,
                                                                           lifetime:
                                                                               _serde::export::PhantomData,})
                    }
                }
            };
        impl ::core::marker::StructuralPartialEq for Application { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for Application {
            #[inline]
            fn eq(&self, other: &Application) -> bool {
                match *other {
                    Application {
                    name: ref __self_1_0, website: ref __self_1_1 } =>
                    match *self {
                        Application {
                        name: ref __self_0_0, website: ref __self_0_1 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &Application) -> bool {
                match *other {
                    Application {
                    name: ref __self_1_0, website: ref __self_1_1 } =>
                    match *self {
                        Application {
                        name: ref __self_0_0, website: ref __self_0_1 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1),
                    },
                }
            }
        }
    }
    /// An empty JSON object.
    pub struct Empty {
    }
    #[doc(hidden)]
    #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
    const _IMPL_DESERIALIZE_FOR_Empty: () =
        {
            #[allow(rust_2018_idioms, clippy :: useless_attribute)]
            extern crate serde as _serde;
            #[allow(unused_macros)]
            macro_rules! try {
                ($ __expr : expr) =>
                {
                    match $ __expr
                    {
                        _serde :: export :: Ok(__val) => __val, _serde ::
                        export :: Err(__err) =>
                        { return _serde :: export :: Err(__err) ; }
                    }
                }
            }
            #[automatically_derived]
            impl <'de> _serde::Deserialize<'de> for Empty {
                fn deserialize<__D>(__deserializer: __D)
                 -> _serde::export::Result<Self, __D::Error> where
                 __D: _serde::Deserializer<'de> {
                    #[allow(non_camel_case_types)]
                    enum __Field { __ignore, }
                    struct __FieldVisitor;
                    impl <'de> _serde::de::Visitor<'de> for __FieldVisitor {
                        type Value = __Field;
                        fn expecting(&self,
                                     __formatter:
                                         &mut _serde::export::Formatter)
                         -> _serde::export::fmt::Result {
                            _serde::export::Formatter::write_str(__formatter,
                                                                 "field identifier")
                        }
                        fn visit_u64<__E>(self, __value: u64)
                         -> _serde::export::Result<Self::Value, __E> where
                         __E: _serde::de::Error {
                            match __value {
                                _ =>
                                _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                     &"field index 0 <= i < 0")),
                            }
                        }
                        fn visit_str<__E>(self, __value: &str)
                         -> _serde::export::Result<Self::Value, __E> where
                         __E: _serde::de::Error {
                            match __value {
                                _ => { _serde::export::Ok(__Field::__ignore) }
                            }
                        }
                        fn visit_bytes<__E>(self, __value: &[u8])
                         -> _serde::export::Result<Self::Value, __E> where
                         __E: _serde::de::Error {
                            match __value {
                                _ => { _serde::export::Ok(__Field::__ignore) }
                            }
                        }
                    }
                    impl <'de> _serde::Deserialize<'de> for __Field {
                        #[inline]
                        fn deserialize<__D>(__deserializer: __D)
                         -> _serde::export::Result<Self, __D::Error> where
                         __D: _serde::Deserializer<'de> {
                            _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                         __FieldVisitor)
                        }
                    }
                    struct __Visitor<'de> {
                        marker: _serde::export::PhantomData<Empty>,
                        lifetime: _serde::export::PhantomData<&'de ()>,
                    }
                    impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> {
                        type Value = Empty;
                        fn expecting(&self,
                                     __formatter:
                                         &mut _serde::export::Formatter)
                         -> _serde::export::fmt::Result {
                            _serde::export::Formatter::write_str(__formatter,
                                                                 "struct Empty")
                        }
                        #[inline]
                        fn visit_seq<__A>(self, _: __A)
                         -> _serde::export::Result<Self::Value, __A::Error>
                         where __A: _serde::de::SeqAccess<'de> {
                            _serde::export::Ok(Empty{})
                        }
                        #[inline]
                        fn visit_map<__A>(self, mut __map: __A)
                         -> _serde::export::Result<Self::Value, __A::Error>
                         where __A: _serde::de::MapAccess<'de> {
                            while let _serde::export::Some(__key) =
                                      match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                          {
                                          _serde::export::Ok(__val) => __val,
                                          _serde::export::Err(__err) => {
                                              return _serde::export::Err(__err);
                                          }
                                      } {
                                match __key {
                                    _ => {
                                        let _ =
                                            match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                {
                                                _serde::export::Ok(__val) =>
                                                __val,
                                                _serde::export::Err(__err) =>
                                                {
                                                    return _serde::export::Err(__err);
                                                }
                                            };
                                    }
                                }
                            }
                            _serde::export::Ok(Empty{})
                        }
                    }
                    const FIELDS: &'static [&'static str] = &[];
                    _serde::Deserializer::deserialize_struct(__deserializer,
                                                             "Empty", FIELDS,
                                                             __Visitor{marker:
                                                                           _serde::export::PhantomData::<Empty>,
                                                                       lifetime:
                                                                           _serde::export::PhantomData,})
                }
            }
        };
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::fmt::Debug for Empty {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            match *self {
                Empty {  } => {
                    let mut debug_trait_builder = f.debug_struct("Empty");
                    debug_trait_builder.finish()
                }
            }
        }
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::marker::Copy for Empty { }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::clone::Clone for Empty {
        #[inline]
        fn clone(&self) -> Empty { { *self } }
    }
    impl ::core::marker::StructuralPartialEq for Empty { }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::cmp::PartialEq for Empty {
        #[inline]
        fn eq(&self, other: &Empty) -> bool {
            match *other {
                Empty {  } => match *self { Empty {  } => true, },
            }
        }
    }
    /// The purpose of this module is to alleviate imports of many common
    /// structs by adding a glob import to the top of mastodon heavy
    /// modules:
    pub mod prelude {
        pub use super::{account::{Account, Source},
                        attachment::{Attachment, MediaType}, card::Card,
                        context::Context, event::Event,
                        filter::{Filter, FilterContext}, instance::*,
                        list::List, mention::Mention,
                        notification::Notification, push::Subscription,
                        relationship::Relationship, report::Report,
                        search_result::{SearchResult, SearchResultV2},
                        status::{Application, Emoji, Status}, Empty};
    }
}
/// Errors
pub mod errors {
    use std::{error, fmt, io::Error as IoError};
    use hyper_old_types::Error as HeaderParseError;
    use reqwest::{header::ToStrError as HeaderStrError, Error as HttpError,
                  StatusCode};
    use serde_json::Error as SerdeError;
    use serde_qs::Error as SerdeQsError;
    use serde_urlencoded::ser::Error as UrlEncodedError;
    use url::ParseError as UrlError;
    use tungstenite::error::Error as WebSocketError;
    /// Convience type over `std::result::Result` with `Error` as the error type.
    pub type Result<T> = ::std::result::Result<T, Error>;
    /// enum of possible errors encountered using the mastodon API.
    pub enum Error {

        /// Error from the Mastodon API. This typically means something went
        /// wrong with your authentication or data.
        Api(ApiError),

        /// Error deserialising to json. Typically represents a breaking change in
        /// the Mastodon API
        Serde(SerdeError),

        /// Error serializing to url-encoded string
        UrlEncoded(UrlEncodedError),

        /// Error encountered in the HTTP backend while requesting a route.
        Http(HttpError),

        /// Wrapper around the `std::io::Error` struct.
        Io(IoError),

        /// Wrapper around the `url::ParseError` struct.
        Url(UrlError),

        /// Missing Client Id.
        ClientIdRequired,

        /// Missing Client Secret.
        ClientSecretRequired,

        /// Missing Access Token.
        AccessTokenRequired,

        /// Generic client error.
        Client(StatusCode),

        /// Generic server error.
        Server(StatusCode),

        /// MastodonBuilder & AppBuilder error
        MissingField(&'static str),

        /// Error converting an http header to a string
        HeaderStrError(HeaderStrError),

        /// Error parsing the http Link header
        HeaderParseError(HeaderParseError),

        /// Error serializing to a query string
        SerdeQs(SerdeQsError),

        /// WebSocket error
        WebSocket(WebSocketError),

        /// Other errors
        Other(String),
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::fmt::Debug for Error {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            match (&*self,) {
                (&Error::Api(ref __self_0),) => {
                    let mut debug_trait_builder = f.debug_tuple("Api");
                    let _ = debug_trait_builder.field(&&(*__self_0));
                    debug_trait_builder.finish()
                }
                (&Error::Serde(ref __self_0),) => {
                    let mut debug_trait_builder = f.debug_tuple("Serde");
                    let _ = debug_trait_builder.field(&&(*__self_0));
                    debug_trait_builder.finish()
                }
                (&Error::UrlEncoded(ref __self_0),) => {
                    let mut debug_trait_builder = f.debug_tuple("UrlEncoded");
                    let _ = debug_trait_builder.field(&&(*__self_0));
                    debug_trait_builder.finish()
                }
                (&Error::Http(ref __self_0),) => {
                    let mut debug_trait_builder = f.debug_tuple("Http");
                    let _ = debug_trait_builder.field(&&(*__self_0));
                    debug_trait_builder.finish()
                }
                (&Error::Io(ref __self_0),) => {
                    let mut debug_trait_builder = f.debug_tuple("Io");
                    let _ = debug_trait_builder.field(&&(*__self_0));
                    debug_trait_builder.finish()
                }
                (&Error::Url(ref __self_0),) => {
                    let mut debug_trait_builder = f.debug_tuple("Url");
                    let _ = debug_trait_builder.field(&&(*__self_0));
                    debug_trait_builder.finish()
                }
                (&Error::ClientIdRequired,) => {
                    let mut debug_trait_builder =
                        f.debug_tuple("ClientIdRequired");
                    debug_trait_builder.finish()
                }
                (&Error::ClientSecretRequired,) => {
                    let mut debug_trait_builder =
                        f.debug_tuple("ClientSecretRequired");
                    debug_trait_builder.finish()
                }
                (&Error::AccessTokenRequired,) => {
                    let mut debug_trait_builder =
                        f.debug_tuple("AccessTokenRequired");
                    debug_trait_builder.finish()
                }
                (&Error::Client(ref __self_0),) => {
                    let mut debug_trait_builder = f.debug_tuple("Client");
                    let _ = debug_trait_builder.field(&&(*__self_0));
                    debug_trait_builder.finish()
                }
                (&Error::Server(ref __self_0),) => {
                    let mut debug_trait_builder = f.debug_tuple("Server");
                    let _ = debug_trait_builder.field(&&(*__self_0));
                    debug_trait_builder.finish()
                }
                (&Error::MissingField(ref __self_0),) => {
                    let mut debug_trait_builder =
                        f.debug_tuple("MissingField");
                    let _ = debug_trait_builder.field(&&(*__self_0));
                    debug_trait_builder.finish()
                }
                (&Error::HeaderStrError(ref __self_0),) => {
                    let mut debug_trait_builder =
                        f.debug_tuple("HeaderStrError");
                    let _ = debug_trait_builder.field(&&(*__self_0));
                    debug_trait_builder.finish()
                }
                (&Error::HeaderParseError(ref __self_0),) => {
                    let mut debug_trait_builder =
                        f.debug_tuple("HeaderParseError");
                    let _ = debug_trait_builder.field(&&(*__self_0));
                    debug_trait_builder.finish()
                }
                (&Error::SerdeQs(ref __self_0),) => {
                    let mut debug_trait_builder = f.debug_tuple("SerdeQs");
                    let _ = debug_trait_builder.field(&&(*__self_0));
                    debug_trait_builder.finish()
                }
                (&Error::WebSocket(ref __self_0),) => {
                    let mut debug_trait_builder = f.debug_tuple("WebSocket");
                    let _ = debug_trait_builder.field(&&(*__self_0));
                    debug_trait_builder.finish()
                }
                (&Error::Other(ref __self_0),) => {
                    let mut debug_trait_builder = f.debug_tuple("Other");
                    let _ = debug_trait_builder.field(&&(*__self_0));
                    debug_trait_builder.finish()
                }
            }
        }
    }
    impl fmt::Display for Error {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            f.write_fmt(::core::fmt::Arguments::new_v1(&[""],
                                                       &match (&self,) {
                                                            (arg0,) =>
                                                            [::core::fmt::ArgumentV1::new(arg0,
                                                                                          ::core::fmt::Debug::fmt)],
                                                        }))
        }
    }
    impl error::Error for Error {
        fn source(&self) -> Option<&(dyn error::Error + 'static)> {
            Some(match *self {
                     Error::Api(ref e) => e,
                     Error::Serde(ref e) => e,
                     Error::UrlEncoded(ref e) => e,
                     Error::Http(ref e) => e,
                     Error::Io(ref e) => e,
                     Error::Url(ref e) => e,
                     Error::HeaderStrError(ref e) => e,
                     Error::HeaderParseError(ref e) => e,
                     Error::SerdeQs(ref e) => e,
                     Error::WebSocket(ref e) => e,
                     Error::Client(..) | Error::Server(..) => { return None }
                     Error::ClientIdRequired => return None,
                     Error::ClientSecretRequired => return None,
                     Error::AccessTokenRequired => return None,
                     Error::MissingField(_) => return None,
                     Error::Other(..) => return None,
                 })
        }
    }
    /// Error returned from the Mastodon API.
    pub struct ApiError {
        /// The type of error.
        pub error: Option<String>,
        /// The description of the error.
        pub error_description: Option<String>,
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::clone::Clone for ApiError {
        #[inline]
        fn clone(&self) -> ApiError {
            match *self {
                ApiError {
                error: ref __self_0_0, error_description: ref __self_0_1 } =>
                ApiError{error: ::core::clone::Clone::clone(&(*__self_0_0)),
                         error_description:
                             ::core::clone::Clone::clone(&(*__self_0_1)),},
            }
        }
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::fmt::Debug for ApiError {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            match *self {
                ApiError {
                error: ref __self_0_0, error_description: ref __self_0_1 } =>
                {
                    let mut debug_trait_builder = f.debug_struct("ApiError");
                    let _ =
                        debug_trait_builder.field("error", &&(*__self_0_0));
                    let _ =
                        debug_trait_builder.field("error_description",
                                                  &&(*__self_0_1));
                    debug_trait_builder.finish()
                }
            }
        }
    }
    #[doc(hidden)]
    #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
    const _IMPL_DESERIALIZE_FOR_ApiError: () =
        {
            #[allow(rust_2018_idioms, clippy :: useless_attribute)]
            extern crate serde as _serde;
            #[allow(unused_macros)]
            macro_rules! try {
                ($ __expr : expr) =>
                {
                    match $ __expr
                    {
                        _serde :: export :: Ok(__val) => __val, _serde ::
                        export :: Err(__err) =>
                        { return _serde :: export :: Err(__err) ; }
                    }
                }
            }
            #[automatically_derived]
            impl <'de> _serde::Deserialize<'de> for ApiError {
                fn deserialize<__D>(__deserializer: __D)
                 -> _serde::export::Result<Self, __D::Error> where
                 __D: _serde::Deserializer<'de> {
                    #[allow(non_camel_case_types)]
                    enum __Field { __field0, __field1, __ignore, }
                    struct __FieldVisitor;
                    impl <'de> _serde::de::Visitor<'de> for __FieldVisitor {
                        type Value = __Field;
                        fn expecting(&self,
                                     __formatter:
                                         &mut _serde::export::Formatter)
                         -> _serde::export::fmt::Result {
                            _serde::export::Formatter::write_str(__formatter,
                                                                 "field identifier")
                        }
                        fn visit_u64<__E>(self, __value: u64)
                         -> _serde::export::Result<Self::Value, __E> where
                         __E: _serde::de::Error {
                            match __value {
                                0u64 => _serde::export::Ok(__Field::__field0),
                                1u64 => _serde::export::Ok(__Field::__field1),
                                _ =>
                                _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                     &"field index 0 <= i < 2")),
                            }
                        }
                        fn visit_str<__E>(self, __value: &str)
                         -> _serde::export::Result<Self::Value, __E> where
                         __E: _serde::de::Error {
                            match __value {
                                "error" =>
                                _serde::export::Ok(__Field::__field0),
                                "error_description" =>
                                _serde::export::Ok(__Field::__field1),
                                _ => { _serde::export::Ok(__Field::__ignore) }
                            }
                        }
                        fn visit_bytes<__E>(self, __value: &[u8])
                         -> _serde::export::Result<Self::Value, __E> where
                         __E: _serde::de::Error {
                            match __value {
                                b"error" =>
                                _serde::export::Ok(__Field::__field0),
                                b"error_description" =>
                                _serde::export::Ok(__Field::__field1),
                                _ => { _serde::export::Ok(__Field::__ignore) }
                            }
                        }
                    }
                    impl <'de> _serde::Deserialize<'de> for __Field {
                        #[inline]
                        fn deserialize<__D>(__deserializer: __D)
                         -> _serde::export::Result<Self, __D::Error> where
                         __D: _serde::Deserializer<'de> {
                            _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                         __FieldVisitor)
                        }
                    }
                    struct __Visitor<'de> {
                        marker: _serde::export::PhantomData<ApiError>,
                        lifetime: _serde::export::PhantomData<&'de ()>,
                    }
                    impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> {
                        type Value = ApiError;
                        fn expecting(&self,
                                     __formatter:
                                         &mut _serde::export::Formatter)
                         -> _serde::export::fmt::Result {
                            _serde::export::Formatter::write_str(__formatter,
                                                                 "struct ApiError")
                        }
                        #[inline]
                        fn visit_seq<__A>(self, mut __seq: __A)
                         -> _serde::export::Result<Self::Value, __A::Error>
                         where __A: _serde::de::SeqAccess<'de> {
                            let __field0 =
                                match match _serde::de::SeqAccess::next_element::<Option<String>>(&mut __seq)
                                          {
                                          _serde::export::Ok(__val) => __val,
                                          _serde::export::Err(__err) => {
                                              return _serde::export::Err(__err);
                                          }
                                      } {
                                    _serde::export::Some(__value) => __value,
                                    _serde::export::None => {
                                        return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                     &"struct ApiError with 2 elements"));
                                    }
                                };
                            let __field1 =
                                match match _serde::de::SeqAccess::next_element::<Option<String>>(&mut __seq)
                                          {
                                          _serde::export::Ok(__val) => __val,
                                          _serde::export::Err(__err) => {
                                              return _serde::export::Err(__err);
                                          }
                                      } {
                                    _serde::export::Some(__value) => __value,
                                    _serde::export::None => {
                                        return _serde::export::Err(_serde::de::Error::invalid_length(1usize,
                                                                                                     &"struct ApiError with 2 elements"));
                                    }
                                };
                            _serde::export::Ok(ApiError{error: __field0,
                                                        error_description:
                                                            __field1,})
                        }
                        #[inline]
                        fn visit_map<__A>(self, mut __map: __A)
                         -> _serde::export::Result<Self::Value, __A::Error>
                         where __A: _serde::de::MapAccess<'de> {
                            let mut __field0:
                                    _serde::export::Option<Option<String>> =
                                _serde::export::None;
                            let mut __field1:
                                    _serde::export::Option<Option<String>> =
                                _serde::export::None;
                            while let _serde::export::Some(__key) =
                                      match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                          {
                                          _serde::export::Ok(__val) => __val,
                                          _serde::export::Err(__err) => {
                                              return _serde::export::Err(__err);
                                          }
                                      } {
                                match __key {
                                    __Field::__field0 => {
                                        if _serde::export::Option::is_some(&__field0)
                                           {
                                            return _serde::export::Err(<__A::Error
                                                                           as
                                                                           _serde::de::Error>::duplicate_field("error"));
                                        }
                                        __field0 =
                                            _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<String>>(&mut __map)
                                                                     {
                                                                     _serde::export::Ok(__val)
                                                                     => __val,
                                                                     _serde::export::Err(__err)
                                                                     => {
                                                                         return _serde::export::Err(__err);
                                                                     }
                                                                 });
                                    }
                                    __Field::__field1 => {
                                        if _serde::export::Option::is_some(&__field1)
                                           {
                                            return _serde::export::Err(<__A::Error
                                                                           as
                                                                           _serde::de::Error>::duplicate_field("error_description"));
                                        }
                                        __field1 =
                                            _serde::export::Some(match _serde::de::MapAccess::next_value::<Option<String>>(&mut __map)
                                                                     {
                                                                     _serde::export::Ok(__val)
                                                                     => __val,
                                                                     _serde::export::Err(__err)
                                                                     => {
                                                                         return _serde::export::Err(__err);
                                                                     }
                                                                 });
                                    }
                                    _ => {
                                        let _ =
                                            match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                {
                                                _serde::export::Ok(__val) =>
                                                __val,
                                                _serde::export::Err(__err) =>
                                                {
                                                    return _serde::export::Err(__err);
                                                }
                                            };
                                    }
                                }
                            }
                            let __field0 =
                                match __field0 {
                                    _serde::export::Some(__field0) =>
                                    __field0,
                                    _serde::export::None =>
                                    match _serde::private::de::missing_field("error")
                                        {
                                        _serde::export::Ok(__val) => __val,
                                        _serde::export::Err(__err) => {
                                            return _serde::export::Err(__err);
                                        }
                                    },
                                };
                            let __field1 =
                                match __field1 {
                                    _serde::export::Some(__field1) =>
                                    __field1,
                                    _serde::export::None =>
                                    match _serde::private::de::missing_field("error_description")
                                        {
                                        _serde::export::Ok(__val) => __val,
                                        _serde::export::Err(__err) => {
                                            return _serde::export::Err(__err);
                                        }
                                    },
                                };
                            _serde::export::Ok(ApiError{error: __field0,
                                                        error_description:
                                                            __field1,})
                        }
                    }
                    const FIELDS: &'static [&'static str] =
                        &["error", "error_description"];
                    _serde::Deserializer::deserialize_struct(__deserializer,
                                                             "ApiError",
                                                             FIELDS,
                                                             __Visitor{marker:
                                                                           _serde::export::PhantomData::<ApiError>,
                                                                       lifetime:
                                                                           _serde::export::PhantomData,})
                }
            }
        };
    impl fmt::Display for ApiError {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            f.write_fmt(::core::fmt::Arguments::new_v1(&[""],
                                                       &match (&self,) {
                                                            (arg0,) =>
                                                            [::core::fmt::ArgumentV1::new(arg0,
                                                                                          ::core::fmt::Debug::fmt)],
                                                        }))
        }
    }
    impl error::Error for ApiError { }
    macro_rules! from {
        ($ ($ (# [$ met : meta]) * $ typ : ident, $ variant : ident,) *) =>
        {
            $
            ($ (# [$ met]) * impl From < $ typ > for Error
             {
                 fn from(from : $ typ) -> Self
                 { use crate :: Error :: * ; $ variant(from) }
             }) *
        }
    }
    impl From<HttpError> for Error {
        fn from(from: HttpError) -> Self {
            use crate::Error::*;
            Http(from)
        }
    }
    impl From<IoError> for Error {
        fn from(from: IoError) -> Self {
            use crate::Error::*;
            Io(from)
        }
    }
    impl From<SerdeError> for Error {
        fn from(from: SerdeError) -> Self {
            use crate::Error::*;
            Serde(from)
        }
    }
    impl From<UrlEncodedError> for Error {
        fn from(from: UrlEncodedError) -> Self {
            use crate::Error::*;
            UrlEncoded(from)
        }
    }
    impl From<UrlError> for Error {
        fn from(from: UrlError) -> Self {
            use crate::Error::*;
            Url(from)
        }
    }
    impl From<ApiError> for Error {
        fn from(from: ApiError) -> Self {
            use crate::Error::*;
            Api(from)
        }
    }
    impl From<HeaderStrError> for Error {
        fn from(from: HeaderStrError) -> Self {
            use crate::Error::*;
            HeaderStrError(from)
        }
    }
    impl From<HeaderParseError> for Error {
        fn from(from: HeaderParseError) -> Self {
            use crate::Error::*;
            HeaderParseError(from)
        }
    }
    impl From<SerdeQsError> for Error {
        fn from(from: SerdeQsError) -> Self {
            use crate::Error::*;
            SerdeQs(from)
        }
    }
    impl From<WebSocketError> for Error {
        fn from(from: WebSocketError) -> Self {
            use crate::Error::*;
            WebSocket(from)
        }
    }
    impl From<String> for Error {
        fn from(from: String) -> Self {
            use crate::Error::*;
            Other(from)
        }
    }
    #[macro_export]
    /// Used to easily create errors from strings
    macro_rules! format_err {
        ($ ($ arg : tt) *) =>
        { { use elefren :: Error ; Error :: Other(format ! ($ ($ arg) *)) } }
    }
}
/// Collection of helpers for serializing/deserializing `Data` objects
pub mod helpers {
    /// Helpers for working with the command line
    pub mod cli {
        use std::io::{self, BufRead, Write};
        use crate::errors::Result;
        use crate::registration::Registered;
        use crate::Mastodon;
        /// Finishes the authentication process for the given `Registered` object,
        /// using the command-line
        pub fn authenticate(registration: Registered) -> Result<Mastodon> {
            let url = registration.authorize_url()?;
            let stdout = io::stdout();
            let stdin = io::stdin();
            let mut stdout = stdout.lock();
            let mut stdin = stdin.lock();
            (&mut stdout).write_fmt(::core::fmt::Arguments::new_v1(&["Click this link to authorize: ",
                                                                     "\n"],
                                                                   &match (&url,)
                                                                        {
                                                                        (arg0,)
                                                                        =>
                                                                        [::core::fmt::ArgumentV1::new(arg0,
                                                                                                      ::core::fmt::Display::fmt)],
                                                                    }))?;
            (&mut stdout).write_fmt(::core::fmt::Arguments::new_v1(&["Paste the returned authorization code: "],
                                                                   &match () {
                                                                        () =>
                                                                        [],
                                                                    }))?;
            stdout.flush()?;
            let mut input = String::new();
            stdin.read_line(&mut input)?;
            let code = input.trim();
            Ok(registration.complete(code)?)
        }
    }
}
mod mastodon_client {
    use async_trait::async_trait;
    use std::borrow::Cow;
    use crate::entities::prelude::*;
    use crate::errors::Result;
    use crate::page::Page;
    use crate::requests::{AddFilterRequest, AddPushRequest, StatusesRequest,
                          UpdateCredsRequest, UpdatePushRequest};
    use crate::status_builder::NewStatus;
    #[doc =
      " Represents the set of methods that a Mastodon Client can do, so that"]
    #[doc = " implementations might be swapped out for testing"]
    #[allow(unused)]
    pub trait MastodonClient {
        #[doc = " GET /api/v1/favourites"]
        #[must_use]
        fn favourites<'life0, 'async_trait>(&'life0 self)
         ->
             ::core::pin::Pin<Box<dyn ::core::future::Future<Output =
                                                             Result<Page<'_,
                                                                         Status>>> +
                                  ::core::marker::Send + 'async_trait>> where
         'life0: 'async_trait, Self: ::core::marker::Sync + 'async_trait {
            #[allow(clippy :: missing_docs_in_private_items, clippy ::
                    type_repetition_in_bounds, clippy ::
                    used_underscore_binding,)]
            async fn __favourites<AsyncTrait: ?Sized + MastodonClient +
                                  ::core::marker::Sync>(_self: &AsyncTrait)
             -> Result<Page<'_, Status>> {
                {
                    ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                               &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                       &match ()
                                                                                                                            {
                                                                                                                            ()
                                                                                                                            =>
                                                                                                                            [],
                                                                                                                        }),)
                                                                                    {
                                                                                    (arg0,)
                                                                                    =>
                                                                                    [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                  ::core::fmt::Display::fmt)],
                                                                                }))
                };
            }
            Box::pin(__favourites::<Self>(self))
        }
        #[doc = " GET /api/v1/blocks"]
        #[must_use]
        fn blocks<'life0, 'async_trait>(&'life0 self)
         ->
             ::core::pin::Pin<Box<dyn ::core::future::Future<Output =
                                                             Result<Page<'_,
                                                                         Account>>> +
                                  ::core::marker::Send + 'async_trait>> where
         'life0: 'async_trait, Self: ::core::marker::Sync + 'async_trait {
            #[allow(clippy :: missing_docs_in_private_items, clippy ::
                    type_repetition_in_bounds, clippy ::
                    used_underscore_binding,)]
            async fn __blocks<AsyncTrait: ?Sized + MastodonClient +
                              ::core::marker::Sync>(_self: &AsyncTrait)
             -> Result<Page<'_, Account>> {
                {
                    ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                               &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                       &match ()
                                                                                                                            {
                                                                                                                            ()
                                                                                                                            =>
                                                                                                                            [],
                                                                                                                        }),)
                                                                                    {
                                                                                    (arg0,)
                                                                                    =>
                                                                                    [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                  ::core::fmt::Display::fmt)],
                                                                                }))
                };
            }
            Box::pin(__blocks::<Self>(self))
        }
        #[doc = " GET /api/v1/domain_blocks"]
        #[must_use]
        fn domain_blocks<'life0, 'async_trait>(&'life0 self)
         ->
             ::core::pin::Pin<Box<dyn ::core::future::Future<Output =
                                                             Result<Page<'_,
                                                                         String>>> +
                                  ::core::marker::Send + 'async_trait>> where
         'life0: 'async_trait, Self: ::core::marker::Sync + 'async_trait {
            #[allow(clippy :: missing_docs_in_private_items, clippy ::
                    type_repetition_in_bounds, clippy ::
                    used_underscore_binding,)]
            async fn __domain_blocks<AsyncTrait: ?Sized + MastodonClient +
                                     ::core::marker::Sync>(_self: &AsyncTrait)
             -> Result<Page<'_, String>> {
                {
                    ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                               &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                       &match ()
                                                                                                                            {
                                                                                                                            ()
                                                                                                                            =>
                                                                                                                            [],
                                                                                                                        }),)
                                                                                    {
                                                                                    (arg0,)
                                                                                    =>
                                                                                    [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                  ::core::fmt::Display::fmt)],
                                                                                }))
                };
            }
            Box::pin(__domain_blocks::<Self>(self))
        }
        #[doc = " GET /api/v1/follow_requests"]
        #[must_use]
        fn follow_requests<'life0, 'async_trait>(&'life0 self)
         ->
             ::core::pin::Pin<Box<dyn ::core::future::Future<Output =
                                                             Result<Page<'_,
                                                                         Account>>> +
                                  ::core::marker::Send + 'async_trait>> where
         'life0: 'async_trait, Self: ::core::marker::Sync + 'async_trait {
            #[allow(clippy :: missing_docs_in_private_items, clippy ::
                    type_repetition_in_bounds, clippy ::
                    used_underscore_binding,)]
            async fn __follow_requests<AsyncTrait: ?Sized + MastodonClient +
                                       ::core::marker::Sync>(_self:
                                                                 &AsyncTrait)
             -> Result<Page<'_, Account>> {
                {
                    ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                               &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                       &match ()
                                                                                                                            {
                                                                                                                            ()
                                                                                                                            =>
                                                                                                                            [],
                                                                                                                        }),)
                                                                                    {
                                                                                    (arg0,)
                                                                                    =>
                                                                                    [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                  ::core::fmt::Display::fmt)],
                                                                                }))
                };
            }
            Box::pin(__follow_requests::<Self>(self))
        }
        #[doc = " GET /api/v1/timelines/home"]
        #[must_use]
        fn get_home_timeline<'life0, 'async_trait>(&'life0 self)
         ->
             ::core::pin::Pin<Box<dyn ::core::future::Future<Output =
                                                             Result<Page<'_,
                                                                         Status>>> +
                                  ::core::marker::Send + 'async_trait>> where
         'life0: 'async_trait, Self: ::core::marker::Sync + 'async_trait {
            #[allow(clippy :: missing_docs_in_private_items, clippy ::
                    type_repetition_in_bounds, clippy ::
                    used_underscore_binding,)]
            async fn __get_home_timeline<AsyncTrait: ?Sized + MastodonClient +
                                         ::core::marker::Sync>(_self:
                                                                   &AsyncTrait)
             -> Result<Page<'_, Status>> {
                {
                    ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                               &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                       &match ()
                                                                                                                            {
                                                                                                                            ()
                                                                                                                            =>
                                                                                                                            [],
                                                                                                                        }),)
                                                                                    {
                                                                                    (arg0,)
                                                                                    =>
                                                                                    [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                  ::core::fmt::Display::fmt)],
                                                                                }))
                };
            }
            Box::pin(__get_home_timeline::<Self>(self))
        }
        #[doc = " GET /api/v1/custom_emojis"]
        #[must_use]
        fn get_emojis<'life0, 'async_trait>(&'life0 self)
         ->
             ::core::pin::Pin<Box<dyn ::core::future::Future<Output =
                                                             Result<Page<'_,
                                                                         Emoji>>> +
                                  ::core::marker::Send + 'async_trait>> where
         'life0: 'async_trait, Self: ::core::marker::Sync + 'async_trait {
            #[allow(clippy :: missing_docs_in_private_items, clippy ::
                    type_repetition_in_bounds, clippy ::
                    used_underscore_binding,)]
            async fn __get_emojis<AsyncTrait: ?Sized + MastodonClient +
                                  ::core::marker::Sync>(_self: &AsyncTrait)
             -> Result<Page<'_, Emoji>> {
                {
                    ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                               &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                       &match ()
                                                                                                                            {
                                                                                                                            ()
                                                                                                                            =>
                                                                                                                            [],
                                                                                                                        }),)
                                                                                    {
                                                                                    (arg0,)
                                                                                    =>
                                                                                    [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                  ::core::fmt::Display::fmt)],
                                                                                }))
                };
            }
            Box::pin(__get_emojis::<Self>(self))
        }
        #[doc = " GET /api/v1/mutes"]
        #[must_use]
        fn mutes<'life0, 'async_trait>(&'life0 self)
         ->
             ::core::pin::Pin<Box<dyn ::core::future::Future<Output =
                                                             Result<Page<'_,
                                                                         Account>>> +
                                  ::core::marker::Send + 'async_trait>> where
         'life0: 'async_trait, Self: ::core::marker::Sync + 'async_trait {
            #[allow(clippy :: missing_docs_in_private_items, clippy ::
                    type_repetition_in_bounds, clippy ::
                    used_underscore_binding,)]
            async fn __mutes<AsyncTrait: ?Sized + MastodonClient +
                             ::core::marker::Sync>(_self: &AsyncTrait)
             -> Result<Page<'_, Account>> {
                {
                    ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                               &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                       &match ()
                                                                                                                            {
                                                                                                                            ()
                                                                                                                            =>
                                                                                                                            [],
                                                                                                                        }),)
                                                                                    {
                                                                                    (arg0,)
                                                                                    =>
                                                                                    [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                  ::core::fmt::Display::fmt)],
                                                                                }))
                };
            }
            Box::pin(__mutes::<Self>(self))
        }
        #[doc = " GET /api/v1/notifications"]
        #[must_use]
        fn notifications<'life0, 'async_trait>(&'life0 self)
         ->
             ::core::pin::Pin<Box<dyn ::core::future::Future<Output =
                                                             Result<Page<'_,
                                                                         Notification>>> +
                                  ::core::marker::Send + 'async_trait>> where
         'life0: 'async_trait, Self: ::core::marker::Sync + 'async_trait {
            #[allow(clippy :: missing_docs_in_private_items, clippy ::
                    type_repetition_in_bounds, clippy ::
                    used_underscore_binding,)]
            async fn __notifications<AsyncTrait: ?Sized + MastodonClient +
                                     ::core::marker::Sync>(_self: &AsyncTrait)
             -> Result<Page<'_, Notification>> {
                {
                    ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                               &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                       &match ()
                                                                                                                            {
                                                                                                                            ()
                                                                                                                            =>
                                                                                                                            [],
                                                                                                                        }),)
                                                                                    {
                                                                                    (arg0,)
                                                                                    =>
                                                                                    [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                  ::core::fmt::Display::fmt)],
                                                                                }))
                };
            }
            Box::pin(__notifications::<Self>(self))
        }
        #[doc = " GET /api/v1/reports"]
        #[must_use]
        fn reports<'life0, 'async_trait>(&'life0 self)
         ->
             ::core::pin::Pin<Box<dyn ::core::future::Future<Output =
                                                             Result<Page<'_,
                                                                         Report>>> +
                                  ::core::marker::Send + 'async_trait>> where
         'life0: 'async_trait, Self: ::core::marker::Sync + 'async_trait {
            #[allow(clippy :: missing_docs_in_private_items, clippy ::
                    type_repetition_in_bounds, clippy ::
                    used_underscore_binding,)]
            async fn __reports<AsyncTrait: ?Sized + MastodonClient +
                               ::core::marker::Sync>(_self: &AsyncTrait)
             -> Result<Page<'_, Report>> {
                {
                    ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                               &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                       &match ()
                                                                                                                            {
                                                                                                                            ()
                                                                                                                            =>
                                                                                                                            [],
                                                                                                                        }),)
                                                                                    {
                                                                                    (arg0,)
                                                                                    =>
                                                                                    [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                  ::core::fmt::Display::fmt)],
                                                                                }))
                };
            }
            Box::pin(__reports::<Self>(self))
        }
        #[doc = " GET /api/v1/accounts/:id/followers"]
        fn followers(&self, id: &str) -> Result<Page<Account>> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " GET /api/v1/accounts/:id/following"]
        fn following(&self, id: &str) -> Result<Page<Account>> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " GET /api/v1/statuses/:id/reblogged_by"]
        fn reblogged_by(&self, id: &str) -> Result<Page<Account>> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " GET /api/v1/statuses/:id/favourited_by"]
        fn favourited_by(&self, id: &str) -> Result<Page<Account>> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " DELETE /api/v1/domain_blocks"]
        fn unblock_domain(&self, domain: String) -> Result<Empty> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " GET /api/v1/instance"]
        fn instance(&self) -> Result<Instance> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " GET /api/v1/accounts/verify_credentials"]
        fn verify_credentials(&self) -> Result<Account> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " POST /api/v1/reports"]
        fn report(&self, account_id: &str, status_ids: Vec<&str>,
                  comment: String) -> Result<Report> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " POST /api/v1/domain_blocks"]
        fn block_domain(&self, domain: String) -> Result<Empty> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " POST /api/v1/accounts/follow_requests/authorize"]
        fn authorize_follow_request(&self, id: &str) -> Result<Empty> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " POST /api/v1/accounts/follow_requests/reject"]
        fn reject_follow_request(&self, id: &str) -> Result<Empty> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " GET /api/v1/search"]
        fn search<'a>(&self, q: &'a str, resolve: bool)
         -> Result<SearchResult> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " GET /api/v2/search"]
        fn search_v2<'a>(&self, q: &'a str, resolve: bool)
         -> Result<SearchResultV2> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " POST /api/v1/follows"]
        fn follows(&self, uri: Cow<'static, str>) -> Result<Account> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " POST /api/v1/media"]
        fn media(&self, file: Cow<'static, str>) -> Result<Attachment> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " POST /api/v1/notifications/clear"]
        fn clear_notifications(&self) -> Result<Empty> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " POST /api/v1/notifications/dismiss"]
        fn dismiss_notification(&self, id: &str) -> Result<Empty> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " GET /api/v1/accounts/:id"]
        fn get_account(&self, id: &str) -> Result<Account> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " POST /api/v1/accounts/:id/follow"]
        fn follow(&self, id: &str) -> Result<Relationship> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " POST /api/v1/accounts/:id/unfollow"]
        fn unfollow(&self, id: &str) -> Result<Relationship> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " GET /api/v1/accounts/:id/block"]
        fn block(&self, id: &str) -> Result<Relationship> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " GET /api/v1/accounts/:id/unblock"]
        fn unblock(&self, id: &str) -> Result<Relationship> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " GET /api/v1/accounts/:id/mute"]
        fn mute(&self, id: &str) -> Result<Relationship> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " GET /api/v1/accounts/:id/unmute"]
        fn unmute(&self, id: &str) -> Result<Relationship> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " GET /api/v1/notifications/:id"]
        fn get_notification(&self, id: &str) -> Result<Notification> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " GET /api/v1/statuses/:id"]
        fn get_status(&self, id: &str) -> Result<Status> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " GET /api/v1/statuses/:id/context"]
        fn get_context(&self, id: &str) -> Result<Context> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " GET /api/v1/statuses/:id/card"]
        fn get_card(&self, id: &str) -> Result<Card> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " POST /api/v1/statuses/:id/reblog"]
        fn reblog(&self, id: &str) -> Result<Status> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " POST /api/v1/statuses/:id/unreblog"]
        fn unreblog(&self, id: &str) -> Result<Status> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " POST /api/v1/statuses/:id/favourite"]
        fn favourite(&self, id: &str) -> Result<Status> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " POST /api/v1/statuses/:id/unfavourite"]
        fn unfavourite(&self, id: &str) -> Result<Status> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " DELETE /api/v1/statuses/:id"]
        fn delete_status(&self, id: &str) -> Result<Empty> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " PATCH /api/v1/accounts/update_credentials"]
        fn update_credentials(&self, builder: &mut UpdateCredsRequest)
         -> Result<Account> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " POST /api/v1/statuses"]
        fn new_status(&self, status: NewStatus) -> Result<Status> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " GET /api/v1/timelines/public"]
        fn get_public_timeline(&self, local: bool) -> Result<Vec<Status>> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " GET /api/v1/timelines/tag/:hashtag"]
        fn get_tagged_timeline(&self, hashtag: String, local: bool)
         -> Result<Vec<Status>> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " GET /api/v1/accounts/:id/statuses"]
        fn statuses<'a, 'b: 'a, S>(&'b self, id: &'b str, request: S)
         -> Result<Page<Status>> where S: Into<Option<StatusesRequest<'a>>> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " GET /api/v1/accounts/relationships"]
        fn relationships(&self, ids: &[&str]) -> Result<Page<Relationship>> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc =
          " GET /api/v1/accounts/search?q=:query&limit=:limit&following=:following"]
        #[must_use]
        fn search_accounts<'life0, 'life1,
                           'async_trait>(&'life0 self, query: &'life1 str,
                                         limit: Option<u64>, following: bool)
         ->
             ::core::pin::Pin<Box<dyn ::core::future::Future<Output =
                                                             Result<Page<'_,
                                                                         Account>>> +
                                  ::core::marker::Send + 'async_trait>> where
         'life0: 'async_trait, 'life1: 'async_trait,
         Self: ::core::marker::Sync + 'async_trait {
            #[allow(clippy :: missing_docs_in_private_items, clippy ::
                    type_repetition_in_bounds, clippy ::
                    used_underscore_binding,)]
            async fn __search_accounts<AsyncTrait: ?Sized + MastodonClient +
                                       ::core::marker::Sync>(_self:
                                                                 &AsyncTrait,
                                                             query: &str,
                                                             limit:
                                                                 Option<u64>,
                                                             following: bool)
             -> Result<Page<'_, Account>> {
                {
                    ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                               &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                       &match ()
                                                                                                                            {
                                                                                                                            ()
                                                                                                                            =>
                                                                                                                            [],
                                                                                                                        }),)
                                                                                    {
                                                                                    (arg0,)
                                                                                    =>
                                                                                    [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                  ::core::fmt::Display::fmt)],
                                                                                }))
                };
            }
            Box::pin(__search_accounts::<Self>(self, query, limit, following))
        }
        #[doc = " POST /api/v1/push/subscription"]
        fn add_push_subscription(&self, request: &AddPushRequest)
         -> Result<Subscription> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " PUT /api/v1/push/subscription"]
        fn update_push_data(&self, request: &UpdatePushRequest)
         -> Result<Subscription> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " GET /api/v1/push/subscription"]
        fn get_push_subscription(&self) -> Result<Subscription> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " DELETE /api/v1/push/subscription"]
        fn delete_push_subscription(&self) -> Result<Empty> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " GET /api/v1/filters"]
        fn get_filters(&self) -> Result<Vec<Filter>> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " POST /api/v1/filters"]
        fn add_filter(&self, request: &mut AddFilterRequest)
         -> Result<Filter> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " GET /api/v1/filters/:id"]
        fn get_filter(&self, id: &str) -> Result<Filter> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " PUT /api/v1/filters/:id"]
        fn update_filter(&self, id: &str, request: &mut AddFilterRequest)
         -> Result<Filter> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " DELETE /api/v1/filters/:id"]
        fn delete_filter(&self, id: &str) -> Result<Empty> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " GET /api/v1/suggestions"]
        fn get_follow_suggestions(&self) -> Result<Vec<Account>> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " DELETE /api/v1/suggestions/:account_id"]
        fn delete_from_suggestions(&self, id: &str) -> Result<Empty> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " GET /api/v1/endorsements"]
        #[must_use]
        fn get_endorsements<'life0, 'async_trait>(&'life0 self)
         ->
             ::core::pin::Pin<Box<dyn ::core::future::Future<Output =
                                                             Result<Page<'_,
                                                                         Account>>> +
                                  ::core::marker::Send + 'async_trait>> where
         'life0: 'async_trait, Self: ::core::marker::Sync + 'async_trait {
            #[allow(clippy :: missing_docs_in_private_items, clippy ::
                    type_repetition_in_bounds, clippy ::
                    used_underscore_binding,)]
            async fn __get_endorsements<AsyncTrait: ?Sized + MastodonClient +
                                        ::core::marker::Sync>(_self:
                                                                  &AsyncTrait)
             -> Result<Page<'_, Account>> {
                {
                    ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                               &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                       &match ()
                                                                                                                            {
                                                                                                                            ()
                                                                                                                            =>
                                                                                                                            [],
                                                                                                                        }),)
                                                                                    {
                                                                                    (arg0,)
                                                                                    =>
                                                                                    [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                  ::core::fmt::Display::fmt)],
                                                                                }))
                };
            }
            Box::pin(__get_endorsements::<Self>(self))
        }
        #[doc = " POST /api/v1/accounts/:id/pin"]
        fn endorse_user(&self, id: &str) -> Result<Relationship> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " POST /api/v1/accounts/:id/unpin"]
        fn unendorse_user(&self, id: &str) -> Result<Relationship> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc =
          " Shortcut for: `let me = client.verify_credentials(); client.followers()`"]
        #[doc = ""]
        #[doc = " ```no_run"]
        #[doc = " # extern crate elefren;"]
        #[doc = " # use std::error::Error;"]
        #[doc = " # use elefren::prelude::*;"]
        #[doc = " # fn main() -> Result<(), Box<Error>> {"]
        #[doc = " # let data = Data {"]
        #[doc = " #   base: \"\".into(),"]
        #[doc = " #   client_id: \"\".into(),"]
        #[doc = " #   client_secret: \"\".into(),"]
        #[doc = " #   redirect: \"\".into(),"]
        #[doc = " #   token: \"\".into(),"]
        #[doc = " # };"]
        #[doc = " # let client = Mastodon::from(data);"]
        #[doc = " let follows_me = client.follows_me()?;"]
        #[doc = " #   Ok(())"]
        #[doc = " # }"]
        fn follows_me(&self) -> Result<Page<Account>> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        #[doc = " Shortcut for"]
        #[doc =
          " `let me = client.verify_credentials(); client.following(&me.id)`"]
        #[doc = ""]
        #[doc = " ```no_run"]
        #[doc = " # extern crate elefren;"]
        #[doc = " # use std::error::Error;"]
        #[doc = " # use elefren::prelude::*;"]
        #[doc = " # fn main() -> Result<(), Box<Error>> {"]
        #[doc = " # let data = Data {"]
        #[doc = " #   base: \"\".into(),"]
        #[doc = " #   client_id: \"\".into(),"]
        #[doc = " #   client_secret: \"\".into(),"]
        #[doc = " #   redirect: \"\".into(),"]
        #[doc = " #   token: \"\".into(),"]
        #[doc = " # };"]
        #[doc = " # let client = Mastodon::from(data);"]
        #[doc = " let follows_me = client.followed_by_me()?;"]
        #[doc = " #   Ok(())"]
        #[doc = " # }"]
        fn followed_by_me(&self) -> Result<Page<Account>> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
    }
    /// Trait that represents clients that can make unauthenticated calls to a
    /// mastodon instance
    #[allow(unused)]
    pub trait MastodonUnauthenticated {
        /// GET /api/v1/statuses/:id
        fn get_status(&self, id: &str) -> Result<Status> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        /// GET /api/v1/statuses/:id/context
        fn get_context(&self, id: &str) -> Result<Context> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        /// GET /api/v1/statuses/:id/card
        fn get_card(&self, id: &str) -> Result<Card> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        /// GET /api/v1/statuses/:id/reblogged_by
        fn reblogged_by(&self, id: &str) -> Result<Page<Account>> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
        /// GET /api/v1/statuses/:id/favourited_by
        fn favourited_by(&self, id: &str) -> Result<Page<Account>> {
            {
                ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "],
                                                                           &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"],
                                                                                                                   &match ()
                                                                                                                        {
                                                                                                                        ()
                                                                                                                        =>
                                                                                                                        [],
                                                                                                                    }),)
                                                                                {
                                                                                (arg0,)
                                                                                =>
                                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                                              ::core::fmt::Display::fmt)],
                                                                            }))
            };
        }
    }
}
/// Handling multiple pages of entities.
pub mod page {
    use super::{deserialise, Mastodon, Result};
    use hyper_old_types::header::{parsing, Link, RelationType};
    use reqwest::{header::LINK, Response};
    use serde::Deserialize;
    use url::Url;
    macro_rules! pages {
        ($ ($ direction : ident : $ fun : ident), *) =>
        {
            $
            (doc_comment !
             (concat !
              ("Method to retrieve the ", stringify ! ($ direction),
               " page of results"), pub async fn $ fun(& mut self) -> Result <
              Option < Vec < T >> >
              {
                  let url = match self . $ direction . take()
                  { Some(s) => s, None => return Ok(None), } ; let response =
                  self . mastodon . send(self . mastodon . client . get(url))
                  ? ; let(prev, next) = get_links(& response) ? ; self . next
                  = next ; self . prev = prev ; deserialise(response)
              }) ;) *
        }
    }
    /// Owned version of the `Page` struct in this module. Allows this to be more
    /// easily stored for later use
    ///
    /// # Example
    ///
    /// ```no_run
    /// # extern crate elefren;
    /// # use elefren::Mastodon;
    /// # use elefren::page::OwnedPage;
    /// # use elefren::entities::status::Status;
    /// # use std::cell::RefCell;
    /// # use elefren::prelude::*;
    /// # fn main() -> Result<(), elefren::Error> {
    /// # let data = Data {
    /// #   base: "".into(),
    /// #   client_id: "".into(),
    /// #   client_secret: "".into(),
    /// #   redirect: "".into(),
    /// #   token: "".into(),
    /// # };
    /// struct HomeTimeline {
    ///     client: Mastodon,
    ///     page: RefCell<Option<OwnedPage<Status>>>,
    /// }
    /// let client = Mastodon::from(data);
    /// let home = client.get_home_timeline()?.to_owned();
    /// let tl = HomeTimeline {
    ///     client,
    ///     page: RefCell::new(Some(home)),
    /// };
    /// # Ok(())
    /// # }
    /// ```
    pub struct OwnedPage<T: for<'de> Deserialize<'de>> {
        mastodon: Mastodon,
        next: Option<Url>,
        prev: Option<Url>,
        /// Initial set of items
        pub initial_items: Vec<T>,
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl <T: ::core::fmt::Debug + for<'de> Deserialize<'de>>
     ::core::fmt::Debug for OwnedPage<T> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            match *self {
                OwnedPage {
                mastodon: ref __self_0_0,
                next: ref __self_0_1,
                prev: ref __self_0_2,
                initial_items: ref __self_0_3 } => {
                    let mut debug_trait_builder = f.debug_struct("OwnedPage");
                    let _ =
                        debug_trait_builder.field("mastodon",
                                                  &&(*__self_0_0));
                    let _ =
                        debug_trait_builder.field("next", &&(*__self_0_1));
                    let _ =
                        debug_trait_builder.field("prev", &&(*__self_0_2));
                    let _ =
                        debug_trait_builder.field("initial_items",
                                                  &&(*__self_0_3));
                    debug_trait_builder.finish()
                }
            }
        }
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl <T: ::core::clone::Clone + for<'de> Deserialize<'de>>
     ::core::clone::Clone for OwnedPage<T> {
        #[inline]
        fn clone(&self) -> OwnedPage<T> {
            match *self {
                OwnedPage {
                mastodon: ref __self_0_0,
                next: ref __self_0_1,
                prev: ref __self_0_2,
                initial_items: ref __self_0_3 } =>
                OwnedPage{mastodon:
                              ::core::clone::Clone::clone(&(*__self_0_0)),
                          next: ::core::clone::Clone::clone(&(*__self_0_1)),
                          prev: ::core::clone::Clone::clone(&(*__self_0_2)),
                          initial_items:
                              ::core::clone::Clone::clone(&(*__self_0_3)),},
            }
        }
    }
    impl <T: for<'de> Deserialize<'de>> OwnedPage<T> {
        #[doc = "Method to retrieve the next page of results"]
        pub async fn next_page(&mut self) -> Result<Option<Vec<T>>> {
            let url =
                match self.next.take() {
                    Some(s) => s,
                    None => return Ok(None),
                };
            let response = self.mastodon.send(self.mastodon.client.get(url))?;
            let (prev, next) = get_links(&response)?;
            self.next = next;
            self.prev = prev;
            deserialise(response)
        }
        #[doc = "Method to retrieve the prev page of results"]
        pub async fn prev_page(&mut self) -> Result<Option<Vec<T>>> {
            let url =
                match self.prev.take() {
                    Some(s) => s,
                    None => return Ok(None),
                };
            let response = self.mastodon.send(self.mastodon.client.get(url))?;
            let (prev, next) = get_links(&response)?;
            self.next = next;
            self.prev = prev;
            deserialise(response)
        }
    }
    impl <'a, T: for<'de> Deserialize<'de>> From<Page<'a, T>> for OwnedPage<T>
     {
        fn from(page: Page<'a, T>) -> OwnedPage<T> {
            OwnedPage{mastodon: page.mastodon.clone(),
                      next: page.next,
                      prev: page.prev,
                      initial_items: page.initial_items,}
        }
    }
    /// Represents a single page of API results
    pub struct Page<'a, T: for<'de> Deserialize<'de>> {
        mastodon: &'a Mastodon,
        next: Option<Url>,
        prev: Option<Url>,
        /// Initial set of items
        pub initial_items: Vec<T>,
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl <'a, T: ::core::fmt::Debug + for<'de> Deserialize<'de>>
     ::core::fmt::Debug for Page<'a, T> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            match *self {
                Page {
                mastodon: ref __self_0_0,
                next: ref __self_0_1,
                prev: ref __self_0_2,
                initial_items: ref __self_0_3 } => {
                    let mut debug_trait_builder = f.debug_struct("Page");
                    let _ =
                        debug_trait_builder.field("mastodon",
                                                  &&(*__self_0_0));
                    let _ =
                        debug_trait_builder.field("next", &&(*__self_0_1));
                    let _ =
                        debug_trait_builder.field("prev", &&(*__self_0_2));
                    let _ =
                        debug_trait_builder.field("initial_items",
                                                  &&(*__self_0_3));
                    debug_trait_builder.finish()
                }
            }
        }
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl <'a, T: ::core::clone::Clone + for<'de> Deserialize<'de>>
     ::core::clone::Clone for Page<'a, T> {
        #[inline]
        fn clone(&self) -> Page<'a, T> {
            match *self {
                Page {
                mastodon: ref __self_0_0,
                next: ref __self_0_1,
                prev: ref __self_0_2,
                initial_items: ref __self_0_3 } =>
                Page{mastodon: ::core::clone::Clone::clone(&(*__self_0_0)),
                     next: ::core::clone::Clone::clone(&(*__self_0_1)),
                     prev: ::core::clone::Clone::clone(&(*__self_0_2)),
                     initial_items:
                         ::core::clone::Clone::clone(&(*__self_0_3)),},
            }
        }
    }
    impl <'a, T: for<'de> Deserialize<'de>> Page<'a, T> {
        #[doc = "Method to retrieve the next page of results"]
        pub async fn next_page(&mut self) -> Result<Option<Vec<T>>> {
            let url =
                match self.next.take() {
                    Some(s) => s,
                    None => return Ok(None),
                };
            let response = self.mastodon.send(self.mastodon.client.get(url))?;
            let (prev, next) = get_links(&response)?;
            self.next = next;
            self.prev = prev;
            deserialise(response)
        }
        #[doc = "Method to retrieve the prev page of results"]
        pub async fn prev_page(&mut self) -> Result<Option<Vec<T>>> {
            let url =
                match self.prev.take() {
                    Some(s) => s,
                    None => return Ok(None),
                };
            let response = self.mastodon.send(self.mastodon.client.get(url))?;
            let (prev, next) = get_links(&response)?;
            self.next = next;
            self.prev = prev;
            deserialise(response)
        }
        pub(crate) fn new(mastodon: &'a Mastodon, response: Response)
         -> Result<Self> {
            let (prev, next) = get_links(&response)?;
            Ok(Page{initial_items: deserialise(response)?,
                    next,
                    prev,
                    mastodon,})
        }
    }
    impl <'a, T: Clone + for<'de> Deserialize<'de>> Page<'a, T> {
        /// Returns an owned version of this struct that doesn't borrow the client
        /// that created it
        ///
        /// # Example
        ///
        /// ```no_run
        /// # extern crate elefren;
        /// # use elefren::Mastodon;
        /// # use elefren::page::OwnedPage;
        /// # use elefren::entities::status::Status;
        /// # use std::cell::RefCell;
        /// # use elefren::prelude::*;
        /// # fn main() -> Result<(), elefren::Error> {
        /// # let data = Data {
        /// #   base: "".into(),
        /// #   client_id: "".into(),
        /// #   client_secret: "".into(),
        /// #   redirect: "".into(),
        /// #   token: "".into(),
        /// # };
        /// struct HomeTimeline {
        ///     client: Mastodon,
        ///     page: RefCell<Option<OwnedPage<Status>>>,
        /// }
        /// let client = Mastodon::from(data);
        /// let home = client.get_home_timeline()?.to_owned();
        /// let tl = HomeTimeline {
        ///     client,
        ///     page: RefCell::new(Some(home)),
        /// };
        /// # Ok(())
        /// # }
        /// ```
        pub fn to_owned(self) -> OwnedPage<T> { OwnedPage::from(self) }
    }
    fn get_links(response: &Response) -> Result<(Option<Url>, Option<Url>)> {
        let mut prev = None;
        let mut next = None;
        if let Some(link_header) = response.headers().get(LINK) {
            let link_header = link_header.to_str()?;
            let link_header = link_header.as_bytes();
            let link_header: Link = parsing::from_raw_str(&link_header)?;
            for value in link_header.values() {
                if let Some(relations) = value.rel() {
                    if relations.contains(&RelationType::Next) {
                        next = Some(Url::parse(value.link())?);
                    }
                    if relations.contains(&RelationType::Prev) {
                        prev = Some(Url::parse(value.link())?);
                    }
                }
            }
        }
        Ok((prev, next))
    }
}
/// Registering your app.
pub mod registration {
    use std::borrow::Cow;
    use reqwest::{Client, RequestBuilder, Response};
    use try_from::TryInto;
    use url::percent_encoding::{utf8_percent_encode, DEFAULT_ENCODE_SET};
    use crate::apps::{App, AppBuilder};
    use crate::scopes::Scopes;
    use crate::Data;
    use crate::Error;
    use crate::Mastodon;
    use crate::MastodonBuilder;
    use crate::Result;
    const DEFAULT_REDIRECT_URI: &'static str = "urn:ietf:wg:oauth:2.0:oob";
    /// Handles registering your mastodon app to your instance. It is recommended
    /// you cache your data struct to avoid registering on every run.
    pub struct Registration<'a> {
        base: String,
        client: Client,
        app_builder: AppBuilder<'a>,
        force_login: bool,
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl <'a> ::core::fmt::Debug for Registration<'a> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            match *self {
                Registration {
                base: ref __self_0_0,
                client: ref __self_0_1,
                app_builder: ref __self_0_2,
                force_login: ref __self_0_3 } => {
                    let mut debug_trait_builder =
                        f.debug_struct("Registration");
                    let _ =
                        debug_trait_builder.field("base", &&(*__self_0_0));
                    let _ =
                        debug_trait_builder.field("client", &&(*__self_0_1));
                    let _ =
                        debug_trait_builder.field("app_builder",
                                                  &&(*__self_0_2));
                    let _ =
                        debug_trait_builder.field("force_login",
                                                  &&(*__self_0_3));
                    debug_trait_builder.finish()
                }
            }
        }
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl <'a> ::core::clone::Clone for Registration<'a> {
        #[inline]
        fn clone(&self) -> Registration<'a> {
            match *self {
                Registration {
                base: ref __self_0_0,
                client: ref __self_0_1,
                app_builder: ref __self_0_2,
                force_login: ref __self_0_3 } =>
                Registration{base:
                                 ::core::clone::Clone::clone(&(*__self_0_0)),
                             client:
                                 ::core::clone::Clone::clone(&(*__self_0_1)),
                             app_builder:
                                 ::core::clone::Clone::clone(&(*__self_0_2)),
                             force_login:
                                 ::core::clone::Clone::clone(&(*__self_0_3)),},
            }
        }
    }
    struct OAuth {
        client_id: String,
        client_secret: String,
        #[serde(default = "default_redirect_uri")]
        redirect_uri: String,
    }
    #[doc(hidden)]
    #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
    const _IMPL_DESERIALIZE_FOR_OAuth: () =
        {
            #[allow(rust_2018_idioms, clippy :: useless_attribute)]
            extern crate serde as _serde;
            #[allow(unused_macros)]
            macro_rules! try {
                ($ __expr : expr) =>
                {
                    match $ __expr
                    {
                        _serde :: export :: Ok(__val) => __val, _serde ::
                        export :: Err(__err) =>
                        { return _serde :: export :: Err(__err) ; }
                    }
                }
            }
            #[automatically_derived]
            impl <'de> _serde::Deserialize<'de> for OAuth {
                fn deserialize<__D>(__deserializer: __D)
                 -> _serde::export::Result<Self, __D::Error> where
                 __D: _serde::Deserializer<'de> {
                    #[allow(non_camel_case_types)]
                    enum __Field { __field0, __field1, __field2, __ignore, }
                    struct __FieldVisitor;
                    impl <'de> _serde::de::Visitor<'de> for __FieldVisitor {
                        type Value = __Field;
                        fn expecting(&self,
                                     __formatter:
                                         &mut _serde::export::Formatter)
                         -> _serde::export::fmt::Result {
                            _serde::export::Formatter::write_str(__formatter,
                                                                 "field identifier")
                        }
                        fn visit_u64<__E>(self, __value: u64)
                         -> _serde::export::Result<Self::Value, __E> where
                         __E: _serde::de::Error {
                            match __value {
                                0u64 => _serde::export::Ok(__Field::__field0),
                                1u64 => _serde::export::Ok(__Field::__field1),
                                2u64 => _serde::export::Ok(__Field::__field2),
                                _ =>
                                _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                     &"field index 0 <= i < 3")),
                            }
                        }
                        fn visit_str<__E>(self, __value: &str)
                         -> _serde::export::Result<Self::Value, __E> where
                         __E: _serde::de::Error {
                            match __value {
                                "client_id" =>
                                _serde::export::Ok(__Field::__field0),
                                "client_secret" =>
                                _serde::export::Ok(__Field::__field1),
                                "redirect_uri" =>
                                _serde::export::Ok(__Field::__field2),
                                _ => { _serde::export::Ok(__Field::__ignore) }
                            }
                        }
                        fn visit_bytes<__E>(self, __value: &[u8])
                         -> _serde::export::Result<Self::Value, __E> where
                         __E: _serde::de::Error {
                            match __value {
                                b"client_id" =>
                                _serde::export::Ok(__Field::__field0),
                                b"client_secret" =>
                                _serde::export::Ok(__Field::__field1),
                                b"redirect_uri" =>
                                _serde::export::Ok(__Field::__field2),
                                _ => { _serde::export::Ok(__Field::__ignore) }
                            }
                        }
                    }
                    impl <'de> _serde::Deserialize<'de> for __Field {
                        #[inline]
                        fn deserialize<__D>(__deserializer: __D)
                         -> _serde::export::Result<Self, __D::Error> where
                         __D: _serde::Deserializer<'de> {
                            _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                         __FieldVisitor)
                        }
                    }
                    struct __Visitor<'de> {
                        marker: _serde::export::PhantomData<OAuth>,
                        lifetime: _serde::export::PhantomData<&'de ()>,
                    }
                    impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> {
                        type Value = OAuth;
                        fn expecting(&self,
                                     __formatter:
                                         &mut _serde::export::Formatter)
                         -> _serde::export::fmt::Result {
                            _serde::export::Formatter::write_str(__formatter,
                                                                 "struct OAuth")
                        }
                        #[inline]
                        fn visit_seq<__A>(self, mut __seq: __A)
                         -> _serde::export::Result<Self::Value, __A::Error>
                         where __A: _serde::de::SeqAccess<'de> {
                            let __field0 =
                                match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                          {
                                          _serde::export::Ok(__val) => __val,
                                          _serde::export::Err(__err) => {
                                              return _serde::export::Err(__err);
                                          }
                                      } {
                                    _serde::export::Some(__value) => __value,
                                    _serde::export::None => {
                                        return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                     &"struct OAuth with 3 elements"));
                                    }
                                };
                            let __field1 =
                                match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                          {
                                          _serde::export::Ok(__val) => __val,
                                          _serde::export::Err(__err) => {
                                              return _serde::export::Err(__err);
                                          }
                                      } {
                                    _serde::export::Some(__value) => __value,
                                    _serde::export::None => {
                                        return _serde::export::Err(_serde::de::Error::invalid_length(1usize,
                                                                                                     &"struct OAuth with 3 elements"));
                                    }
                                };
                            let __field2 =
                                match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                          {
                                          _serde::export::Ok(__val) => __val,
                                          _serde::export::Err(__err) => {
                                              return _serde::export::Err(__err);
                                          }
                                      } {
                                    _serde::export::Some(__value) => __value,
                                    _serde::export::None => {
                                        default_redirect_uri()
                                    }
                                };
                            _serde::export::Ok(OAuth{client_id: __field0,
                                                     client_secret: __field1,
                                                     redirect_uri: __field2,})
                        }
                        #[inline]
                        fn visit_map<__A>(self, mut __map: __A)
                         -> _serde::export::Result<Self::Value, __A::Error>
                         where __A: _serde::de::MapAccess<'de> {
                            let mut __field0: _serde::export::Option<String> =
                                _serde::export::None;
                            let mut __field1: _serde::export::Option<String> =
                                _serde::export::None;
                            let mut __field2: _serde::export::Option<String> =
                                _serde::export::None;
                            while let _serde::export::Some(__key) =
                                      match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                          {
                                          _serde::export::Ok(__val) => __val,
                                          _serde::export::Err(__err) => {
                                              return _serde::export::Err(__err);
                                          }
                                      } {
                                match __key {
                                    __Field::__field0 => {
                                        if _serde::export::Option::is_some(&__field0)
                                           {
                                            return _serde::export::Err(<__A::Error
                                                                           as
                                                                           _serde::de::Error>::duplicate_field("client_id"));
                                        }
                                        __field0 =
                                            _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                     {
                                                                     _serde::export::Ok(__val)
                                                                     => __val,
                                                                     _serde::export::Err(__err)
                                                                     => {
                                                                         return _serde::export::Err(__err);
                                                                     }
                                                                 });
                                    }
                                    __Field::__field1 => {
                                        if _serde::export::Option::is_some(&__field1)
                                           {
                                            return _serde::export::Err(<__A::Error
                                                                           as
                                                                           _serde::de::Error>::duplicate_field("client_secret"));
                                        }
                                        __field1 =
                                            _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                     {
                                                                     _serde::export::Ok(__val)
                                                                     => __val,
                                                                     _serde::export::Err(__err)
                                                                     => {
                                                                         return _serde::export::Err(__err);
                                                                     }
                                                                 });
                                    }
                                    __Field::__field2 => {
                                        if _serde::export::Option::is_some(&__field2)
                                           {
                                            return _serde::export::Err(<__A::Error
                                                                           as
                                                                           _serde::de::Error>::duplicate_field("redirect_uri"));
                                        }
                                        __field2 =
                                            _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                     {
                                                                     _serde::export::Ok(__val)
                                                                     => __val,
                                                                     _serde::export::Err(__err)
                                                                     => {
                                                                         return _serde::export::Err(__err);
                                                                     }
                                                                 });
                                    }
                                    _ => {
                                        let _ =
                                            match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                {
                                                _serde::export::Ok(__val) =>
                                                __val,
                                                _serde::export::Err(__err) =>
                                                {
                                                    return _serde::export::Err(__err);
                                                }
                                            };
                                    }
                                }
                            }
                            let __field0 =
                                match __field0 {
                                    _serde::export::Some(__field0) =>
                                    __field0,
                                    _serde::export::None =>
                                    match _serde::private::de::missing_field("client_id")
                                        {
                                        _serde::export::Ok(__val) => __val,
                                        _serde::export::Err(__err) => {
                                            return _serde::export::Err(__err);
                                        }
                                    },
                                };
                            let __field1 =
                                match __field1 {
                                    _serde::export::Some(__field1) =>
                                    __field1,
                                    _serde::export::None =>
                                    match _serde::private::de::missing_field("client_secret")
                                        {
                                        _serde::export::Ok(__val) => __val,
                                        _serde::export::Err(__err) => {
                                            return _serde::export::Err(__err);
                                        }
                                    },
                                };
                            let __field2 =
                                match __field2 {
                                    _serde::export::Some(__field2) =>
                                    __field2,
                                    _serde::export::None =>
                                    default_redirect_uri(),
                                };
                            _serde::export::Ok(OAuth{client_id: __field0,
                                                     client_secret: __field1,
                                                     redirect_uri: __field2,})
                        }
                    }
                    const FIELDS: &'static [&'static str] =
                        &["client_id", "client_secret", "redirect_uri"];
                    _serde::Deserializer::deserialize_struct(__deserializer,
                                                             "OAuth", FIELDS,
                                                             __Visitor{marker:
                                                                           _serde::export::PhantomData::<OAuth>,
                                                                       lifetime:
                                                                           _serde::export::PhantomData,})
                }
            }
        };
    fn default_redirect_uri() -> String { DEFAULT_REDIRECT_URI.to_string() }
    struct AccessToken {
        access_token: String,
    }
    #[doc(hidden)]
    #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
    const _IMPL_DESERIALIZE_FOR_AccessToken: () =
        {
            #[allow(rust_2018_idioms, clippy :: useless_attribute)]
            extern crate serde as _serde;
            #[allow(unused_macros)]
            macro_rules! try {
                ($ __expr : expr) =>
                {
                    match $ __expr
                    {
                        _serde :: export :: Ok(__val) => __val, _serde ::
                        export :: Err(__err) =>
                        { return _serde :: export :: Err(__err) ; }
                    }
                }
            }
            #[automatically_derived]
            impl <'de> _serde::Deserialize<'de> for AccessToken {
                fn deserialize<__D>(__deserializer: __D)
                 -> _serde::export::Result<Self, __D::Error> where
                 __D: _serde::Deserializer<'de> {
                    #[allow(non_camel_case_types)]
                    enum __Field { __field0, __ignore, }
                    struct __FieldVisitor;
                    impl <'de> _serde::de::Visitor<'de> for __FieldVisitor {
                        type Value = __Field;
                        fn expecting(&self,
                                     __formatter:
                                         &mut _serde::export::Formatter)
                         -> _serde::export::fmt::Result {
                            _serde::export::Formatter::write_str(__formatter,
                                                                 "field identifier")
                        }
                        fn visit_u64<__E>(self, __value: u64)
                         -> _serde::export::Result<Self::Value, __E> where
                         __E: _serde::de::Error {
                            match __value {
                                0u64 => _serde::export::Ok(__Field::__field0),
                                _ =>
                                _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                     &"field index 0 <= i < 1")),
                            }
                        }
                        fn visit_str<__E>(self, __value: &str)
                         -> _serde::export::Result<Self::Value, __E> where
                         __E: _serde::de::Error {
                            match __value {
                                "access_token" =>
                                _serde::export::Ok(__Field::__field0),
                                _ => { _serde::export::Ok(__Field::__ignore) }
                            }
                        }
                        fn visit_bytes<__E>(self, __value: &[u8])
                         -> _serde::export::Result<Self::Value, __E> where
                         __E: _serde::de::Error {
                            match __value {
                                b"access_token" =>
                                _serde::export::Ok(__Field::__field0),
                                _ => { _serde::export::Ok(__Field::__ignore) }
                            }
                        }
                    }
                    impl <'de> _serde::Deserialize<'de> for __Field {
                        #[inline]
                        fn deserialize<__D>(__deserializer: __D)
                         -> _serde::export::Result<Self, __D::Error> where
                         __D: _serde::Deserializer<'de> {
                            _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                         __FieldVisitor)
                        }
                    }
                    struct __Visitor<'de> {
                        marker: _serde::export::PhantomData<AccessToken>,
                        lifetime: _serde::export::PhantomData<&'de ()>,
                    }
                    impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> {
                        type Value = AccessToken;
                        fn expecting(&self,
                                     __formatter:
                                         &mut _serde::export::Formatter)
                         -> _serde::export::fmt::Result {
                            _serde::export::Formatter::write_str(__formatter,
                                                                 "struct AccessToken")
                        }
                        #[inline]
                        fn visit_seq<__A>(self, mut __seq: __A)
                         -> _serde::export::Result<Self::Value, __A::Error>
                         where __A: _serde::de::SeqAccess<'de> {
                            let __field0 =
                                match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
                                          {
                                          _serde::export::Ok(__val) => __val,
                                          _serde::export::Err(__err) => {
                                              return _serde::export::Err(__err);
                                          }
                                      } {
                                    _serde::export::Some(__value) => __value,
                                    _serde::export::None => {
                                        return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
                                                                                                     &"struct AccessToken with 1 element"));
                                    }
                                };
                            _serde::export::Ok(AccessToken{access_token:
                                                               __field0,})
                        }
                        #[inline]
                        fn visit_map<__A>(self, mut __map: __A)
                         -> _serde::export::Result<Self::Value, __A::Error>
                         where __A: _serde::de::MapAccess<'de> {
                            let mut __field0: _serde::export::Option<String> =
                                _serde::export::None;
                            while let _serde::export::Some(__key) =
                                      match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                          {
                                          _serde::export::Ok(__val) => __val,
                                          _serde::export::Err(__err) => {
                                              return _serde::export::Err(__err);
                                          }
                                      } {
                                match __key {
                                    __Field::__field0 => {
                                        if _serde::export::Option::is_some(&__field0)
                                           {
                                            return _serde::export::Err(<__A::Error
                                                                           as
                                                                           _serde::de::Error>::duplicate_field("access_token"));
                                        }
                                        __field0 =
                                            _serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
                                                                     {
                                                                     _serde::export::Ok(__val)
                                                                     => __val,
                                                                     _serde::export::Err(__err)
                                                                     => {
                                                                         return _serde::export::Err(__err);
                                                                     }
                                                                 });
                                    }
                                    _ => {
                                        let _ =
                                            match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
                                                {
                                                _serde::export::Ok(__val) =>
                                                __val,
                                                _serde::export::Err(__err) =>
                                                {
                                                    return _serde::export::Err(__err);
                                                }
                                            };
                                    }
                                }
                            }
                            let __field0 =
                                match __field0 {
                                    _serde::export::Some(__field0) =>
                                    __field0,
                                    _serde::export::None =>
                                    match _serde::private::de::missing_field("access_token")
                                        {
                                        _serde::export::Ok(__val) => __val,
                                        _serde::export::Err(__err) => {
                                            return _serde::export::Err(__err);
                                        }
                                    },
                                };
                            _serde::export::Ok(AccessToken{access_token:
                                                               __field0,})
                        }
                    }
                    const FIELDS: &'static [&'static str] = &["access_token"];
                    _serde::Deserializer::deserialize_struct(__deserializer,
                                                             "AccessToken",
                                                             FIELDS,
                                                             __Visitor{marker:
                                                                           _serde::export::PhantomData::<AccessToken>,
                                                                       lifetime:
                                                                           _serde::export::PhantomData,})
                }
            }
        };
    impl <'a> Registration<'a> {
        /// Construct a new registration process to the instance of the `base` url.
        /// ```
        /// use elefren::prelude::*;
        ///
        /// let registration = Registration::new("https://mastodon.social");
        /// ```
        pub fn new<I: Into<String>>(base: I) -> Self {
            Registration{base: base.into(),
                         client: Client::new(),
                         app_builder: AppBuilder::new(),
                         force_login: false,}
        }
    }
    impl <'a> Registration<'a> {
        /// Sets the name of this app
        ///
        /// This is required, and if this isn't set then the AppBuilder::build
        /// method will fail
        pub fn client_name<I: Into<Cow<'a, str>>>(&mut self, name: I)
         -> &mut Self {
            self.app_builder.client_name(name.into());
            self
        }
        /// Sets the redirect uris that this app uses
        pub fn redirect_uris<I: Into<Cow<'a, str>>>(&mut self, uris: I)
         -> &mut Self {
            self.app_builder.redirect_uris(uris);
            self
        }
        /// Sets the scopes that this app requires
        ///
        /// The default for an app is Scopes::Read
        pub fn scopes(&mut self, scopes: Scopes) -> &mut Self {
            self.app_builder.scopes(scopes);
            self
        }
        /// Sets the optional "website" to register the app with
        pub fn website<I: Into<Cow<'a, str>>>(&mut self, website: I)
         -> &mut Self {
            self.app_builder.website(website);
            self
        }
        /// Forces the user to re-login (useful if you need to re-auth as a
        /// different user on the same instance
        pub fn force_login(&mut self, force_login: bool) -> &mut Self {
            self.force_login = force_login;
            self
        }
        fn send(&self, req: RequestBuilder) -> Result<Response> {
            let req = req.build()?;
            Ok(self.client.execute(req)?)
        }
        /// Register the given application
        ///
        /// ```no_run
        /// # extern crate elefren;
        /// # fn main () -> elefren::Result<()> {
        /// use elefren::{apps::App, prelude::*};
        ///
        /// let mut app = App::builder();
        /// app.client_name("elefren_test");
        ///
        /// let registration = Registration::new("https://mastodon.social").register(app)?;
        /// let url = registration.authorize_url()?;
        /// // Here you now need to open the url in the browser
        /// // And handle a the redirect url coming back with the code.
        /// let code = String::from("RETURNED_FROM_BROWSER");
        /// let mastodon = registration.complete(&code)?;
        ///
        /// println!("{:?}", mastodon.get_home_timeline()?.initial_items);
        /// # Ok(())
        /// # }
        /// ```
        pub fn register<I: TryInto<App>>(&mut self, app: I)
         -> Result<Registered> where Error: From<<I as TryInto<App>>::Err> {
            let app = app.try_into()?;
            let oauth = self.send_app(&app)?;
            Ok(Registered{base: self.base.clone(),
                          client: self.client.clone(),
                          client_id: oauth.client_id,
                          client_secret: oauth.client_secret,
                          redirect: oauth.redirect_uri,
                          scopes: app.scopes().clone(),
                          force_login: self.force_login,})
        }
        /// Register the application with the server from the `base` url.
        ///
        /// ```no_run
        /// # extern crate elefren;
        /// # fn main () -> elefren::Result<()> {
        /// use elefren::prelude::*;
        ///
        /// let registration = Registration::new("https://mastodon.social")
        ///     .client_name("elefren_test")
        ///     .build()?;
        /// let url = registration.authorize_url()?;
        /// // Here you now need to open the url in the browser
        /// // And handle a the redirect url coming back with the code.
        /// let code = String::from("RETURNED_FROM_BROWSER");
        /// let mastodon = registration.complete(&code)?;
        ///
        /// println!("{:?}", mastodon.get_home_timeline()?.initial_items);
        /// # Ok(())
        /// # }
        /// ```
        pub fn build(&mut self) -> Result<Registered> {
            let app: App = self.app_builder.clone().build()?;
            let oauth = self.send_app(&app)?;
            Ok(Registered{base: self.base.clone(),
                          client: self.client.clone(),
                          client_id: oauth.client_id,
                          client_secret: oauth.client_secret,
                          redirect: oauth.redirect_uri,
                          scopes: app.scopes().clone(),
                          force_login: self.force_login,})
        }
        fn send_app(&self, app: &App) -> Result<OAuth> {
            let url =
                {
                    let res =
                        ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["",
                                                                              "/api/v1/apps"],
                                                                            &match (&self.base,)
                                                                                 {
                                                                                 (arg0,)
                                                                                 =>
                                                                                 [::core::fmt::ArgumentV1::new(arg0,
                                                                                                               ::core::fmt::Display::fmt)],
                                                                             }));
                    res
                };
            Ok(self.send(self.client.post(&url).json(&app))?.json()?)
        }
    }
    impl Registered {
        /// Skip having to retrieve the client id and secret from the server by
        /// creating a `Registered` struct directly
        ///
        /// # Example
        ///
        /// ```no_run
        /// # extern crate elefren;
        /// # fn main() -> elefren::Result<()> {
        /// use elefren::{prelude::*, registration::Registered};
        ///
        /// let registration = Registered::from_parts(
        ///     "https://example.com",
        ///     "the-client-id",
        ///     "the-client-secret",
        ///     "https://example.com/redirect",
        ///     Scopes::read_all(),
        ///     false,
        /// );
        /// let url = registration.authorize_url()?;
        /// // Here you now need to open the url in the browser
        /// // And handle a the redirect url coming back with the code.
        /// let code = String::from("RETURNED_FROM_BROWSER");
        /// let mastodon = registration.complete(&code)?;
        ///
        /// println!("{:?}", mastodon.get_home_timeline()?.initial_items);
        /// #   Ok(())
        /// # }
        /// ```
        pub fn from_parts(base: &str, client_id: &str, client_secret: &str,
                          redirect: &str, scopes: Scopes, force_login: bool)
         -> Registered {
            Registered{base: base.to_string(),
                       client: Client::new(),
                       client_id: client_id.to_string(),
                       client_secret: client_secret.to_string(),
                       redirect: redirect.to_string(),
                       scopes,
                       force_login,}
        }
    }
    impl Registered {
        fn send(&self, req: RequestBuilder) -> Result<Response> {
            let req = req.build()?;
            Ok(self.client.execute(req)?)
        }
        /// Returns the parts of the `Registered` struct that can be used to
        /// recreate another `Registered` struct
        ///
        /// # Example
        ///
        /// ```
        /// # extern crate elefren;
        /// use elefren::{prelude::*, registration::Registered};
        /// # fn main() -> Result<(), Box<std::error::Error>> {
        ///
        /// let origbase = "https://example.social";
        /// let origclient_id = "some-client_id";
        /// let origclient_secret = "some-client-secret";
        /// let origredirect = "https://example.social/redirect";
        /// let origscopes = Scopes::all();
        /// let origforce_login = false;
        ///
        /// let registered = Registered::from_parts(
        ///     origbase,
        ///     origclient_id,
        ///     origclient_secret,
        ///     origredirect,
        ///     origscopes.clone(),
        ///     origforce_login,
        /// );
        ///
        /// let (base, client_id, client_secret, redirect, scopes, force_login) = registered.into_parts();
        ///
        /// assert_eq!(origbase, &base);
        /// assert_eq!(origclient_id, &client_id);
        /// assert_eq!(origclient_secret, &client_secret);
        /// assert_eq!(origredirect, &redirect);
        /// assert_eq!(origscopes, scopes);
        /// assert_eq!(origforce_login, force_login);
        /// #   Ok(())
        /// # }
        /// ```
        pub fn into_parts(self)
         -> (String, String, String, String, Scopes, bool) {
            (self.base, self.client_id, self.client_secret, self.redirect,
             self.scopes, self.force_login)
        }
        /// Returns the full url needed for authorisation. This needs to be opened
        /// in a browser.
        pub fn authorize_url(&self) -> Result<String> {
            let scopes =
                {
                    let res =
                        ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&[""],
                                                                            &match (&self.scopes,)
                                                                                 {
                                                                                 (arg0,)
                                                                                 =>
                                                                                 [::core::fmt::ArgumentV1::new(arg0,
                                                                                                               ::core::fmt::Display::fmt)],
                                                                             }));
                    res
                };
            let scopes: String =
                utf8_percent_encode(&scopes, DEFAULT_ENCODE_SET).collect();
            let url =
                if self.force_login {
                    {
                        let res =
                            ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["",
                                                                                  "/oauth/authorize?client_id=",
                                                                                  "&redirect_uri=",
                                                                                  "&scope=",
                                                                                  "&force_login=true&response_type=code"],
                                                                                &match (&self.base,
                                                                                        &self.client_id,
                                                                                        &self.redirect,
                                                                                        &scopes)
                                                                                     {
                                                                                     (arg0,
                                                                                      arg1,
                                                                                      arg2,
                                                                                      arg3)
                                                                                     =>
                                                                                     [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                   ::core::fmt::Display::fmt),
                                                                                      ::core::fmt::ArgumentV1::new(arg1,
                                                                                                                   ::core::fmt::Display::fmt),
                                                                                      ::core::fmt::ArgumentV1::new(arg2,
                                                                                                                   ::core::fmt::Display::fmt),
                                                                                      ::core::fmt::ArgumentV1::new(arg3,
                                                                                                                   ::core::fmt::Display::fmt)],
                                                                                 }));
                        res
                    }
                } else {
                    {
                        let res =
                            ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["",
                                                                                  "/oauth/authorize?client_id=",
                                                                                  "&redirect_uri=",
                                                                                  "&scope=",
                                                                                  "&response_type=code"],
                                                                                &match (&self.base,
                                                                                        &self.client_id,
                                                                                        &self.redirect,
                                                                                        &scopes)
                                                                                     {
                                                                                     (arg0,
                                                                                      arg1,
                                                                                      arg2,
                                                                                      arg3)
                                                                                     =>
                                                                                     [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                   ::core::fmt::Display::fmt),
                                                                                      ::core::fmt::ArgumentV1::new(arg1,
                                                                                                                   ::core::fmt::Display::fmt),
                                                                                      ::core::fmt::ArgumentV1::new(arg2,
                                                                                                                   ::core::fmt::Display::fmt),
                                                                                      ::core::fmt::ArgumentV1::new(arg3,
                                                                                                                   ::core::fmt::Display::fmt)],
                                                                                 }));
                        res
                    }
                };
            Ok(url)
        }
        /// Create an access token from the client id, client secret, and code
        /// provided by the authorisation url.
        pub fn complete(&self, code: &str) -> Result<Mastodon> {
            let url =
                {
                    let res =
                        ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["",
                                                                              "/oauth/token?client_id=",
                                                                              "&client_secret=",
                                                                              "&code=",
                                                                              "&grant_type=authorization_code&redirect_uri="],
                                                                            &match (&self.base,
                                                                                    &self.client_id,
                                                                                    &self.client_secret,
                                                                                    &code,
                                                                                    &self.redirect)
                                                                                 {
                                                                                 (arg0,
                                                                                  arg1,
                                                                                  arg2,
                                                                                  arg3,
                                                                                  arg4)
                                                                                 =>
                                                                                 [::core::fmt::ArgumentV1::new(arg0,
                                                                                                               ::core::fmt::Display::fmt),
                                                                                  ::core::fmt::ArgumentV1::new(arg1,
                                                                                                               ::core::fmt::Display::fmt),
                                                                                  ::core::fmt::ArgumentV1::new(arg2,
                                                                                                               ::core::fmt::Display::fmt),
                                                                                  ::core::fmt::ArgumentV1::new(arg3,
                                                                                                               ::core::fmt::Display::fmt),
                                                                                  ::core::fmt::ArgumentV1::new(arg4,
                                                                                                               ::core::fmt::Display::fmt)],
                                                                             }));
                    res
                };
            let token: AccessToken =
                self.send(self.client.post(&url))?.json()?;
            let data =
                Data{base: self.base.clone().into(),
                     client_id: self.client_id.clone().into(),
                     client_secret: self.client_secret.clone().into(),
                     redirect: self.redirect.clone().into(),
                     token: token.access_token.into(),};
            let mut builder = MastodonBuilder::new();
            builder.client(self.client.clone()).data(data);
            Ok(builder.build()?)
        }
    }
    /// Represents the state of the auth flow when the app has been registered but
    /// the user is not authenticated
    pub struct Registered {
        base: String,
        client: Client,
        client_id: String,
        client_secret: String,
        redirect: String,
        scopes: Scopes,
        force_login: bool,
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::fmt::Debug for Registered {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            match *self {
                Registered {
                base: ref __self_0_0,
                client: ref __self_0_1,
                client_id: ref __self_0_2,
                client_secret: ref __self_0_3,
                redirect: ref __self_0_4,
                scopes: ref __self_0_5,
                force_login: ref __self_0_6 } => {
                    let mut debug_trait_builder =
                        f.debug_struct("Registered");
                    let _ =
                        debug_trait_builder.field("base", &&(*__self_0_0));
                    let _ =
                        debug_trait_builder.field("client", &&(*__self_0_1));
                    let _ =
                        debug_trait_builder.field("client_id",
                                                  &&(*__self_0_2));
                    let _ =
                        debug_trait_builder.field("client_secret",
                                                  &&(*__self_0_3));
                    let _ =
                        debug_trait_builder.field("redirect",
                                                  &&(*__self_0_4));
                    let _ =
                        debug_trait_builder.field("scopes", &&(*__self_0_5));
                    let _ =
                        debug_trait_builder.field("force_login",
                                                  &&(*__self_0_6));
                    debug_trait_builder.finish()
                }
            }
        }
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::clone::Clone for Registered {
        #[inline]
        fn clone(&self) -> Registered {
            match *self {
                Registered {
                base: ref __self_0_0,
                client: ref __self_0_1,
                client_id: ref __self_0_2,
                client_secret: ref __self_0_3,
                redirect: ref __self_0_4,
                scopes: ref __self_0_5,
                force_login: ref __self_0_6 } =>
                Registered{base: ::core::clone::Clone::clone(&(*__self_0_0)),
                           client:
                               ::core::clone::Clone::clone(&(*__self_0_1)),
                           client_id:
                               ::core::clone::Clone::clone(&(*__self_0_2)),
                           client_secret:
                               ::core::clone::Clone::clone(&(*__self_0_3)),
                           redirect:
                               ::core::clone::Clone::clone(&(*__self_0_4)),
                           scopes:
                               ::core::clone::Clone::clone(&(*__self_0_5)),
                           force_login:
                               ::core::clone::Clone::clone(&(*__self_0_6)),},
            }
        }
    }
}
/// Requests
pub mod requests {
    /// Data structure for the MastodonClient::add_filter method
    pub use self::filter::AddFilterRequest;
    /// Data structure for the MastodonClient::add_push_subscription method
    pub use self::push::{AddPushRequest, Keys, UpdatePushRequest};
    /// Data structure for the MastodonClient::statuses method
    pub use self::statuses::StatusesRequest;
    /// Data structure for the MastodonClient::update_credentials method
    pub use self::update_credentials::UpdateCredsRequest;
    mod filter {
        use crate::entities::filter::FilterContext;
        use std::time::Duration;
        /// Form used to create a filter
        ///
        /// # Example
        ///
        /// ```
        /// # extern crate elefren;
        /// # use std::error::Error;
        /// use elefren::{entities::filter::FilterContext, requests::AddFilterRequest};
        /// # fn main() -> Result<(), Box<Error>> {
        /// let request = AddFilterRequest::new("foo", FilterContext::Home);
        /// #   Ok(())
        /// # }
        /// ```
        pub struct AddFilterRequest {
            phrase: String,
            context: FilterContext,
            irreversible: Option<bool>,
            whole_word: Option<bool>,
            #[serde(serialize_with = "serialize_duration::ser")]
            expires_in: Option<Duration>,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for AddFilterRequest {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    AddFilterRequest {
                    phrase: ref __self_0_0,
                    context: ref __self_0_1,
                    irreversible: ref __self_0_2,
                    whole_word: ref __self_0_3,
                    expires_in: ref __self_0_4 } => {
                        let mut debug_trait_builder =
                            f.debug_struct("AddFilterRequest");
                        let _ =
                            debug_trait_builder.field("phrase",
                                                      &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("context",
                                                      &&(*__self_0_1));
                        let _ =
                            debug_trait_builder.field("irreversible",
                                                      &&(*__self_0_2));
                        let _ =
                            debug_trait_builder.field("whole_word",
                                                      &&(*__self_0_3));
                        let _ =
                            debug_trait_builder.field("expires_in",
                                                      &&(*__self_0_4));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for AddFilterRequest {
            #[inline]
            fn clone(&self) -> AddFilterRequest {
                match *self {
                    AddFilterRequest {
                    phrase: ref __self_0_0,
                    context: ref __self_0_1,
                    irreversible: ref __self_0_2,
                    whole_word: ref __self_0_3,
                    expires_in: ref __self_0_4 } =>
                    AddFilterRequest{phrase:
                                         ::core::clone::Clone::clone(&(*__self_0_0)),
                                     context:
                                         ::core::clone::Clone::clone(&(*__self_0_1)),
                                     irreversible:
                                         ::core::clone::Clone::clone(&(*__self_0_2)),
                                     whole_word:
                                         ::core::clone::Clone::clone(&(*__self_0_3)),
                                     expires_in:
                                         ::core::clone::Clone::clone(&(*__self_0_4)),},
                }
            }
        }
        impl ::core::marker::StructuralPartialEq for AddFilterRequest { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for AddFilterRequest {
            #[inline]
            fn eq(&self, other: &AddFilterRequest) -> bool {
                match *other {
                    AddFilterRequest {
                    phrase: ref __self_1_0,
                    context: ref __self_1_1,
                    irreversible: ref __self_1_2,
                    whole_word: ref __self_1_3,
                    expires_in: ref __self_1_4 } =>
                    match *self {
                        AddFilterRequest {
                        phrase: ref __self_0_0,
                        context: ref __self_0_1,
                        irreversible: ref __self_0_2,
                        whole_word: ref __self_0_3,
                        expires_in: ref __self_0_4 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1) &&
                            (*__self_0_2) == (*__self_1_2) &&
                            (*__self_0_3) == (*__self_1_3) &&
                            (*__self_0_4) == (*__self_1_4),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &AddFilterRequest) -> bool {
                match *other {
                    AddFilterRequest {
                    phrase: ref __self_1_0,
                    context: ref __self_1_1,
                    irreversible: ref __self_1_2,
                    whole_word: ref __self_1_3,
                    expires_in: ref __self_1_4 } =>
                    match *self {
                        AddFilterRequest {
                        phrase: ref __self_0_0,
                        context: ref __self_0_1,
                        irreversible: ref __self_0_2,
                        whole_word: ref __self_0_3,
                        expires_in: ref __self_0_4 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1) ||
                            (*__self_0_2) != (*__self_1_2) ||
                            (*__self_0_3) != (*__self_1_3) ||
                            (*__self_0_4) != (*__self_1_4),
                    },
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_SERIALIZE_FOR_AddFilterRequest: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl _serde::Serialize for AddFilterRequest {
                    fn serialize<__S>(&self, __serializer: __S)
                     -> _serde::export::Result<__S::Ok, __S::Error> where
                     __S: _serde::Serializer {
                        let mut __serde_state =
                            match _serde::Serializer::serialize_struct(__serializer,
                                                                       "AddFilterRequest",
                                                                       false
                                                                           as
                                                                           usize
                                                                           + 1
                                                                           + 1
                                                                           + 1
                                                                           + 1
                                                                           +
                                                                           1)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "phrase",
                                                                            &self.phrase)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "context",
                                                                            &self.context)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "irreversible",
                                                                            &self.irreversible)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "whole_word",
                                                                            &self.whole_word)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "expires_in",
                                                                            {
                                                                                struct __SerializeWith<'__a> {
                                                                                    values: (&'__a Option<Duration>,),
                                                                                    phantom: _serde::export::PhantomData<AddFilterRequest>,
                                                                                }
                                                                                impl <'__a>
                                                                                 _serde::Serialize
                                                                                 for
                                                                                 __SerializeWith<'__a>
                                                                                 {
                                                                                    fn serialize<__S>(&self,
                                                                                                      __s:
                                                                                                          __S)
                                                                                     ->
                                                                                         _serde::export::Result<__S::Ok,
                                                                                                                __S::Error>
                                                                                     where
                                                                                     __S: _serde::Serializer {
                                                                                        serialize_duration::ser(self.values.0,
                                                                                                                __s)
                                                                                    }
                                                                                }
                                                                                &__SerializeWith{values:
                                                                                                     (&self.expires_in,),
                                                                                                 phantom:
                                                                                                     _serde::export::PhantomData::<AddFilterRequest>,}
                                                                            })
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        _serde::ser::SerializeStruct::end(__serde_state)
                    }
                }
            };
        impl AddFilterRequest {
            /// Create a new AddFilterRequest
            pub fn new(phrase: &str, context: FilterContext)
             -> AddFilterRequest {
                AddFilterRequest{phrase: phrase.to_string(),
                                 context,
                                 irreversible: None,
                                 whole_word: None,
                                 expires_in: None,}
            }
            /// Set `irreversible` to `true`
            pub fn irreversible(&mut self) -> &mut Self {
                self.irreversible = Some(true);
                self
            }
            /// Set `whole_word` to `true`
            pub fn whole_word(&mut self) -> &mut Self {
                self.whole_word = Some(true);
                self
            }
            /// Set `expires_in` to a duration
            pub fn expires_in(&mut self, d: Duration) -> &mut Self {
                self.expires_in = Some(d);
                self
            }
        }
        mod serialize_duration {
            use serde::ser::Serializer;
            use std::time::Duration;
            pub(crate) fn ser<S>(duration: &Option<Duration>, s: S)
             -> Result<S::Ok, S::Error> where S: Serializer {
                if let Some(d) = duration {
                    let sec = d.as_secs();
                    s.serialize_u64(sec)
                } else { s.serialize_none() }
            }
        }
    }
    mod push {
        use crate::entities::push::{add_subscription, update_data};
        use crate::errors::Result;
        /// Container for the key & auth strings for an AddPushRequest
        ///
        /// # Example
        ///
        /// ```
        /// # extern crate elefren;
        /// use elefren::requests::Keys;
        ///
        /// let keys = Keys::new("anetohias===", "oeatssah=");
        /// ```
        pub struct Keys {
            pub(crate) p256dh: String,
            pub(crate) auth: String,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for Keys {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    Keys { p256dh: ref __self_0_0, auth: ref __self_0_1 } => {
                        let mut debug_trait_builder = f.debug_struct("Keys");
                        let _ =
                            debug_trait_builder.field("p256dh",
                                                      &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("auth",
                                                      &&(*__self_0_1));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::default::Default for Keys {
            #[inline]
            fn default() -> Keys {
                Keys{p256dh: ::core::default::Default::default(),
                     auth: ::core::default::Default::default(),}
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for Keys {
            #[inline]
            fn clone(&self) -> Keys {
                match *self {
                    Keys { p256dh: ref __self_0_0, auth: ref __self_0_1 } =>
                    Keys{p256dh: ::core::clone::Clone::clone(&(*__self_0_0)),
                         auth: ::core::clone::Clone::clone(&(*__self_0_1)),},
                }
            }
        }
        impl ::core::marker::StructuralPartialEq for Keys { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for Keys {
            #[inline]
            fn eq(&self, other: &Keys) -> bool {
                match *other {
                    Keys { p256dh: ref __self_1_0, auth: ref __self_1_1 } =>
                    match *self {
                        Keys { p256dh: ref __self_0_0, auth: ref __self_0_1 }
                        =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &Keys) -> bool {
                match *other {
                    Keys { p256dh: ref __self_1_0, auth: ref __self_1_1 } =>
                    match *self {
                        Keys { p256dh: ref __self_0_0, auth: ref __self_0_1 }
                        =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1),
                    },
                }
            }
        }
        impl Keys {
            /// Create the `Keys` container
            ///
            /// # Example
            ///
            /// ```
            /// # extern crate elefren;
            /// use elefren::requests::Keys;
            ///
            /// let keys = Keys::new("anetohias===", "oeatssah=");
            /// ```
            pub fn new(p256dh: &str, auth: &str) -> Keys {
                Keys{p256dh: p256dh.to_string(), auth: auth.to_string(),}
            }
        }
        /// Builder to pass to the Mastodon::add_push_subscription method
        ///
        /// # Example
        ///
        /// ```no_run
        /// # extern crate elefren;
        /// # use elefren::{MastodonClient, Mastodon, Data};
        /// # fn main() -> Result<(), elefren::Error> {
        /// # let data = Data {
        /// #   base: "".into(),
        /// #   client_id: "".into(),
        /// #   client_secret: "".into(),
        /// #   redirect: "".into(),
        /// #   token: "".into(),
        /// # };
        /// use elefren::requests::{AddPushRequest, Keys};
        ///
        /// let client = Mastodon::from(data);
        ///
        /// let keys = Keys::new("stahesuahoei293ise===", "tasecoa,nmeozka==");
        /// let mut request = AddPushRequest::new("http://example.com/push/endpoint", &keys);
        /// request.follow().reblog();
        ///
        /// client.add_push_subscription(&request)?;
        /// #   Ok(())
        /// # }
        /// ```
        pub struct AddPushRequest {
            endpoint: String,
            p256dh: String,
            auth: String,
            follow: Option<bool>,
            favourite: Option<bool>,
            reblog: Option<bool>,
            mention: Option<bool>,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for AddPushRequest {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    AddPushRequest {
                    endpoint: ref __self_0_0,
                    p256dh: ref __self_0_1,
                    auth: ref __self_0_2,
                    follow: ref __self_0_3,
                    favourite: ref __self_0_4,
                    reblog: ref __self_0_5,
                    mention: ref __self_0_6 } => {
                        let mut debug_trait_builder =
                            f.debug_struct("AddPushRequest");
                        let _ =
                            debug_trait_builder.field("endpoint",
                                                      &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("p256dh",
                                                      &&(*__self_0_1));
                        let _ =
                            debug_trait_builder.field("auth",
                                                      &&(*__self_0_2));
                        let _ =
                            debug_trait_builder.field("follow",
                                                      &&(*__self_0_3));
                        let _ =
                            debug_trait_builder.field("favourite",
                                                      &&(*__self_0_4));
                        let _ =
                            debug_trait_builder.field("reblog",
                                                      &&(*__self_0_5));
                        let _ =
                            debug_trait_builder.field("mention",
                                                      &&(*__self_0_6));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::default::Default for AddPushRequest {
            #[inline]
            fn default() -> AddPushRequest {
                AddPushRequest{endpoint: ::core::default::Default::default(),
                               p256dh: ::core::default::Default::default(),
                               auth: ::core::default::Default::default(),
                               follow: ::core::default::Default::default(),
                               favourite: ::core::default::Default::default(),
                               reblog: ::core::default::Default::default(),
                               mention: ::core::default::Default::default(),}
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for AddPushRequest {
            #[inline]
            fn clone(&self) -> AddPushRequest {
                match *self {
                    AddPushRequest {
                    endpoint: ref __self_0_0,
                    p256dh: ref __self_0_1,
                    auth: ref __self_0_2,
                    follow: ref __self_0_3,
                    favourite: ref __self_0_4,
                    reblog: ref __self_0_5,
                    mention: ref __self_0_6 } =>
                    AddPushRequest{endpoint:
                                       ::core::clone::Clone::clone(&(*__self_0_0)),
                                   p256dh:
                                       ::core::clone::Clone::clone(&(*__self_0_1)),
                                   auth:
                                       ::core::clone::Clone::clone(&(*__self_0_2)),
                                   follow:
                                       ::core::clone::Clone::clone(&(*__self_0_3)),
                                   favourite:
                                       ::core::clone::Clone::clone(&(*__self_0_4)),
                                   reblog:
                                       ::core::clone::Clone::clone(&(*__self_0_5)),
                                   mention:
                                       ::core::clone::Clone::clone(&(*__self_0_6)),},
                }
            }
        }
        impl ::core::marker::StructuralPartialEq for AddPushRequest { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for AddPushRequest {
            #[inline]
            fn eq(&self, other: &AddPushRequest) -> bool {
                match *other {
                    AddPushRequest {
                    endpoint: ref __self_1_0,
                    p256dh: ref __self_1_1,
                    auth: ref __self_1_2,
                    follow: ref __self_1_3,
                    favourite: ref __self_1_4,
                    reblog: ref __self_1_5,
                    mention: ref __self_1_6 } =>
                    match *self {
                        AddPushRequest {
                        endpoint: ref __self_0_0,
                        p256dh: ref __self_0_1,
                        auth: ref __self_0_2,
                        follow: ref __self_0_3,
                        favourite: ref __self_0_4,
                        reblog: ref __self_0_5,
                        mention: ref __self_0_6 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1) &&
                            (*__self_0_2) == (*__self_1_2) &&
                            (*__self_0_3) == (*__self_1_3) &&
                            (*__self_0_4) == (*__self_1_4) &&
                            (*__self_0_5) == (*__self_1_5) &&
                            (*__self_0_6) == (*__self_1_6),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &AddPushRequest) -> bool {
                match *other {
                    AddPushRequest {
                    endpoint: ref __self_1_0,
                    p256dh: ref __self_1_1,
                    auth: ref __self_1_2,
                    follow: ref __self_1_3,
                    favourite: ref __self_1_4,
                    reblog: ref __self_1_5,
                    mention: ref __self_1_6 } =>
                    match *self {
                        AddPushRequest {
                        endpoint: ref __self_0_0,
                        p256dh: ref __self_0_1,
                        auth: ref __self_0_2,
                        follow: ref __self_0_3,
                        favourite: ref __self_0_4,
                        reblog: ref __self_0_5,
                        mention: ref __self_0_6 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1) ||
                            (*__self_0_2) != (*__self_1_2) ||
                            (*__self_0_3) != (*__self_1_3) ||
                            (*__self_0_4) != (*__self_1_4) ||
                            (*__self_0_5) != (*__self_1_5) ||
                            (*__self_0_6) != (*__self_1_6),
                    },
                }
            }
        }
        impl AddPushRequest {
            /// Construct a new AddPushRequest
            ///
            /// # Example
            ///
            /// ```
            /// # extern crate elefren;
            /// use elefren::requests::{AddPushRequest, Keys};
            /// let keys = Keys::new("abcdef===", "foobar==");
            /// let push_endpoint = "https://example.com/push/endpoint";
            /// let request = AddPushRequest::new(push_endpoint, &keys);
            /// ```
            pub fn new(endpoint: &str, keys: &Keys) -> AddPushRequest {
                AddPushRequest{endpoint: endpoint.to_string(),
                               p256dh: keys.p256dh.clone(),
                               auth: keys.auth.clone(), ..Default::default()}
            }
            /// A flag that indicates if you want follow notifications pushed
            ///
            /// # Example
            /// ```
            /// # extern crate elefren;
            /// use elefren::requests::{AddPushRequest, Keys};
            /// let keys = Keys::new("abcdef===", "foobar==");
            /// let push_endpoint = "https://example.com/push/endpoint";
            /// let mut request = AddPushRequest::new(push_endpoint, &keys);
            /// request.follow();
            /// ```
            pub fn follow(&mut self) -> &mut Self {
                self.follow = Some(true);
                self
            }
            /// A flag that indicates if you want favourite notifications pushed
            ///
            /// # Example
            /// ```
            /// # extern crate elefren;
            /// use elefren::requests::{AddPushRequest, Keys};
            /// let keys = Keys::new("abcdef===", "foobar==");
            /// let push_endpoint = "https://example.com/push/endpoint";
            /// let mut request = AddPushRequest::new(push_endpoint, &keys);
            /// request.favourite();
            /// ```
            pub fn favourite(&mut self) -> &mut Self {
                self.favourite = Some(true);
                self
            }
            /// A flag that indicates if you want reblog notifications pushed
            ///
            /// # Example
            /// ```
            /// # extern crate elefren;
            /// use elefren::requests::{AddPushRequest, Keys};
            /// let keys = Keys::new("abcdef===", "foobar==");
            /// let push_endpoint = "https://example.com/push/endpoint";
            /// let mut request = AddPushRequest::new(push_endpoint, &keys);
            /// request.reblog();
            /// ```
            pub fn reblog(&mut self) -> &mut Self {
                self.reblog = Some(true);
                self
            }
            /// A flag that indicates if you want mention notifications pushed
            ///
            /// # Example
            /// ```
            /// # extern crate elefren;
            /// use elefren::requests::{AddPushRequest, Keys};
            /// let keys = Keys::new("abcdef===", "foobar==");
            /// let push_endpoint = "https://example.com/push/endpoint";
            /// let mut request = AddPushRequest::new(push_endpoint, &keys);
            /// request.mention();
            /// ```
            pub fn mention(&mut self) -> &mut Self {
                self.mention = Some(true);
                self
            }
            fn flags_present(&self) -> bool {
                self.follow.is_some() || self.favourite.is_some() ||
                    self.reblog.is_some() || self.mention.is_some()
            }
            pub(crate) fn build(&self) -> Result<add_subscription::Form> {
                use crate::entities::push::{add_subscription::{Data, Form,
                                                               Keys,
                                                               Subscription},
                                            Alerts};
                let mut form =
                    Form{subscription:
                             Subscription{endpoint: self.endpoint.clone(),
                                          keys:
                                              Keys{p256dh:
                                                       self.p256dh.clone(),
                                                   auth:
                                                       self.auth.clone(),},},
                         data: None,};
                if self.flags_present() {
                    let mut alerts = Alerts::default();
                    if let Some(follow) = self.follow {
                        alerts.follow = Some(follow);
                    }
                    if let Some(favourite) = self.favourite {
                        alerts.favourite = Some(favourite);
                    }
                    if let Some(reblog) = self.reblog {
                        alerts.reblog = Some(reblog);
                    }
                    if let Some(mention) = self.mention {
                        alerts.mention = Some(mention);
                    }
                    form.data = Some(Data{alerts: Some(alerts),});
                }
                Ok(form)
            }
        }
        /// Builder to pass to the Mastodon::update_push_data method
        ///
        /// # Example
        ///
        /// ```no_run
        /// # extern crate elefren;
        /// # use elefren::{MastodonClient, Mastodon, Data};
        /// # fn main() -> Result<(), elefren::Error> {
        /// # let data = Data {
        /// #   base: "".into(),
        /// #   client_id: "".into(),
        /// #   client_secret: "".into(),
        /// #   redirect: "".into(),
        /// #   token: "".into(),
        /// # };
        /// use elefren::requests::UpdatePushRequest;
        ///
        /// let client = Mastodon::from(data);
        ///
        /// let mut request = UpdatePushRequest::new("foobar");
        /// request.follow(true).reblog(true);
        ///
        /// client.update_push_data(&request)?;
        /// #   Ok(())
        /// # }
        /// ```
        pub struct UpdatePushRequest {
            id: String,
            follow: Option<bool>,
            favourite: Option<bool>,
            reblog: Option<bool>,
            mention: Option<bool>,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for UpdatePushRequest {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    UpdatePushRequest {
                    id: ref __self_0_0,
                    follow: ref __self_0_1,
                    favourite: ref __self_0_2,
                    reblog: ref __self_0_3,
                    mention: ref __self_0_4 } => {
                        let mut debug_trait_builder =
                            f.debug_struct("UpdatePushRequest");
                        let _ =
                            debug_trait_builder.field("id", &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("follow",
                                                      &&(*__self_0_1));
                        let _ =
                            debug_trait_builder.field("favourite",
                                                      &&(*__self_0_2));
                        let _ =
                            debug_trait_builder.field("reblog",
                                                      &&(*__self_0_3));
                        let _ =
                            debug_trait_builder.field("mention",
                                                      &&(*__self_0_4));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::default::Default for UpdatePushRequest {
            #[inline]
            fn default() -> UpdatePushRequest {
                UpdatePushRequest{id: ::core::default::Default::default(),
                                  follow: ::core::default::Default::default(),
                                  favourite:
                                      ::core::default::Default::default(),
                                  reblog: ::core::default::Default::default(),
                                  mention:
                                      ::core::default::Default::default(),}
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for UpdatePushRequest {
            #[inline]
            fn clone(&self) -> UpdatePushRequest {
                match *self {
                    UpdatePushRequest {
                    id: ref __self_0_0,
                    follow: ref __self_0_1,
                    favourite: ref __self_0_2,
                    reblog: ref __self_0_3,
                    mention: ref __self_0_4 } =>
                    UpdatePushRequest{id:
                                          ::core::clone::Clone::clone(&(*__self_0_0)),
                                      follow:
                                          ::core::clone::Clone::clone(&(*__self_0_1)),
                                      favourite:
                                          ::core::clone::Clone::clone(&(*__self_0_2)),
                                      reblog:
                                          ::core::clone::Clone::clone(&(*__self_0_3)),
                                      mention:
                                          ::core::clone::Clone::clone(&(*__self_0_4)),},
                }
            }
        }
        impl ::core::marker::StructuralPartialEq for UpdatePushRequest { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for UpdatePushRequest {
            #[inline]
            fn eq(&self, other: &UpdatePushRequest) -> bool {
                match *other {
                    UpdatePushRequest {
                    id: ref __self_1_0,
                    follow: ref __self_1_1,
                    favourite: ref __self_1_2,
                    reblog: ref __self_1_3,
                    mention: ref __self_1_4 } =>
                    match *self {
                        UpdatePushRequest {
                        id: ref __self_0_0,
                        follow: ref __self_0_1,
                        favourite: ref __self_0_2,
                        reblog: ref __self_0_3,
                        mention: ref __self_0_4 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1) &&
                            (*__self_0_2) == (*__self_1_2) &&
                            (*__self_0_3) == (*__self_1_3) &&
                            (*__self_0_4) == (*__self_1_4),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &UpdatePushRequest) -> bool {
                match *other {
                    UpdatePushRequest {
                    id: ref __self_1_0,
                    follow: ref __self_1_1,
                    favourite: ref __self_1_2,
                    reblog: ref __self_1_3,
                    mention: ref __self_1_4 } =>
                    match *self {
                        UpdatePushRequest {
                        id: ref __self_0_0,
                        follow: ref __self_0_1,
                        favourite: ref __self_0_2,
                        reblog: ref __self_0_3,
                        mention: ref __self_0_4 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1) ||
                            (*__self_0_2) != (*__self_1_2) ||
                            (*__self_0_3) != (*__self_1_3) ||
                            (*__self_0_4) != (*__self_1_4),
                    },
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_SERIALIZE_FOR_UpdatePushRequest: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl _serde::Serialize for UpdatePushRequest {
                    fn serialize<__S>(&self, __serializer: __S)
                     -> _serde::export::Result<__S::Ok, __S::Error> where
                     __S: _serde::Serializer {
                        let mut __serde_state =
                            match _serde::Serializer::serialize_struct(__serializer,
                                                                       "UpdatePushRequest",
                                                                       false
                                                                           as
                                                                           usize
                                                                           + 1
                                                                           + 1
                                                                           + 1
                                                                           + 1
                                                                           +
                                                                           1)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "id",
                                                                            &self.id)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "follow",
                                                                            &self.follow)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "favourite",
                                                                            &self.favourite)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "reblog",
                                                                            &self.reblog)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "mention",
                                                                            &self.mention)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        _serde::ser::SerializeStruct::end(__serde_state)
                    }
                }
            };
        impl UpdatePushRequest {
            /// Construct a new UpdatePushRequest
            ///
            /// # Example
            ///
            /// ```
            /// # extern crate elefren;
            /// use elefren::requests::UpdatePushRequest;
            /// let request = UpdatePushRequest::new("some-id");
            /// ```
            pub fn new(id: &str) -> UpdatePushRequest {
                UpdatePushRequest{id: id.to_string(), ..Default::default()}
            }
            /// A flag that indicates if you want follow notifications pushed
            ///
            /// # Example
            /// ```
            /// # extern crate elefren;
            /// use elefren::requests::UpdatePushRequest;
            /// let mut request = UpdatePushRequest::new("foobar");
            /// request.follow(true);
            /// ```
            pub fn follow(&mut self, follow: bool) -> &mut Self {
                self.follow = Some(follow);
                self
            }
            /// A flag that indicates if you want favourite notifications pushed
            ///
            /// # Example
            /// ```
            /// # extern crate elefren;
            /// use elefren::requests::UpdatePushRequest;
            /// let mut request = UpdatePushRequest::new("foobar");
            /// request.favourite(true);
            /// ```
            pub fn favourite(&mut self, favourite: bool) -> &mut Self {
                self.favourite = Some(favourite);
                self
            }
            /// A flag that indicates if you want reblog notifications pushed
            ///
            /// # Example
            /// ```
            /// # extern crate elefren;
            /// use elefren::requests::UpdatePushRequest;
            /// let mut request = UpdatePushRequest::new("foobar");
            /// request.reblog(true);
            /// ```
            pub fn reblog(&mut self, reblog: bool) -> &mut Self {
                self.reblog = Some(reblog);
                self
            }
            /// A flag that indicates if you want mention notifications pushed
            ///
            /// # Example
            /// ```
            /// # extern crate elefren;
            /// use elefren::requests::UpdatePushRequest;
            /// let mut request = UpdatePushRequest::new("foobar");
            /// request.mention(true);
            /// ```
            pub fn mention(&mut self, mention: bool) -> &mut Self {
                self.mention = Some(mention);
                self
            }
            fn flags_present(&self) -> bool {
                self.follow.is_some() || self.favourite.is_some() ||
                    self.reblog.is_some() || self.mention.is_some()
            }
            pub(crate) fn build(&self) -> update_data::Form {
                use crate::entities::push::{update_data::{Data, Form},
                                            Alerts};
                let mut form =
                    Form{id: self.id.clone(), ..Default::default()};
                if self.flags_present() {
                    let mut alerts = Alerts::default();
                    if let Some(follow) = self.follow {
                        alerts.follow = Some(follow);
                    }
                    if let Some(favourite) = self.favourite {
                        alerts.favourite = Some(favourite);
                    }
                    if let Some(reblog) = self.reblog {
                        alerts.reblog = Some(reblog);
                    }
                    if let Some(mention) = self.mention {
                        alerts.mention = Some(mention);
                    }
                    form.data = Data{alerts: Some(alerts),};
                }
                form
            }
        }
    }
    mod statuses {
        use crate::errors::Error;
        use serde_qs;
        use std::{borrow::Cow, convert::Into};
        mod bool_qs_serialize {
            use serde::Serializer;
            pub fn is_false(b: &bool) -> bool { !*b }
            pub fn serialize<S: Serializer>(b: &bool, s: S)
             -> Result<S::Ok, S::Error> {
                if *b { s.serialize_i64(1) } else { s.serialize_i64(0) }
            }
        }
        /// Builder for making a client.statuses() call
        ///
        /// # Example
        ///
        /// ```
        /// # extern crate elefren;
        /// # use elefren::StatusesRequest;
        /// let mut request = StatusesRequest::new();
        /// request.only_media().pinned().since_id("foo");
        /// # assert_eq!(&request.to_querystring().expect("Couldn't serialize qs")[..], "?only_media=1&pinned=1&since_id=foo");
        /// ```
        pub struct StatusesRequest<'a> {
            #[serde(skip_serializing_if = "bool_qs_serialize::is_false")]
            #[serde(serialize_with = "bool_qs_serialize::serialize")]
            only_media: bool,
            #[serde(skip_serializing_if = "bool_qs_serialize::is_false")]
            #[serde(serialize_with = "bool_qs_serialize::serialize")]
            exclude_replies: bool,
            #[serde(skip_serializing_if = "bool_qs_serialize::is_false")]
            #[serde(serialize_with = "bool_qs_serialize::serialize")]
            pinned: bool,
            #[serde(skip_serializing_if = "Option::is_none")]
            max_id: Option<Cow<'a, str>>,
            #[serde(skip_serializing_if = "Option::is_none")]
            since_id: Option<Cow<'a, str>>,
            #[serde(skip_serializing_if = "Option::is_none")]
            limit: Option<usize>,
            #[serde(skip_serializing_if = "Option::is_none")]
            min_id: Option<Cow<'a, str>>,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl <'a> ::core::clone::Clone for StatusesRequest<'a> {
            #[inline]
            fn clone(&self) -> StatusesRequest<'a> {
                match *self {
                    StatusesRequest {
                    only_media: ref __self_0_0,
                    exclude_replies: ref __self_0_1,
                    pinned: ref __self_0_2,
                    max_id: ref __self_0_3,
                    since_id: ref __self_0_4,
                    limit: ref __self_0_5,
                    min_id: ref __self_0_6 } =>
                    StatusesRequest{only_media:
                                        ::core::clone::Clone::clone(&(*__self_0_0)),
                                    exclude_replies:
                                        ::core::clone::Clone::clone(&(*__self_0_1)),
                                    pinned:
                                        ::core::clone::Clone::clone(&(*__self_0_2)),
                                    max_id:
                                        ::core::clone::Clone::clone(&(*__self_0_3)),
                                    since_id:
                                        ::core::clone::Clone::clone(&(*__self_0_4)),
                                    limit:
                                        ::core::clone::Clone::clone(&(*__self_0_5)),
                                    min_id:
                                        ::core::clone::Clone::clone(&(*__self_0_6)),},
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl <'a> ::core::fmt::Debug for StatusesRequest<'a> {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    StatusesRequest {
                    only_media: ref __self_0_0,
                    exclude_replies: ref __self_0_1,
                    pinned: ref __self_0_2,
                    max_id: ref __self_0_3,
                    since_id: ref __self_0_4,
                    limit: ref __self_0_5,
                    min_id: ref __self_0_6 } => {
                        let mut debug_trait_builder =
                            f.debug_struct("StatusesRequest");
                        let _ =
                            debug_trait_builder.field("only_media",
                                                      &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("exclude_replies",
                                                      &&(*__self_0_1));
                        let _ =
                            debug_trait_builder.field("pinned",
                                                      &&(*__self_0_2));
                        let _ =
                            debug_trait_builder.field("max_id",
                                                      &&(*__self_0_3));
                        let _ =
                            debug_trait_builder.field("since_id",
                                                      &&(*__self_0_4));
                        let _ =
                            debug_trait_builder.field("limit",
                                                      &&(*__self_0_5));
                        let _ =
                            debug_trait_builder.field("min_id",
                                                      &&(*__self_0_6));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl <'a> ::core::default::Default for StatusesRequest<'a> {
            #[inline]
            fn default() -> StatusesRequest<'a> {
                StatusesRequest{only_media:
                                    ::core::default::Default::default(),
                                exclude_replies:
                                    ::core::default::Default::default(),
                                pinned: ::core::default::Default::default(),
                                max_id: ::core::default::Default::default(),
                                since_id: ::core::default::Default::default(),
                                limit: ::core::default::Default::default(),
                                min_id: ::core::default::Default::default(),}
            }
        }
        impl <'a> ::core::marker::StructuralPartialEq for StatusesRequest<'a>
         {
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl <'a> ::core::cmp::PartialEq for StatusesRequest<'a> {
            #[inline]
            fn eq(&self, other: &StatusesRequest<'a>) -> bool {
                match *other {
                    StatusesRequest {
                    only_media: ref __self_1_0,
                    exclude_replies: ref __self_1_1,
                    pinned: ref __self_1_2,
                    max_id: ref __self_1_3,
                    since_id: ref __self_1_4,
                    limit: ref __self_1_5,
                    min_id: ref __self_1_6 } =>
                    match *self {
                        StatusesRequest {
                        only_media: ref __self_0_0,
                        exclude_replies: ref __self_0_1,
                        pinned: ref __self_0_2,
                        max_id: ref __self_0_3,
                        since_id: ref __self_0_4,
                        limit: ref __self_0_5,
                        min_id: ref __self_0_6 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1) &&
                            (*__self_0_2) == (*__self_1_2) &&
                            (*__self_0_3) == (*__self_1_3) &&
                            (*__self_0_4) == (*__self_1_4) &&
                            (*__self_0_5) == (*__self_1_5) &&
                            (*__self_0_6) == (*__self_1_6),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &StatusesRequest<'a>) -> bool {
                match *other {
                    StatusesRequest {
                    only_media: ref __self_1_0,
                    exclude_replies: ref __self_1_1,
                    pinned: ref __self_1_2,
                    max_id: ref __self_1_3,
                    since_id: ref __self_1_4,
                    limit: ref __self_1_5,
                    min_id: ref __self_1_6 } =>
                    match *self {
                        StatusesRequest {
                        only_media: ref __self_0_0,
                        exclude_replies: ref __self_0_1,
                        pinned: ref __self_0_2,
                        max_id: ref __self_0_3,
                        since_id: ref __self_0_4,
                        limit: ref __self_0_5,
                        min_id: ref __self_0_6 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1) ||
                            (*__self_0_2) != (*__self_1_2) ||
                            (*__self_0_3) != (*__self_1_3) ||
                            (*__self_0_4) != (*__self_1_4) ||
                            (*__self_0_5) != (*__self_1_5) ||
                            (*__self_0_6) != (*__self_1_6),
                    },
                }
            }
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_SERIALIZE_FOR_StatusesRequest: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'a> _serde::Serialize for StatusesRequest<'a> {
                    fn serialize<__S>(&self, __serializer: __S)
                     -> _serde::export::Result<__S::Ok, __S::Error> where
                     __S: _serde::Serializer {
                        let mut __serde_state =
                            match _serde::Serializer::serialize_struct(__serializer,
                                                                       "StatusesRequest",
                                                                       false
                                                                           as
                                                                           usize
                                                                           +
                                                                           if bool_qs_serialize::is_false(&self.only_media)
                                                                              {
                                                                               0
                                                                           } else {
                                                                               1
                                                                           } +
                                                                           if bool_qs_serialize::is_false(&self.exclude_replies)
                                                                              {
                                                                               0
                                                                           } else {
                                                                               1
                                                                           } +
                                                                           if bool_qs_serialize::is_false(&self.pinned)
                                                                              {
                                                                               0
                                                                           } else {
                                                                               1
                                                                           } +
                                                                           if Option::is_none(&self.max_id)
                                                                              {
                                                                               0
                                                                           } else {
                                                                               1
                                                                           } +
                                                                           if Option::is_none(&self.since_id)
                                                                              {
                                                                               0
                                                                           } else {
                                                                               1
                                                                           } +
                                                                           if Option::is_none(&self.limit)
                                                                              {
                                                                               0
                                                                           } else {
                                                                               1
                                                                           } +
                                                                           if Option::is_none(&self.min_id)
                                                                              {
                                                                               0
                                                                           } else {
                                                                               1
                                                                           })
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        if !bool_qs_serialize::is_false(&self.only_media) {
                            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                "only_media",
                                                                                {
                                                                                    struct __SerializeWith<'__a,
                                                                                                           'a: '__a> {
                                                                                        values: (&'__a bool,),
                                                                                        phantom: _serde::export::PhantomData<StatusesRequest<'a>>,
                                                                                    }
                                                                                    impl <'__a,
                                                                                          'a: '__a>
                                                                                     _serde::Serialize
                                                                                     for
                                                                                     __SerializeWith<'__a,
                                                                                                     'a>
                                                                                     {
                                                                                        fn serialize<__S>(&self,
                                                                                                          __s:
                                                                                                              __S)
                                                                                         ->
                                                                                             _serde::export::Result<__S::Ok,
                                                                                                                    __S::Error>
                                                                                         where
                                                                                         __S: _serde::Serializer {
                                                                                            bool_qs_serialize::serialize(self.values.0,
                                                                                                                         __s)
                                                                                        }
                                                                                    }
                                                                                    &__SerializeWith{values:
                                                                                                         (&self.only_media,),
                                                                                                     phantom:
                                                                                                         _serde::export::PhantomData::<StatusesRequest<'a>>,}
                                                                                })
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        } else {
                            match _serde::ser::SerializeStruct::skip_field(&mut __serde_state,
                                                                           "only_media")
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        }
                        if !bool_qs_serialize::is_false(&self.exclude_replies)
                           {
                            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                "exclude_replies",
                                                                                {
                                                                                    struct __SerializeWith<'__a,
                                                                                                           'a: '__a> {
                                                                                        values: (&'__a bool,),
                                                                                        phantom: _serde::export::PhantomData<StatusesRequest<'a>>,
                                                                                    }
                                                                                    impl <'__a,
                                                                                          'a: '__a>
                                                                                     _serde::Serialize
                                                                                     for
                                                                                     __SerializeWith<'__a,
                                                                                                     'a>
                                                                                     {
                                                                                        fn serialize<__S>(&self,
                                                                                                          __s:
                                                                                                              __S)
                                                                                         ->
                                                                                             _serde::export::Result<__S::Ok,
                                                                                                                    __S::Error>
                                                                                         where
                                                                                         __S: _serde::Serializer {
                                                                                            bool_qs_serialize::serialize(self.values.0,
                                                                                                                         __s)
                                                                                        }
                                                                                    }
                                                                                    &__SerializeWith{values:
                                                                                                         (&self.exclude_replies,),
                                                                                                     phantom:
                                                                                                         _serde::export::PhantomData::<StatusesRequest<'a>>,}
                                                                                })
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        } else {
                            match _serde::ser::SerializeStruct::skip_field(&mut __serde_state,
                                                                           "exclude_replies")
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        }
                        if !bool_qs_serialize::is_false(&self.pinned) {
                            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                "pinned",
                                                                                {
                                                                                    struct __SerializeWith<'__a,
                                                                                                           'a: '__a> {
                                                                                        values: (&'__a bool,),
                                                                                        phantom: _serde::export::PhantomData<StatusesRequest<'a>>,
                                                                                    }
                                                                                    impl <'__a,
                                                                                          'a: '__a>
                                                                                     _serde::Serialize
                                                                                     for
                                                                                     __SerializeWith<'__a,
                                                                                                     'a>
                                                                                     {
                                                                                        fn serialize<__S>(&self,
                                                                                                          __s:
                                                                                                              __S)
                                                                                         ->
                                                                                             _serde::export::Result<__S::Ok,
                                                                                                                    __S::Error>
                                                                                         where
                                                                                         __S: _serde::Serializer {
                                                                                            bool_qs_serialize::serialize(self.values.0,
                                                                                                                         __s)
                                                                                        }
                                                                                    }
                                                                                    &__SerializeWith{values:
                                                                                                         (&self.pinned,),
                                                                                                     phantom:
                                                                                                         _serde::export::PhantomData::<StatusesRequest<'a>>,}
                                                                                })
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        } else {
                            match _serde::ser::SerializeStruct::skip_field(&mut __serde_state,
                                                                           "pinned")
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        }
                        if !Option::is_none(&self.max_id) {
                            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                "max_id",
                                                                                &self.max_id)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        } else {
                            match _serde::ser::SerializeStruct::skip_field(&mut __serde_state,
                                                                           "max_id")
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        }
                        if !Option::is_none(&self.since_id) {
                            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                "since_id",
                                                                                &self.since_id)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        } else {
                            match _serde::ser::SerializeStruct::skip_field(&mut __serde_state,
                                                                           "since_id")
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        }
                        if !Option::is_none(&self.limit) {
                            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                "limit",
                                                                                &self.limit)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        } else {
                            match _serde::ser::SerializeStruct::skip_field(&mut __serde_state,
                                                                           "limit")
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        }
                        if !Option::is_none(&self.min_id) {
                            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                "min_id",
                                                                                &self.min_id)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        } else {
                            match _serde::ser::SerializeStruct::skip_field(&mut __serde_state,
                                                                           "min_id")
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        }
                        _serde::ser::SerializeStruct::end(__serde_state)
                    }
                }
            };
        impl <'a> Into<Option<StatusesRequest<'a>>> for
         &'a mut StatusesRequest<'a> {
            fn into(self) -> Option<StatusesRequest<'a>> {
                Some(StatusesRequest{only_media: self.only_media,
                                     exclude_replies: self.exclude_replies,
                                     pinned: self.pinned,
                                     max_id: self.max_id.clone(),
                                     since_id: self.since_id.clone(),
                                     limit: self.limit.clone(),
                                     min_id: self.min_id.clone(),})
            }
        }
        impl <'a> StatusesRequest<'a> {
            /// Construct a new `StatusesRequest` object
            ///
            /// # Example
            ///
            /// ```
            /// # extern crate elefren;
            /// # use elefren::StatusesRequest;
            /// let request = StatusesRequest::new();
            /// ```
            pub fn new() -> Self { Self::default() }
            /// Set the `?only_media=1` flag for the .statuses() request
            ///
            /// # Example
            ///
            /// ```
            /// # extern crate elefren;
            /// # use elefren::StatusesRequest;
            /// let mut request = StatusesRequest::new();
            /// assert_eq!(&request.only_media().to_querystring().expect("Couldn't serialize qs"), "?only_media=1");
            pub fn only_media(&mut self) -> &mut Self {
                self.only_media = true;
                self
            }
            /// Set the `?exclude_replies=1` flag for the .statuses() request
            ///
            /// # Example
            ///
            /// ```
            /// # extern crate elefren;
            /// # use elefren::StatusesRequest;
            /// let mut request = StatusesRequest::new();
            /// assert_eq!(
            ///     &request
            ///         .exclude_replies()
            ///         .to_querystring()
            ///         .expect("Couldn't serialize qs"),
            ///     "?exclude_replies=1"
            /// );
            /// ```
            pub fn exclude_replies(&mut self) -> &mut Self {
                self.exclude_replies = true;
                self
            }
            /// Set the `?pinned=1` flag for the .statuses() request
            ///
            /// # Example
            ///
            /// ```
            /// # extern crate elefren;
            /// # use elefren::StatusesRequest;
            /// let mut request = StatusesRequest::new();
            /// assert_eq!(
            ///     &request
            ///         .pinned()
            ///         .to_querystring()
            ///         .expect("Couldn't serialize qs"),
            ///     "?pinned=1"
            /// );
            /// ```
            pub fn pinned(&mut self) -> &mut Self { self.pinned = true; self }
            /// Set the `?max_id=:max_id` flag for the .statuses() request
            ///
            /// # Example
            ///
            /// ```
            /// # extern crate elefren;
            /// # use elefren::StatusesRequest;
            /// let mut request = StatusesRequest::new();
            /// assert_eq!(
            ///     &request
            ///         .max_id("foo")
            ///         .to_querystring()
            ///         .expect("Couldn't serialize qs"),
            ///     "?max_id=foo"
            /// );
            /// ```
            pub fn max_id<S: Into<Cow<'a, str>>>(&mut self, max_id: S)
             -> &mut Self {
                self.max_id = Some(max_id.into());
                self
            }
            /// Set the `?since_id=:since_id` flag for the .statuses() request
            ///
            /// # Example
            ///
            /// ```
            /// # extern crate elefren;
            /// # use elefren::StatusesRequest;
            /// let mut request = StatusesRequest::new();
            /// assert_eq!(
            ///     &request
            ///         .since_id("foo")
            ///         .to_querystring()
            ///         .expect("Couldn't serialize qs"),
            ///     "?since_id=foo"
            /// );
            /// ```
            pub fn since_id<S: Into<Cow<'a, str>>>(&mut self, since_id: S)
             -> &mut Self {
                self.since_id = Some(since_id.into());
                self
            }
            /// Set the `?limit=:limit` flag for the .statuses() request
            ///
            /// # Example
            ///
            /// ```
            /// # extern crate elefren;
            /// # use elefren::StatusesRequest;
            /// let mut request = StatusesRequest::new();
            /// assert_eq!(
            ///     &request
            ///         .limit(10)
            ///         .to_querystring()
            ///         .expect("Couldn't serialize qs"),
            ///     "?limit=10"
            /// );
            /// ```
            pub fn limit(&mut self, limit: usize) -> &mut Self {
                self.limit = Some(limit);
                self
            }
            /// Set the `?min_id=:min_id` flag for the .statuses() request
            ///
            /// # Example
            ///
            /// ```
            /// # extern crate elefren;
            /// # use elefren::StatusesRequest;
            /// let mut request = StatusesRequest::new();
            /// assert_eq!(
            ///     &request
            ///         .min_id("foobar")
            ///         .to_querystring()
            ///         .expect("Couldn't serialize qs"),
            ///     "?min_id=foobar"
            /// );
            /// ```
            pub fn min_id<S: Into<Cow<'a, str>>>(&mut self, min_id: S)
             -> &mut Self {
                self.min_id = Some(min_id.into());
                self
            }
            /// Turns this builder into a querystring
            ///
            /// # Example
            ///
            /// ```
            /// # extern crate elefren;
            /// # use elefren::StatusesRequest;
            /// let mut request = StatusesRequest::new();
            /// assert_eq!(
            ///     &request
            ///         .limit(10)
            ///         .pinned()
            ///         .to_querystring()
            ///         .expect("Couldn't serialize qs"),
            ///     "?pinned=1&limit=10"
            /// );
            /// ```
            pub fn to_querystring(&self) -> Result<String, Error> {
                Ok({
                       let res =
                           ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["?"],
                                                                               &match (&serde_qs::to_string(&self)?,)
                                                                                    {
                                                                                    (arg0,)
                                                                                    =>
                                                                                    [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                  ::core::fmt::Display::fmt)],
                                                                                }));
                       res
                   })
            }
        }
    }
    mod update_credentials {
        use std::{fmt::Display, path::{Path, PathBuf}};
        use crate::entities::account::{Credentials, MetadataField,
                                       UpdateSource};
        use crate::errors::Result;
        use crate::status_builder;
        /// Builder to pass to the Mastodon::update_credentials method
        ///
        /// # Example
        ///
        /// ```no_run
        /// # extern crate elefren;
        /// # use elefren::Data;
        /// # fn main() -> Result<(), elefren::Error> {
        /// # let data = Data {
        /// #   base: "".into(),
        /// #   client_id: "".into(),
        /// #   client_secret: "".into(),
        /// #   redirect: "".into(),
        /// #   token: "".into(),
        /// # };
        /// use elefren::{prelude::*, status_builder::Visibility, UpdateCredsRequest};
        ///
        /// let client = Mastodon::from(data);
        /// let mut builder = UpdateCredsRequest::new();
        ///
        /// builder.privacy(Visibility::Unlisted);
        ///
        /// let result = client.update_credentials(&mut builder)?;
        /// #   Ok(())
        /// # }
        /// ```
        pub struct UpdateCredsRequest {
            display_name: Option<String>,
            note: Option<String>,
            avatar: Option<PathBuf>,
            header: Option<PathBuf>,
            field_attributes: Vec<MetadataField>,
            privacy: Option<status_builder::Visibility>,
            sensitive: Option<bool>,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for UpdateCredsRequest {
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
             -> ::core::fmt::Result {
                match *self {
                    UpdateCredsRequest {
                    display_name: ref __self_0_0,
                    note: ref __self_0_1,
                    avatar: ref __self_0_2,
                    header: ref __self_0_3,
                    field_attributes: ref __self_0_4,
                    privacy: ref __self_0_5,
                    sensitive: ref __self_0_6 } => {
                        let mut debug_trait_builder =
                            f.debug_struct("UpdateCredsRequest");
                        let _ =
                            debug_trait_builder.field("display_name",
                                                      &&(*__self_0_0));
                        let _ =
                            debug_trait_builder.field("note",
                                                      &&(*__self_0_1));
                        let _ =
                            debug_trait_builder.field("avatar",
                                                      &&(*__self_0_2));
                        let _ =
                            debug_trait_builder.field("header",
                                                      &&(*__self_0_3));
                        let _ =
                            debug_trait_builder.field("field_attributes",
                                                      &&(*__self_0_4));
                        let _ =
                            debug_trait_builder.field("privacy",
                                                      &&(*__self_0_5));
                        let _ =
                            debug_trait_builder.field("sensitive",
                                                      &&(*__self_0_6));
                        debug_trait_builder.finish()
                    }
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::default::Default for UpdateCredsRequest {
            #[inline]
            fn default() -> UpdateCredsRequest {
                UpdateCredsRequest{display_name:
                                       ::core::default::Default::default(),
                                   note: ::core::default::Default::default(),
                                   avatar:
                                       ::core::default::Default::default(),
                                   header:
                                       ::core::default::Default::default(),
                                   field_attributes:
                                       ::core::default::Default::default(),
                                   privacy:
                                       ::core::default::Default::default(),
                                   sensitive:
                                       ::core::default::Default::default(),}
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for UpdateCredsRequest {
            #[inline]
            fn clone(&self) -> UpdateCredsRequest {
                match *self {
                    UpdateCredsRequest {
                    display_name: ref __self_0_0,
                    note: ref __self_0_1,
                    avatar: ref __self_0_2,
                    header: ref __self_0_3,
                    field_attributes: ref __self_0_4,
                    privacy: ref __self_0_5,
                    sensitive: ref __self_0_6 } =>
                    UpdateCredsRequest{display_name:
                                           ::core::clone::Clone::clone(&(*__self_0_0)),
                                       note:
                                           ::core::clone::Clone::clone(&(*__self_0_1)),
                                       avatar:
                                           ::core::clone::Clone::clone(&(*__self_0_2)),
                                       header:
                                           ::core::clone::Clone::clone(&(*__self_0_3)),
                                       field_attributes:
                                           ::core::clone::Clone::clone(&(*__self_0_4)),
                                       privacy:
                                           ::core::clone::Clone::clone(&(*__self_0_5)),
                                       sensitive:
                                           ::core::clone::Clone::clone(&(*__self_0_6)),},
                }
            }
        }
        impl ::core::marker::StructuralPartialEq for UpdateCredsRequest { }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::cmp::PartialEq for UpdateCredsRequest {
            #[inline]
            fn eq(&self, other: &UpdateCredsRequest) -> bool {
                match *other {
                    UpdateCredsRequest {
                    display_name: ref __self_1_0,
                    note: ref __self_1_1,
                    avatar: ref __self_1_2,
                    header: ref __self_1_3,
                    field_attributes: ref __self_1_4,
                    privacy: ref __self_1_5,
                    sensitive: ref __self_1_6 } =>
                    match *self {
                        UpdateCredsRequest {
                        display_name: ref __self_0_0,
                        note: ref __self_0_1,
                        avatar: ref __self_0_2,
                        header: ref __self_0_3,
                        field_attributes: ref __self_0_4,
                        privacy: ref __self_0_5,
                        sensitive: ref __self_0_6 } =>
                        (*__self_0_0) == (*__self_1_0) &&
                            (*__self_0_1) == (*__self_1_1) &&
                            (*__self_0_2) == (*__self_1_2) &&
                            (*__self_0_3) == (*__self_1_3) &&
                            (*__self_0_4) == (*__self_1_4) &&
                            (*__self_0_5) == (*__self_1_5) &&
                            (*__self_0_6) == (*__self_1_6),
                    },
                }
            }
            #[inline]
            fn ne(&self, other: &UpdateCredsRequest) -> bool {
                match *other {
                    UpdateCredsRequest {
                    display_name: ref __self_1_0,
                    note: ref __self_1_1,
                    avatar: ref __self_1_2,
                    header: ref __self_1_3,
                    field_attributes: ref __self_1_4,
                    privacy: ref __self_1_5,
                    sensitive: ref __self_1_6 } =>
                    match *self {
                        UpdateCredsRequest {
                        display_name: ref __self_0_0,
                        note: ref __self_0_1,
                        avatar: ref __self_0_2,
                        header: ref __self_0_3,
                        field_attributes: ref __self_0_4,
                        privacy: ref __self_0_5,
                        sensitive: ref __self_0_6 } =>
                        (*__self_0_0) != (*__self_1_0) ||
                            (*__self_0_1) != (*__self_1_1) ||
                            (*__self_0_2) != (*__self_1_2) ||
                            (*__self_0_3) != (*__self_1_3) ||
                            (*__self_0_4) != (*__self_1_4) ||
                            (*__self_0_5) != (*__self_1_5) ||
                            (*__self_0_6) != (*__self_1_6),
                    },
                }
            }
        }
        impl UpdateCredsRequest {
            /// Create a new UpdateCredsRequest
            ///
            /// # Example
            ///
            /// ```
            /// # extern crate elefren;
            /// use elefren::UpdateCredsRequest;
            ///
            /// let mut builder = UpdateCredsRequest::new();
            /// ```
            pub fn new() -> UpdateCredsRequest { Default::default() }
            /// Set the new display_name value
            ///
            /// # Example
            ///
            /// ```
            /// # extern crate elefren;
            /// use elefren::UpdateCredsRequest;
            ///
            /// let mut builder = UpdateCredsRequest::new();
            ///
            /// builder.display_name("my new display name");
            /// ```
            pub fn display_name<D: Display>(&mut self, name: D) -> &mut Self {
                self.display_name = Some(name.to_string());
                self
            }
            /// Set the new note value
            ///
            /// # Example
            ///
            /// ```
            /// # extern crate elefren;
            /// use elefren::UpdateCredsRequest;
            ///
            /// let mut builder = UpdateCredsRequest::new();
            ///
            /// builder.note("my new note");
            /// ```
            pub fn note<D: Display>(&mut self, note: D) -> &mut Self {
                self.note = Some(note.to_string());
                self
            }
            /// Set the new avatar value
            ///
            /// # Example
            ///
            /// ```
            /// # extern crate elefren;
            /// use elefren::UpdateCredsRequest;
            ///
            /// let mut builder = UpdateCredsRequest::new();
            ///
            /// builder.avatar("/path/to/my/new/avatar");
            /// ```
            pub fn avatar<P: AsRef<Path>>(&mut self, path: P) -> &mut Self {
                let path = path.as_ref();
                let path = path.to_path_buf();
                self.avatar = Some(path);
                self
            }
            /// Set the new header value
            ///
            /// # Example
            ///
            /// ```
            /// # extern crate elefren;
            /// use elefren::UpdateCredsRequest;
            ///
            /// let mut builder = UpdateCredsRequest::new();
            ///
            /// builder.header("/path/to/my/new/header");
            /// ```
            pub fn header<P: AsRef<Path>>(&mut self, path: P) -> &mut Self {
                let path = path.as_ref();
                let path = path.to_path_buf();
                self.header = Some(path);
                self
            }
            /// Set the new privacy value
            ///
            /// # Example
            ///
            /// ```
            /// # extern crate elefren;
            /// use elefren::{status_builder::Visibility, UpdateCredsRequest};
            ///
            /// let mut builder = UpdateCredsRequest::new();
            ///
            /// builder.privacy(Visibility::Public);
            /// ```
            pub fn privacy(&mut self, privacy: status_builder::Visibility)
             -> &mut Self {
                self.privacy = Some(privacy);
                self
            }
            /// Set the new sensitive value
            ///
            /// # Example
            ///
            /// ```
            /// # extern crate elefren;
            /// use elefren::UpdateCredsRequest;
            ///
            /// let mut builder = UpdateCredsRequest::new();
            ///
            /// builder.sensitive(true);
            /// ```
            pub fn sensitive(&mut self, sensitive: bool) -> &mut Self {
                self.sensitive = Some(sensitive);
                self
            }
            /// Add a metadata field
            ///
            /// # Example
            ///
            /// ```
            /// # extern crate elefren;
            /// use elefren::UpdateCredsRequest;
            ///
            /// let mut builder = UpdateCredsRequest::new();
            ///
            /// builder.field_attribute("some key", "some value");
            /// ```
            pub fn field_attribute(&mut self, name: &str, value: &str)
             -> &mut Self {
                self.field_attributes.push(MetadataField::new(name, value));
                self
            }
            pub(crate) fn build(&mut self) -> Result<Credentials> {
                Ok(Credentials{display_name: self.display_name.clone(),
                               note: self.note.clone(),
                               avatar: self.avatar.clone(),
                               header: self.avatar.clone(),
                               source:
                                   Some(UpdateSource{privacy:
                                                         self.privacy.clone(),
                                                     sensitive:
                                                         self.sensitive.clone(),}),
                               fields_attributes:
                                   self.field_attributes.clone(),})
            }
        }
    }
}
/// OAuth Scopes
pub mod scopes {
    use std::{cmp::{Ordering, PartialEq, PartialOrd}, collections::HashSet,
              fmt, ops::BitOr, str::FromStr};
    use serde::ser::{Serialize, Serializer};
    use crate::errors::Error;
    use serde::{Deserialize, Deserializer};
    use serde::de::{self, Visitor};
    /// Represents a set of OAuth scopes
    ///
    /// # Example
    ///
    /// ```rust
    /// use elefren::prelude::*;
    ///
    /// let read = Scopes::read_all();
    /// let write = Scopes::write_all();
    /// let follow = Scopes::follow();
    /// let all = read | write | follow;
    /// ```
    pub struct Scopes {
        scopes: HashSet<Scope>,
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::clone::Clone for Scopes {
        #[inline]
        fn clone(&self) -> Scopes {
            match *self {
                Scopes { scopes: ref __self_0_0 } =>
                Scopes{scopes: ::core::clone::Clone::clone(&(*__self_0_0)),},
            }
        }
    }
    impl FromStr for Scopes {
        type Err = Error;
        fn from_str(s: &str) -> Result<Scopes, Self::Err> {
            let mut set = HashSet::new();
            for scope in s.split_whitespace() {
                let scope = Scope::from_str(&scope)?;
                set.insert(scope);
            }
            Ok(Scopes{scopes: set,})
        }
    }
    impl Serialize for Scopes {
        fn serialize<S>(&self, serializer: S)
         -> ::std::result::Result<S::Ok, S::Error> where S: Serializer {
            let repr =
                {
                    let res =
                        ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&[""],
                                                                            &match (&self,)
                                                                                 {
                                                                                 (arg0,)
                                                                                 =>
                                                                                 [::core::fmt::ArgumentV1::new(arg0,
                                                                                                               ::core::fmt::Display::fmt)],
                                                                             }));
                    res
                };
            serializer.serialize_str(&repr)
        }
    }
    struct DeserializeScopesVisitor;
    impl <'de> Visitor<'de> for DeserializeScopesVisitor {
        type Value = Scopes;
        fn expecting(&self, formatter: &mut fmt::Formatter)
         -> Result<(), fmt::Error> {
            formatter.write_fmt(::core::fmt::Arguments::new_v1(&["space separated scopes"],
                                                               &match () {
                                                                    () => [],
                                                                }))
        }
        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where
         E: de::Error {
            Scopes::from_str(v).map_err(de::Error::custom)
        }
    }
    impl <'de> Deserialize<'de> for Scopes {
        fn deserialize<D>(deserializer: D)
         -> Result<Self, <D as Deserializer<'de>>::Error> where
         D: Deserializer<'de> {
            deserializer.deserialize_str(DeserializeScopesVisitor)
        }
    }
    impl Scopes {
        /// Represents all available oauth scopes: "read write follow push"
        ///
        /// ```
        /// # extern crate elefren;
        /// # use std::error::Error;
        /// use elefren::scopes::Scopes;
        ///
        /// # fn main() -> Result<(), Box<Error>> {
        /// let scope = Scopes::all();
        /// assert_eq!(&format!("{}", scope), "read write follow push");
        /// #   Ok(())
        /// # }
        /// ```
        pub fn all() -> Scopes {
            Scopes::read_all() | Scopes::write_all() | Scopes::follow() |
                Scopes::push()
        }
        /// Represents the full "read" scope
        ///
        /// ```
        /// # extern crate elefren;
        /// # use std::error::Error;
        /// use elefren::scopes::Scopes;
        ///
        /// # fn main() -> Result<(), Box<Error>> {
        /// let scope = Scopes::read_all();
        /// assert_eq!(&format!("{}", scope), "read");
        /// #   Ok(())
        /// # }
        /// ```
        pub fn read_all() -> Scopes { Scopes::_read(None) }
        /// Represents a specific "read:___" scope
        ///
        /// ```
        /// # extern crate elefren;
        /// # use std::error::Error;
        /// use elefren::scopes::{Read, Scopes};
        ///
        /// # fn main() -> Result<(), Box<Error>> {
        /// let scope = Scopes::read(Read::Accounts);
        /// assert_eq!(&format!("{}", scope), "read:accounts");
        /// #   Ok(())
        /// # }
        /// ```
        pub fn read(subscope: Read) -> Scopes {
            Scopes::_read(Some(subscope))
        }
        /// Represents the full "write" scope
        ///
        /// ```
        /// # extern crate elefren;
        /// # use std::error::Error;
        /// use elefren::scopes::Scopes;
        ///
        /// # fn main() -> Result<(), Box<Error>> {
        /// let scope = Scopes::write_all();
        /// assert_eq!(&format!("{}", scope), "write");
        /// #   Ok(())
        /// # }
        /// ```
        pub fn write_all() -> Scopes { Scopes::_write(None) }
        /// Represents a specific "write:___" scope
        ///
        /// ```
        /// # extern crate elefren;
        /// # use std::error::Error;
        /// use elefren::scopes::{Scopes, Write};
        ///
        /// # fn main() -> Result<(), Box<Error>> {
        /// let scope = Scopes::write(Write::Accounts);
        /// assert_eq!(&format!("{}", scope), "write:accounts");
        /// #   Ok(())
        /// # }
        /// ```
        pub fn write(subscope: Write) -> Scopes {
            Scopes::_write(Some(subscope))
        }
        /// Represents the "follow" scope
        ///
        /// ```
        /// # extern crate elefren;
        /// # use std::error::Error;
        /// use elefren::scopes::Scopes;
        ///
        /// # fn main() -> Result<(), Box<Error>> {
        /// let scope = Scopes::follow();
        /// assert_eq!(&format!("{}", scope), "follow");
        /// #   Ok(())
        /// # }
        /// ```
        pub fn follow() -> Scopes { Scopes::new(Scope::Follow) }
        /// Represents the full "push" scope
        ///
        /// ```
        /// # extern crate elefren;
        /// # use std::error::Error;
        /// use elefren::scopes::Scopes;
        ///
        /// # fn main() -> Result<(), Box<Error>> {
        /// let scope = Scopes::push();
        /// assert_eq!(&format!("{}", scope), "push");
        /// #   Ok(())
        /// # }
        /// ```
        pub fn push() -> Scopes { Scopes::new(Scope::Push) }
        /// Combines 2 scopes together
        ///
        /// # Example
        ///
        /// ```rust
        /// use elefren::prelude::*;
        ///
        /// let read = Scopes::read_all();
        /// let write = Scopes::write_all();
        /// let read_write = read.and(write);
        /// ```
        pub fn and(self, other: Scopes) -> Scopes {
            let newset: HashSet<_> =
                self.scopes.union(&other.scopes).into_iter().map(|s|
                                                                     *s).collect();
            Scopes{scopes: newset,}
        }
        fn _write(subscope: Option<Write>) -> Scopes {
            Scopes::new(Scope::Write(subscope))
        }
        fn _read(subscope: Option<Read>) -> Scopes {
            Scopes::new(Scope::Read(subscope))
        }
        fn new(scope: Scope) -> Scopes {
            let mut set = HashSet::new();
            set.insert(scope);
            Scopes{scopes: set,}
        }
    }
    impl BitOr for Scopes {
        type Output = Scopes;
        fn bitor(self, other: Scopes) -> Self::Output { self.and(other) }
    }
    impl PartialEq for Scopes {
        fn eq(&self, other: &Scopes) -> bool {
            self.scopes.symmetric_difference(&other.scopes).next().is_none()
        }
    }
    impl Default for Scopes {
        fn default() -> Scopes { Scopes::read_all() }
    }
    impl fmt::Debug for Scopes {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            f.write_fmt(::core::fmt::Arguments::new_v1(&["["],
                                                       &match () {
                                                            () => [],
                                                        }))?;
            for scope in &self.scopes {
                f.write_fmt(::core::fmt::Arguments::new_v1(&[""],
                                                           &match (&&scope,) {
                                                                (arg0,) =>
                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                              ::core::fmt::Debug::fmt)],
                                                            }))?;
            }
            Ok(f.write_fmt(::core::fmt::Arguments::new_v1(&["]"],
                                                          &match () {
                                                               () => [],
                                                           }))?)
        }
    }
    impl fmt::Display for Scopes {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            let mut start = true;
            let scopes =
                {
                    let mut scopes = self.scopes.iter().collect::<Vec<_>>();
                    scopes.sort();
                    scopes
                };
            for scope in &scopes {
                if !start {
                    f.write_fmt(::core::fmt::Arguments::new_v1(&[" "],
                                                               &match () {
                                                                    () => [],
                                                                }))?;
                } else { start = false; }
                f.write_fmt(::core::fmt::Arguments::new_v1(&[""],
                                                           &match (&&scope,) {
                                                                (arg0,) =>
                                                                [::core::fmt::ArgumentV1::new(arg0,
                                                                                              ::core::fmt::Display::fmt)],
                                                            }))?;
            }
            Ok(())
        }
    }
    /// Permission scope of the application.
    /// [Details on what each permission provides][1]
    /// [1]: https://github.com/tootsuite/documentation/blob/master/Using-the-API/OAuth-details.md)
    enum Scope {

        /// Read only permissions.
        #[serde(rename = "read")]
        Read(Option<Read>),

        /// Write only permissions.
        #[serde(rename = "write")]
        Write(Option<Write>),

        /// Only permission to add and remove followers.
        #[serde(rename = "follow")]
        Follow,

        /// Push permissions
        #[serde(rename = "push")]
        Push,
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::fmt::Debug for Scope {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            match (&*self,) {
                (&Scope::Read(ref __self_0),) => {
                    let mut debug_trait_builder = f.debug_tuple("Read");
                    let _ = debug_trait_builder.field(&&(*__self_0));
                    debug_trait_builder.finish()
                }
                (&Scope::Write(ref __self_0),) => {
                    let mut debug_trait_builder = f.debug_tuple("Write");
                    let _ = debug_trait_builder.field(&&(*__self_0));
                    debug_trait_builder.finish()
                }
                (&Scope::Follow,) => {
                    let mut debug_trait_builder = f.debug_tuple("Follow");
                    debug_trait_builder.finish()
                }
                (&Scope::Push,) => {
                    let mut debug_trait_builder = f.debug_tuple("Push");
                    debug_trait_builder.finish()
                }
            }
        }
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::clone::Clone for Scope {
        #[inline]
        fn clone(&self) -> Scope {
            {
                let _: ::core::clone::AssertParamIsClone<Option<Read>>;
                let _: ::core::clone::AssertParamIsClone<Option<Write>>;
                *self
            }
        }
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::marker::Copy for Scope { }
    impl ::core::marker::StructuralPartialEq for Scope { }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::cmp::PartialEq for Scope {
        #[inline]
        fn eq(&self, other: &Scope) -> bool {
            {
                let __self_vi =
                    unsafe { ::core::intrinsics::discriminant_value(&*self) };
                let __arg_1_vi =
                    unsafe {
                        ::core::intrinsics::discriminant_value(&*other)
                    };
                if true && __self_vi == __arg_1_vi {
                    match (&*self, &*other) {
                        (&Scope::Read(ref __self_0),
                         &Scope::Read(ref __arg_1_0)) =>
                        (*__self_0) == (*__arg_1_0),
                        (&Scope::Write(ref __self_0),
                         &Scope::Write(ref __arg_1_0)) =>
                        (*__self_0) == (*__arg_1_0),
                        _ => true,
                    }
                } else { false }
            }
        }
        #[inline]
        fn ne(&self, other: &Scope) -> bool {
            {
                let __self_vi =
                    unsafe { ::core::intrinsics::discriminant_value(&*self) };
                let __arg_1_vi =
                    unsafe {
                        ::core::intrinsics::discriminant_value(&*other)
                    };
                if true && __self_vi == __arg_1_vi {
                    match (&*self, &*other) {
                        (&Scope::Read(ref __self_0),
                         &Scope::Read(ref __arg_1_0)) =>
                        (*__self_0) != (*__arg_1_0),
                        (&Scope::Write(ref __self_0),
                         &Scope::Write(ref __arg_1_0)) =>
                        (*__self_0) != (*__arg_1_0),
                        _ => false,
                    }
                } else { true }
            }
        }
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::cmp::PartialOrd for Scope {
        #[inline]
        fn partial_cmp(&self, other: &Scope)
         -> ::core::option::Option<::core::cmp::Ordering> {
            {
                let __self_vi =
                    unsafe { ::core::intrinsics::discriminant_value(&*self) };
                let __arg_1_vi =
                    unsafe {
                        ::core::intrinsics::discriminant_value(&*other)
                    };
                if true && __self_vi == __arg_1_vi {
                    match (&*self, &*other) {
                        (&Scope::Read(ref __self_0),
                         &Scope::Read(ref __arg_1_0)) =>
                        match ::core::cmp::PartialOrd::partial_cmp(&(*__self_0),
                                                                   &(*__arg_1_0))
                            {
                            ::core::option::Option::Some(::core::cmp::Ordering::Equal)
                            =>
                            ::core::option::Option::Some(::core::cmp::Ordering::Equal),
                            cmp => cmp,
                        },
                        (&Scope::Write(ref __self_0),
                         &Scope::Write(ref __arg_1_0)) =>
                        match ::core::cmp::PartialOrd::partial_cmp(&(*__self_0),
                                                                   &(*__arg_1_0))
                            {
                            ::core::option::Option::Some(::core::cmp::Ordering::Equal)
                            =>
                            ::core::option::Option::Some(::core::cmp::Ordering::Equal),
                            cmp => cmp,
                        },
                        _ =>
                        ::core::option::Option::Some(::core::cmp::Ordering::Equal),
                    }
                } else { __self_vi.partial_cmp(&__arg_1_vi) }
            }
        }
        #[inline]
        fn lt(&self, other: &Scope) -> bool {
            {
                let __self_vi =
                    unsafe { ::core::intrinsics::discriminant_value(&*self) };
                let __arg_1_vi =
                    unsafe {
                        ::core::intrinsics::discriminant_value(&*other)
                    };
                if true && __self_vi == __arg_1_vi {
                    match (&*self, &*other) {
                        (&Scope::Read(ref __self_0),
                         &Scope::Read(ref __arg_1_0)) =>
                        ::core::option::Option::unwrap_or(::core::cmp::PartialOrd::partial_cmp(&(*__self_0),
                                                                                               &(*__arg_1_0)),
                                                          ::core::cmp::Ordering::Greater)
                            == ::core::cmp::Ordering::Less,
                        (&Scope::Write(ref __self_0),
                         &Scope::Write(ref __arg_1_0)) =>
                        ::core::option::Option::unwrap_or(::core::cmp::PartialOrd::partial_cmp(&(*__self_0),
                                                                                               &(*__arg_1_0)),
                                                          ::core::cmp::Ordering::Greater)
                            == ::core::cmp::Ordering::Less,
                        _ => false,
                    }
                } else { __self_vi.lt(&__arg_1_vi) }
            }
        }
        #[inline]
        fn le(&self, other: &Scope) -> bool {
            {
                let __self_vi =
                    unsafe { ::core::intrinsics::discriminant_value(&*self) };
                let __arg_1_vi =
                    unsafe {
                        ::core::intrinsics::discriminant_value(&*other)
                    };
                if true && __self_vi == __arg_1_vi {
                    match (&*self, &*other) {
                        (&Scope::Read(ref __self_0),
                         &Scope::Read(ref __arg_1_0)) =>
                        ::core::option::Option::unwrap_or(::core::cmp::PartialOrd::partial_cmp(&(*__self_0),
                                                                                               &(*__arg_1_0)),
                                                          ::core::cmp::Ordering::Greater)
                            != ::core::cmp::Ordering::Greater,
                        (&Scope::Write(ref __self_0),
                         &Scope::Write(ref __arg_1_0)) =>
                        ::core::option::Option::unwrap_or(::core::cmp::PartialOrd::partial_cmp(&(*__self_0),
                                                                                               &(*__arg_1_0)),
                                                          ::core::cmp::Ordering::Greater)
                            != ::core::cmp::Ordering::Greater,
                        _ => true,
                    }
                } else { __self_vi.le(&__arg_1_vi) }
            }
        }
        #[inline]
        fn gt(&self, other: &Scope) -> bool {
            {
                let __self_vi =
                    unsafe { ::core::intrinsics::discriminant_value(&*self) };
                let __arg_1_vi =
                    unsafe {
                        ::core::intrinsics::discriminant_value(&*other)
                    };
                if true && __self_vi == __arg_1_vi {
                    match (&*self, &*other) {
                        (&Scope::Read(ref __self_0),
                         &Scope::Read(ref __arg_1_0)) =>
                        ::core::option::Option::unwrap_or(::core::cmp::PartialOrd::partial_cmp(&(*__self_0),
                                                                                               &(*__arg_1_0)),
                                                          ::core::cmp::Ordering::Less)
                            == ::core::cmp::Ordering::Greater,
                        (&Scope::Write(ref __self_0),
                         &Scope::Write(ref __arg_1_0)) =>
                        ::core::option::Option::unwrap_or(::core::cmp::PartialOrd::partial_cmp(&(*__self_0),
                                                                                               &(*__arg_1_0)),
                                                          ::core::cmp::Ordering::Less)
                            == ::core::cmp::Ordering::Greater,
                        _ => false,
                    }
                } else { __self_vi.gt(&__arg_1_vi) }
            }
        }
        #[inline]
        fn ge(&self, other: &Scope) -> bool {
            {
                let __self_vi =
                    unsafe { ::core::intrinsics::discriminant_value(&*self) };
                let __arg_1_vi =
                    unsafe {
                        ::core::intrinsics::discriminant_value(&*other)
                    };
                if true && __self_vi == __arg_1_vi {
                    match (&*self, &*other) {
                        (&Scope::Read(ref __self_0),
                         &Scope::Read(ref __arg_1_0)) =>
                        ::core::option::Option::unwrap_or(::core::cmp::PartialOrd::partial_cmp(&(*__self_0),
                                                                                               &(*__arg_1_0)),
                                                          ::core::cmp::Ordering::Less)
                            != ::core::cmp::Ordering::Less,
                        (&Scope::Write(ref __self_0),
                         &Scope::Write(ref __arg_1_0)) =>
                        ::core::option::Option::unwrap_or(::core::cmp::PartialOrd::partial_cmp(&(*__self_0),
                                                                                               &(*__arg_1_0)),
                                                          ::core::cmp::Ordering::Less)
                            != ::core::cmp::Ordering::Less,
                        _ => true,
                    }
                } else { __self_vi.ge(&__arg_1_vi) }
            }
        }
    }
    impl ::core::marker::StructuralEq for Scope { }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::cmp::Eq for Scope {
        #[inline]
        #[doc(hidden)]
        fn assert_receiver_is_total_eq(&self) -> () {
            {
                let _: ::core::cmp::AssertParamIsEq<Option<Read>>;
                let _: ::core::cmp::AssertParamIsEq<Option<Write>>;
            }
        }
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::hash::Hash for Scope {
        fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
            match (&*self,) {
                (&Scope::Read(ref __self_0),) => {
                    ::core::hash::Hash::hash(&unsafe {
                                                  ::core::intrinsics::discriminant_value(self)
                                              }, state);
                    ::core::hash::Hash::hash(&(*__self_0), state)
                }
                (&Scope::Write(ref __self_0),) => {
                    ::core::hash::Hash::hash(&unsafe {
                                                  ::core::intrinsics::discriminant_value(self)
                                              }, state);
                    ::core::hash::Hash::hash(&(*__self_0), state)
                }
                _ => {
                    ::core::hash::Hash::hash(&unsafe {
                                                  ::core::intrinsics::discriminant_value(self)
                                              }, state)
                }
            }
        }
    }
    #[doc(hidden)]
    #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
    const _IMPL_SERIALIZE_FOR_Scope: () =
        {
            #[allow(rust_2018_idioms, clippy :: useless_attribute)]
            extern crate serde as _serde;
            #[allow(unused_macros)]
            macro_rules! try {
                ($ __expr : expr) =>
                {
                    match $ __expr
                    {
                        _serde :: export :: Ok(__val) => __val, _serde ::
                        export :: Err(__err) =>
                        { return _serde :: export :: Err(__err) ; }
                    }
                }
            }
            #[automatically_derived]
            impl _serde::Serialize for Scope {
                fn serialize<__S>(&self, __serializer: __S)
                 -> _serde::export::Result<__S::Ok, __S::Error> where
                 __S: _serde::Serializer {
                    match *self {
                        Scope::Read(ref __field0) =>
                        _serde::Serializer::serialize_newtype_variant(__serializer,
                                                                      "Scope",
                                                                      0u32,
                                                                      "read",
                                                                      __field0),
                        Scope::Write(ref __field0) =>
                        _serde::Serializer::serialize_newtype_variant(__serializer,
                                                                      "Scope",
                                                                      1u32,
                                                                      "write",
                                                                      __field0),
                        Scope::Follow =>
                        _serde::Serializer::serialize_unit_variant(__serializer,
                                                                   "Scope",
                                                                   2u32,
                                                                   "follow"),
                        Scope::Push =>
                        _serde::Serializer::serialize_unit_variant(__serializer,
                                                                   "Scope",
                                                                   3u32,
                                                                   "push"),
                    }
                }
            }
        };
    impl FromStr for Scope {
        type Err = Error;
        fn from_str(s: &str) -> Result<Scope, Self::Err> {
            Ok(match s {
                   "read" => Scope::Read(None),
                   "write" => Scope::Write(None),
                   "follow" => Scope::Follow,
                   "push" => Scope::Push,
                   read if read.starts_with("read:") => {
                       let r: Read = Read::from_str(&read[5..])?;
                       Scope::Read(Some(r))
                   }
                   write if write.starts_with("write:") => {
                       let w: Write = Write::from_str(&write[6..])?;
                       Scope::Write(Some(w))
                   }
                   _ => return Err(Error::Other("Unknown scope".to_string())),
               })
        }
    }
    impl Ord for Scope {
        fn cmp(&self, other: &Scope) -> Ordering {
            match (*self, *other) {
                (Scope::Read(None), Scope::Read(None)) => Ordering::Equal,
                (Scope::Read(None), Scope::Read(Some(..))) => Ordering::Less,
                (Scope::Read(Some(..)), Scope::Read(None)) =>
                Ordering::Greater,
                (Scope::Read(Some(ref a)), Scope::Read(Some(ref b))) =>
                a.cmp(b),
                (Scope::Write(None), Scope::Write(None)) => Ordering::Equal,
                (Scope::Write(None), Scope::Write(Some(..))) =>
                Ordering::Less,
                (Scope::Write(Some(..)), Scope::Write(None)) =>
                Ordering::Greater,
                (Scope::Write(Some(ref a)), Scope::Write(Some(ref b))) =>
                a.cmp(b),
                (Scope::Read(..), Scope::Write(..)) => Ordering::Less,
                (Scope::Read(..), Scope::Follow) => Ordering::Less,
                (Scope::Read(..), Scope::Push) => Ordering::Less,
                (Scope::Write(..), Scope::Read(..)) => Ordering::Greater,
                (Scope::Write(..), Scope::Follow) => Ordering::Less,
                (Scope::Write(..), Scope::Push) => Ordering::Less,
                (Scope::Follow, Scope::Read(..)) => Ordering::Greater,
                (Scope::Follow, Scope::Write(..)) => Ordering::Greater,
                (Scope::Follow, Scope::Follow) => Ordering::Equal,
                (Scope::Follow, Scope::Push) => Ordering::Less,
                (Scope::Push, Scope::Push) => Ordering::Equal,
                (Scope::Push, _) => Ordering::Greater,
            }
        }
    }
    impl fmt::Display for Scope {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            use self::Scope::*;
            let s =
                match *self {
                    Read(Some(ref r)) => return fmt::Display::fmt(r, f),
                    Read(None) => "read",
                    Write(Some(ref w)) => return fmt::Display::fmt(w, f),
                    Write(None) => "write",
                    Follow => "follow",
                    Push => "push",
                };
            f.write_fmt(::core::fmt::Arguments::new_v1(&[""],
                                                       &match (&s,) {
                                                            (arg0,) =>
                                                            [::core::fmt::ArgumentV1::new(arg0,
                                                                                          ::core::fmt::Display::fmt)],
                                                        }))
        }
    }
    impl Default for Scope {
        fn default() -> Self { Scope::Read(None) }
    }
    /// Represents the granular "read:___" oauth scopes
    pub enum Read {

        /// Accounts
        #[serde(rename = "accounts")]
        Accounts,

        /// Blocks
        #[serde(rename = "blocks")]
        Blocks,

        /// Favourites
        #[serde(rename = "favourites")]
        Favourites,

        /// Filters
        #[serde(rename = "filters")]
        Filters,

        /// Follows
        #[serde(rename = "follows")]
        Follows,

        /// Lists
        #[serde(rename = "lists")]
        Lists,

        /// Mutes
        #[serde(rename = "mutes")]
        Mutes,

        /// Notifications
        #[serde(rename = "notifications")]
        Notifications,

        /// Reports
        #[serde(rename = "reports")]
        Reports,

        /// Search
        #[serde(rename = "search")]
        Search,

        /// Statuses
        #[serde(rename = "statuses")]
        Statuses,
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::fmt::Debug for Read {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            match (&*self,) {
                (&Read::Accounts,) => {
                    let mut debug_trait_builder = f.debug_tuple("Accounts");
                    debug_trait_builder.finish()
                }
                (&Read::Blocks,) => {
                    let mut debug_trait_builder = f.debug_tuple("Blocks");
                    debug_trait_builder.finish()
                }
                (&Read::Favourites,) => {
                    let mut debug_trait_builder = f.debug_tuple("Favourites");
                    debug_trait_builder.finish()
                }
                (&Read::Filters,) => {
                    let mut debug_trait_builder = f.debug_tuple("Filters");
                    debug_trait_builder.finish()
                }
                (&Read::Follows,) => {
                    let mut debug_trait_builder = f.debug_tuple("Follows");
                    debug_trait_builder.finish()
                }
                (&Read::Lists,) => {
                    let mut debug_trait_builder = f.debug_tuple("Lists");
                    debug_trait_builder.finish()
                }
                (&Read::Mutes,) => {
                    let mut debug_trait_builder = f.debug_tuple("Mutes");
                    debug_trait_builder.finish()
                }
                (&Read::Notifications,) => {
                    let mut debug_trait_builder =
                        f.debug_tuple("Notifications");
                    debug_trait_builder.finish()
                }
                (&Read::Reports,) => {
                    let mut debug_trait_builder = f.debug_tuple("Reports");
                    debug_trait_builder.finish()
                }
                (&Read::Search,) => {
                    let mut debug_trait_builder = f.debug_tuple("Search");
                    debug_trait_builder.finish()
                }
                (&Read::Statuses,) => {
                    let mut debug_trait_builder = f.debug_tuple("Statuses");
                    debug_trait_builder.finish()
                }
            }
        }
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::clone::Clone for Read {
        #[inline]
        fn clone(&self) -> Read { { *self } }
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::marker::Copy for Read { }
    impl ::core::marker::StructuralPartialEq for Read { }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::cmp::PartialEq for Read {
        #[inline]
        fn eq(&self, other: &Read) -> bool {
            {
                let __self_vi =
                    unsafe { ::core::intrinsics::discriminant_value(&*self) };
                let __arg_1_vi =
                    unsafe {
                        ::core::intrinsics::discriminant_value(&*other)
                    };
                if true && __self_vi == __arg_1_vi {
                    match (&*self, &*other) { _ => true, }
                } else { false }
            }
        }
    }
    impl ::core::marker::StructuralEq for Read { }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::cmp::Eq for Read {
        #[inline]
        #[doc(hidden)]
        fn assert_receiver_is_total_eq(&self) -> () { { } }
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::hash::Hash for Read {
        fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
            match (&*self,) {
                _ => {
                    ::core::hash::Hash::hash(&unsafe {
                                                  ::core::intrinsics::discriminant_value(self)
                                              }, state)
                }
            }
        }
    }
    #[doc(hidden)]
    #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
    const _IMPL_SERIALIZE_FOR_Read: () =
        {
            #[allow(rust_2018_idioms, clippy :: useless_attribute)]
            extern crate serde as _serde;
            #[allow(unused_macros)]
            macro_rules! try {
                ($ __expr : expr) =>
                {
                    match $ __expr
                    {
                        _serde :: export :: Ok(__val) => __val, _serde ::
                        export :: Err(__err) =>
                        { return _serde :: export :: Err(__err) ; }
                    }
                }
            }
            #[automatically_derived]
            impl _serde::Serialize for Read {
                fn serialize<__S>(&self, __serializer: __S)
                 -> _serde::export::Result<__S::Ok, __S::Error> where
                 __S: _serde::Serializer {
                    match *self {
                        Read::Accounts =>
                        _serde::Serializer::serialize_unit_variant(__serializer,
                                                                   "Read",
                                                                   0u32,
                                                                   "accounts"),
                        Read::Blocks =>
                        _serde::Serializer::serialize_unit_variant(__serializer,
                                                                   "Read",
                                                                   1u32,
                                                                   "blocks"),
                        Read::Favourites =>
                        _serde::Serializer::serialize_unit_variant(__serializer,
                                                                   "Read",
                                                                   2u32,
                                                                   "favourites"),
                        Read::Filters =>
                        _serde::Serializer::serialize_unit_variant(__serializer,
                                                                   "Read",
                                                                   3u32,
                                                                   "filters"),
                        Read::Follows =>
                        _serde::Serializer::serialize_unit_variant(__serializer,
                                                                   "Read",
                                                                   4u32,
                                                                   "follows"),
                        Read::Lists =>
                        _serde::Serializer::serialize_unit_variant(__serializer,
                                                                   "Read",
                                                                   5u32,
                                                                   "lists"),
                        Read::Mutes =>
                        _serde::Serializer::serialize_unit_variant(__serializer,
                                                                   "Read",
                                                                   6u32,
                                                                   "mutes"),
                        Read::Notifications =>
                        _serde::Serializer::serialize_unit_variant(__serializer,
                                                                   "Read",
                                                                   7u32,
                                                                   "notifications"),
                        Read::Reports =>
                        _serde::Serializer::serialize_unit_variant(__serializer,
                                                                   "Read",
                                                                   8u32,
                                                                   "reports"),
                        Read::Search =>
                        _serde::Serializer::serialize_unit_variant(__serializer,
                                                                   "Read",
                                                                   9u32,
                                                                   "search"),
                        Read::Statuses =>
                        _serde::Serializer::serialize_unit_variant(__serializer,
                                                                   "Read",
                                                                   10u32,
                                                                   "statuses"),
                    }
                }
            }
        };
    impl FromStr for Read {
        type Err = Error;
        fn from_str(s: &str) -> Result<Read, Self::Err> {
            Ok(match s {
                   "accounts" => Read::Accounts,
                   "blocks" => Read::Blocks,
                   "favourites" => Read::Favourites,
                   "filters" => Read::Filters,
                   "follows" => Read::Follows,
                   "lists" => Read::Lists,
                   "mutes" => Read::Mutes,
                   "notifications" => Read::Notifications,
                   "reports" => Read::Reports,
                   "search" => Read::Search,
                   "statuses" => Read::Statuses,
                   _ =>
                   return Err(Error::Other("Unknown 'read' subcategory".to_string())),
               })
        }
    }
    impl PartialOrd for Read {
        fn partial_cmp(&self, other: &Read) -> Option<Ordering> {
            Some(self.cmp(other))
        }
    }
    impl Ord for Read {
        fn cmp(&self, other: &Read) -> Ordering {
            let a =
                {
                    let res =
                        ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&[""],
                                                                            &match (&self,)
                                                                                 {
                                                                                 (arg0,)
                                                                                 =>
                                                                                 [::core::fmt::ArgumentV1::new(arg0,
                                                                                                               ::core::fmt::Debug::fmt)],
                                                                             }));
                    res
                };
            let b =
                {
                    let res =
                        ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&[""],
                                                                            &match (&other,)
                                                                                 {
                                                                                 (arg0,)
                                                                                 =>
                                                                                 [::core::fmt::ArgumentV1::new(arg0,
                                                                                                               ::core::fmt::Debug::fmt)],
                                                                             }));
                    res
                };
            a.cmp(&b)
        }
    }
    impl fmt::Display for Read {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            f.write_fmt(::core::fmt::Arguments::new_v1(&["read:"],
                                                       &match (&match *self {
                                                                    Read::Accounts
                                                                    =>
                                                                    "accounts",
                                                                    Read::Blocks
                                                                    =>
                                                                    "blocks",
                                                                    Read::Favourites
                                                                    =>
                                                                    "favourites",
                                                                    Read::Filters
                                                                    =>
                                                                    "filters",
                                                                    Read::Follows
                                                                    =>
                                                                    "follows",
                                                                    Read::Lists
                                                                    =>
                                                                    "lists",
                                                                    Read::Mutes
                                                                    =>
                                                                    "mutes",
                                                                    Read::Notifications
                                                                    =>
                                                                    "notifications",
                                                                    Read::Reports
                                                                    =>
                                                                    "reports",
                                                                    Read::Search
                                                                    =>
                                                                    "search",
                                                                    Read::Statuses
                                                                    =>
                                                                    "statuses",
                                                                },) {
                                                            (arg0,) =>
                                                            [::core::fmt::ArgumentV1::new(arg0,
                                                                                          ::core::fmt::Display::fmt)],
                                                        }))
        }
    }
    /// Represents the granular "write:___" oauth scopes
    pub enum Write {

        /// Accounts
        #[serde(rename = "accounts")]
        Accounts,

        /// Blocks
        #[serde(rename = "blocks")]
        Blocks,

        /// Favourites
        #[serde(rename = "favourites")]
        Favourites,

        /// Filters
        #[serde(rename = "filters")]
        Filters,

        /// Follows
        #[serde(rename = "follows")]
        Follows,

        /// Lists
        #[serde(rename = "lists")]
        Lists,

        /// Media
        #[serde(rename = "media")]
        Media,

        /// Mutes
        #[serde(rename = "mutes")]
        Mutes,

        /// Notifications
        #[serde(rename = "notifications")]
        Notifications,

        /// Reports
        #[serde(rename = "reports")]
        Reports,

        /// Statuses
        #[serde(rename = "statuses")]
        Statuses,
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::fmt::Debug for Write {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            match (&*self,) {
                (&Write::Accounts,) => {
                    let mut debug_trait_builder = f.debug_tuple("Accounts");
                    debug_trait_builder.finish()
                }
                (&Write::Blocks,) => {
                    let mut debug_trait_builder = f.debug_tuple("Blocks");
                    debug_trait_builder.finish()
                }
                (&Write::Favourites,) => {
                    let mut debug_trait_builder = f.debug_tuple("Favourites");
                    debug_trait_builder.finish()
                }
                (&Write::Filters,) => {
                    let mut debug_trait_builder = f.debug_tuple("Filters");
                    debug_trait_builder.finish()
                }
                (&Write::Follows,) => {
                    let mut debug_trait_builder = f.debug_tuple("Follows");
                    debug_trait_builder.finish()
                }
                (&Write::Lists,) => {
                    let mut debug_trait_builder = f.debug_tuple("Lists");
                    debug_trait_builder.finish()
                }
                (&Write::Media,) => {
                    let mut debug_trait_builder = f.debug_tuple("Media");
                    debug_trait_builder.finish()
                }
                (&Write::Mutes,) => {
                    let mut debug_trait_builder = f.debug_tuple("Mutes");
                    debug_trait_builder.finish()
                }
                (&Write::Notifications,) => {
                    let mut debug_trait_builder =
                        f.debug_tuple("Notifications");
                    debug_trait_builder.finish()
                }
                (&Write::Reports,) => {
                    let mut debug_trait_builder = f.debug_tuple("Reports");
                    debug_trait_builder.finish()
                }
                (&Write::Statuses,) => {
                    let mut debug_trait_builder = f.debug_tuple("Statuses");
                    debug_trait_builder.finish()
                }
            }
        }
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::clone::Clone for Write {
        #[inline]
        fn clone(&self) -> Write { { *self } }
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::marker::Copy for Write { }
    impl ::core::marker::StructuralPartialEq for Write { }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::cmp::PartialEq for Write {
        #[inline]
        fn eq(&self, other: &Write) -> bool {
            {
                let __self_vi =
                    unsafe { ::core::intrinsics::discriminant_value(&*self) };
                let __arg_1_vi =
                    unsafe {
                        ::core::intrinsics::discriminant_value(&*other)
                    };
                if true && __self_vi == __arg_1_vi {
                    match (&*self, &*other) { _ => true, }
                } else { false }
            }
        }
    }
    impl ::core::marker::StructuralEq for Write { }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::cmp::Eq for Write {
        #[inline]
        #[doc(hidden)]
        fn assert_receiver_is_total_eq(&self) -> () { { } }
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::hash::Hash for Write {
        fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
            match (&*self,) {
                _ => {
                    ::core::hash::Hash::hash(&unsafe {
                                                  ::core::intrinsics::discriminant_value(self)
                                              }, state)
                }
            }
        }
    }
    #[doc(hidden)]
    #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
    const _IMPL_SERIALIZE_FOR_Write: () =
        {
            #[allow(rust_2018_idioms, clippy :: useless_attribute)]
            extern crate serde as _serde;
            #[allow(unused_macros)]
            macro_rules! try {
                ($ __expr : expr) =>
                {
                    match $ __expr
                    {
                        _serde :: export :: Ok(__val) => __val, _serde ::
                        export :: Err(__err) =>
                        { return _serde :: export :: Err(__err) ; }
                    }
                }
            }
            #[automatically_derived]
            impl _serde::Serialize for Write {
                fn serialize<__S>(&self, __serializer: __S)
                 -> _serde::export::Result<__S::Ok, __S::Error> where
                 __S: _serde::Serializer {
                    match *self {
                        Write::Accounts =>
                        _serde::Serializer::serialize_unit_variant(__serializer,
                                                                   "Write",
                                                                   0u32,
                                                                   "accounts"),
                        Write::Blocks =>
                        _serde::Serializer::serialize_unit_variant(__serializer,
                                                                   "Write",
                                                                   1u32,
                                                                   "blocks"),
                        Write::Favourites =>
                        _serde::Serializer::serialize_unit_variant(__serializer,
                                                                   "Write",
                                                                   2u32,
                                                                   "favourites"),
                        Write::Filters =>
                        _serde::Serializer::serialize_unit_variant(__serializer,
                                                                   "Write",
                                                                   3u32,
                                                                   "filters"),
                        Write::Follows =>
                        _serde::Serializer::serialize_unit_variant(__serializer,
                                                                   "Write",
                                                                   4u32,
                                                                   "follows"),
                        Write::Lists =>
                        _serde::Serializer::serialize_unit_variant(__serializer,
                                                                   "Write",
                                                                   5u32,
                                                                   "lists"),
                        Write::Media =>
                        _serde::Serializer::serialize_unit_variant(__serializer,
                                                                   "Write",
                                                                   6u32,
                                                                   "media"),
                        Write::Mutes =>
                        _serde::Serializer::serialize_unit_variant(__serializer,
                                                                   "Write",
                                                                   7u32,
                                                                   "mutes"),
                        Write::Notifications =>
                        _serde::Serializer::serialize_unit_variant(__serializer,
                                                                   "Write",
                                                                   8u32,
                                                                   "notifications"),
                        Write::Reports =>
                        _serde::Serializer::serialize_unit_variant(__serializer,
                                                                   "Write",
                                                                   9u32,
                                                                   "reports"),
                        Write::Statuses =>
                        _serde::Serializer::serialize_unit_variant(__serializer,
                                                                   "Write",
                                                                   10u32,
                                                                   "statuses"),
                    }
                }
            }
        };
    impl FromStr for Write {
        type Err = Error;
        fn from_str(s: &str) -> Result<Write, Self::Err> {
            Ok(match s {
                   "accounts" => Write::Accounts,
                   "blocks" => Write::Blocks,
                   "favourites" => Write::Favourites,
                   "filters" => Write::Filters,
                   "follows" => Write::Follows,
                   "lists" => Write::Lists,
                   "media" => Write::Media,
                   "mutes" => Write::Mutes,
                   "notifications" => Write::Notifications,
                   "reports" => Write::Reports,
                   "statuses" => Write::Statuses,
                   _ =>
                   return Err(Error::Other("Unknown 'write' subcategory".to_string())),
               })
        }
    }
    impl PartialOrd for Write {
        fn partial_cmp(&self, other: &Write) -> Option<Ordering> {
            Some(self.cmp(other))
        }
    }
    impl Ord for Write {
        fn cmp(&self, other: &Write) -> Ordering {
            let a =
                {
                    let res =
                        ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&[""],
                                                                            &match (&self,)
                                                                                 {
                                                                                 (arg0,)
                                                                                 =>
                                                                                 [::core::fmt::ArgumentV1::new(arg0,
                                                                                                               ::core::fmt::Debug::fmt)],
                                                                             }));
                    res
                };
            let b =
                {
                    let res =
                        ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&[""],
                                                                            &match (&other,)
                                                                                 {
                                                                                 (arg0,)
                                                                                 =>
                                                                                 [::core::fmt::ArgumentV1::new(arg0,
                                                                                                               ::core::fmt::Debug::fmt)],
                                                                             }));
                    res
                };
            a.cmp(&b)
        }
    }
    impl fmt::Display for Write {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            f.write_fmt(::core::fmt::Arguments::new_v1(&["write:"],
                                                       &match (&match *self {
                                                                    Write::Accounts
                                                                    =>
                                                                    "accounts",
                                                                    Write::Blocks
                                                                    =>
                                                                    "blocks",
                                                                    Write::Favourites
                                                                    =>
                                                                    "favourites",
                                                                    Write::Filters
                                                                    =>
                                                                    "filters",
                                                                    Write::Follows
                                                                    =>
                                                                    "follows",
                                                                    Write::Lists
                                                                    =>
                                                                    "lists",
                                                                    Write::Media
                                                                    =>
                                                                    "media",
                                                                    Write::Mutes
                                                                    =>
                                                                    "mutes",
                                                                    Write::Notifications
                                                                    =>
                                                                    "notifications",
                                                                    Write::Reports
                                                                    =>
                                                                    "reports",
                                                                    Write::Statuses
                                                                    =>
                                                                    "statuses",
                                                                },) {
                                                            (arg0,) =>
                                                            [::core::fmt::ArgumentV1::new(arg0,
                                                                                          ::core::fmt::Display::fmt)],
                                                        }))
        }
    }
}
/// Constructing a status
pub mod status_builder {
    use isolang::Language;
    /// A builder pattern struct for constructing a status.
    ///
    /// # Example
    ///
    /// ```
    /// # extern crate elefren;
    /// # use elefren::{Language, StatusBuilder};
    ///
    /// # fn main() -> Result<(), elefren::Error> {
    /// let status = StatusBuilder::new()
    ///     .status("a status")
    ///     .sensitive(true)
    ///     .spoiler_text("a CW")
    ///     .language(Language::Eng)
    ///     .build()?;
    /// # Ok(())
    /// # }
    /// ```
    pub struct StatusBuilder {
        status: Option<String>,
        in_reply_to_id: Option<String>,
        media_ids: Option<Vec<String>>,
        sensitive: Option<bool>,
        spoiler_text: Option<String>,
        content_type: Option<String>,
        visibility: Option<Visibility>,
        language: Option<Language>,
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::fmt::Debug for StatusBuilder {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            match *self {
                StatusBuilder {
                status: ref __self_0_0,
                in_reply_to_id: ref __self_0_1,
                media_ids: ref __self_0_2,
                sensitive: ref __self_0_3,
                spoiler_text: ref __self_0_4,
                content_type: ref __self_0_5,
                visibility: ref __self_0_6,
                language: ref __self_0_7 } => {
                    let mut debug_trait_builder =
                        f.debug_struct("StatusBuilder");
                    let _ =
                        debug_trait_builder.field("status", &&(*__self_0_0));
                    let _ =
                        debug_trait_builder.field("in_reply_to_id",
                                                  &&(*__self_0_1));
                    let _ =
                        debug_trait_builder.field("media_ids",
                                                  &&(*__self_0_2));
                    let _ =
                        debug_trait_builder.field("sensitive",
                                                  &&(*__self_0_3));
                    let _ =
                        debug_trait_builder.field("spoiler_text",
                                                  &&(*__self_0_4));
                    let _ =
                        debug_trait_builder.field("content_type",
                                                  &&(*__self_0_5));
                    let _ =
                        debug_trait_builder.field("visibility",
                                                  &&(*__self_0_6));
                    let _ =
                        debug_trait_builder.field("language",
                                                  &&(*__self_0_7));
                    debug_trait_builder.finish()
                }
            }
        }
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::default::Default for StatusBuilder {
        #[inline]
        fn default() -> StatusBuilder {
            StatusBuilder{status: ::core::default::Default::default(),
                          in_reply_to_id: ::core::default::Default::default(),
                          media_ids: ::core::default::Default::default(),
                          sensitive: ::core::default::Default::default(),
                          spoiler_text: ::core::default::Default::default(),
                          content_type: ::core::default::Default::default(),
                          visibility: ::core::default::Default::default(),
                          language: ::core::default::Default::default(),}
        }
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::clone::Clone for StatusBuilder {
        #[inline]
        fn clone(&self) -> StatusBuilder {
            match *self {
                StatusBuilder {
                status: ref __self_0_0,
                in_reply_to_id: ref __self_0_1,
                media_ids: ref __self_0_2,
                sensitive: ref __self_0_3,
                spoiler_text: ref __self_0_4,
                content_type: ref __self_0_5,
                visibility: ref __self_0_6,
                language: ref __self_0_7 } =>
                StatusBuilder{status:
                                  ::core::clone::Clone::clone(&(*__self_0_0)),
                              in_reply_to_id:
                                  ::core::clone::Clone::clone(&(*__self_0_1)),
                              media_ids:
                                  ::core::clone::Clone::clone(&(*__self_0_2)),
                              sensitive:
                                  ::core::clone::Clone::clone(&(*__self_0_3)),
                              spoiler_text:
                                  ::core::clone::Clone::clone(&(*__self_0_4)),
                              content_type:
                                  ::core::clone::Clone::clone(&(*__self_0_5)),
                              visibility:
                                  ::core::clone::Clone::clone(&(*__self_0_6)),
                              language:
                                  ::core::clone::Clone::clone(&(*__self_0_7)),},
            }
        }
    }
    impl ::core::marker::StructuralPartialEq for StatusBuilder { }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::cmp::PartialEq for StatusBuilder {
        #[inline]
        fn eq(&self, other: &StatusBuilder) -> bool {
            match *other {
                StatusBuilder {
                status: ref __self_1_0,
                in_reply_to_id: ref __self_1_1,
                media_ids: ref __self_1_2,
                sensitive: ref __self_1_3,
                spoiler_text: ref __self_1_4,
                content_type: ref __self_1_5,
                visibility: ref __self_1_6,
                language: ref __self_1_7 } =>
                match *self {
                    StatusBuilder {
                    status: ref __self_0_0,
                    in_reply_to_id: ref __self_0_1,
                    media_ids: ref __self_0_2,
                    sensitive: ref __self_0_3,
                    spoiler_text: ref __self_0_4,
                    content_type: ref __self_0_5,
                    visibility: ref __self_0_6,
                    language: ref __self_0_7 } =>
                    (*__self_0_0) == (*__self_1_0) &&
                        (*__self_0_1) == (*__self_1_1) &&
                        (*__self_0_2) == (*__self_1_2) &&
                        (*__self_0_3) == (*__self_1_3) &&
                        (*__self_0_4) == (*__self_1_4) &&
                        (*__self_0_5) == (*__self_1_5) &&
                        (*__self_0_6) == (*__self_1_6) &&
                        (*__self_0_7) == (*__self_1_7),
                },
            }
        }
        #[inline]
        fn ne(&self, other: &StatusBuilder) -> bool {
            match *other {
                StatusBuilder {
                status: ref __self_1_0,
                in_reply_to_id: ref __self_1_1,
                media_ids: ref __self_1_2,
                sensitive: ref __self_1_3,
                spoiler_text: ref __self_1_4,
                content_type: ref __self_1_5,
                visibility: ref __self_1_6,
                language: ref __self_1_7 } =>
                match *self {
                    StatusBuilder {
                    status: ref __self_0_0,
                    in_reply_to_id: ref __self_0_1,
                    media_ids: ref __self_0_2,
                    sensitive: ref __self_0_3,
                    spoiler_text: ref __self_0_4,
                    content_type: ref __self_0_5,
                    visibility: ref __self_0_6,
                    language: ref __self_0_7 } =>
                    (*__self_0_0) != (*__self_1_0) ||
                        (*__self_0_1) != (*__self_1_1) ||
                        (*__self_0_2) != (*__self_1_2) ||
                        (*__self_0_3) != (*__self_1_3) ||
                        (*__self_0_4) != (*__self_1_4) ||
                        (*__self_0_5) != (*__self_1_5) ||
                        (*__self_0_6) != (*__self_1_6) ||
                        (*__self_0_7) != (*__self_1_7),
                },
            }
        }
    }
    impl StatusBuilder {
        /// Create a StatusBuilder object
        ///
        /// # Example
        ///
        /// ```rust,no_run
        /// # use elefren::prelude::*;
        /// # use elefren::status_builder::Visibility;
        /// # fn main() -> Result<(), elefren::Error> {
        /// # let data = Data {
        /// #     base: "".into(),
        /// #     client_id: "".into(),
        /// #     client_secret: "".into(),
        /// #     redirect: "".into(),
        /// #     token: "".into(),
        /// # };
        /// # let client = Mastodon::from(data);
        /// let status = StatusBuilder::new()
        ///     .status("a status")
        ///     .visibility(Visibility::Public)
        ///     .build()?;
        /// client.new_status(status)?;
        /// #   Ok(())
        /// # }
        /// ```
        pub fn new() -> StatusBuilder { StatusBuilder::default() }
        /// Set the text for the post
        ///
        /// # Example
        ///
        /// ```rust
        /// # use elefren::prelude::*;
        /// # fn main() -> Result<(), elefren::Error> {
        /// let status = StatusBuilder::new().status("awoooooo").build()?;
        /// #   Ok(())
        /// # }
        /// ```
        pub fn status<I: Into<String>>(&mut self, status: I) -> &mut Self {
            self.status = Some(status.into());
            self
        }
        /// Set the in_reply_to_id for the post
        ///
        /// # Example
        ///
        /// ```rust
        /// # use elefren::prelude::*;
        /// # fn main() -> Result<(), elefren::Error> {
        /// let status = StatusBuilder::new()
        ///     .status("awooooo")
        ///     .in_reply_to("12345")
        ///     .build()?;
        /// #   Ok(())
        /// # }
        /// ```
        pub fn in_reply_to<I: Into<String>>(&mut self, id: I) -> &mut Self {
            self.in_reply_to_id = Some(id.into());
            self
        }
        /// Set the media_ids for the post
        ///
        /// # Example
        ///
        /// ```rust
        /// # use elefren::prelude::*;
        /// # fn main() -> Result<(), elefren::Error> {
        /// let status = StatusBuilder::new().media_ids(&["foo", "bar"]).build()?;
        /// #   Ok(())
        /// # }
        /// ```
        pub fn media_ids<S: std::fmt::Display,
                         I: IntoIterator<Item = S>>(&mut self, ids: I)
         -> &mut Self {
            self.media_ids =
                Some(ids.into_iter().map(|s|
                                             s.to_string()).collect::<Vec<_>>());
            self
        }
        /// Set the sensitive attribute for the post
        ///
        /// # Example
        ///
        /// ```rust
        /// # use elefren::prelude::*;
        /// # fn main() -> Result<(), elefren::Error> {
        /// let status = StatusBuilder::new()
        ///     .media_ids(&["foo", "bar"])
        ///     .sensitive(true)
        ///     .build()?;
        /// #   Ok(())
        /// # }
        /// ```
        pub fn sensitive(&mut self, sensitive: bool) -> &mut Self {
            self.sensitive = Some(sensitive);
            self
        }
        /// Set the spoiler text/CW for the post
        ///
        /// # Example
        ///
        /// ```rust
        /// # use elefren::prelude::*;
        /// # fn main() -> Result<(), elefren::Error> {
        /// let status = StatusBuilder::new()
        ///     .status("awoooo!!")
        ///     .spoiler_text("awoo inside")
        ///     .build()?;
        /// #   Ok(())
        /// # }
        /// ```
        pub fn spoiler_text<I: Into<String>>(&mut self, spoiler_text: I)
         -> &mut Self {
            self.spoiler_text = Some(spoiler_text.into());
            self
        }
        /// Set the content type of the post
        ///
        /// This is a Pleroma and Glitch-soc extension of the API.
        ///
        /// # Possible values
        /// - `text/plain`
        /// - `text/html`
        /// - `text/markdown`
        /// - `text/bbcode` (Pleroma only)
        ///
        /// The set of supported content types may vary by server.
        ///
        /// # Example
        ///
        /// ```rust
        /// # use elefren::prelude::*;
        /// # fn main() -> Result<(), elefren::Error> {
        /// let status = StatusBuilder::new()
        ///     .status("<b>thicc</b>")
        ///     .content_type("text/html")
        ///     .build()?;
        /// #   Ok(())
        /// # }
        /// ```
        pub fn content_type<I: Into<String>>(&mut self, content_type: I)
         -> &mut Self {
            self.content_type = Some(content_type.into());
            self
        }
        /// Set the visibility for the post
        ///
        /// # Example
        ///
        /// ```rust
        /// # use elefren::prelude::*;
        /// # use elefren::status_builder::Visibility;
        /// # fn main() -> Result<(), elefren::Error> {
        /// let status = StatusBuilder::new()
        ///     .status("awooooooo")
        ///     .visibility(Visibility::Public)
        ///     .build()?;
        /// #   Ok(())
        /// # }
        /// ```
        pub fn visibility(&mut self, visibility: Visibility) -> &mut Self {
            self.visibility = Some(visibility);
            self
        }
        /// Set the language for the post
        ///
        /// # Example
        ///
        /// ```rust
        /// # use elefren::prelude::*;
        /// # use elefren::Language;
        /// # fn main() -> Result<(), elefren::Error> {
        /// let status = StatusBuilder::new()
        ///     .status("awoo!!!!")
        ///     .language(Language::Eng)
        ///     .build()?;
        /// #   Ok(())
        /// # }
        /// ```
        pub fn language(&mut self, language: Language) -> &mut Self {
            self.language = Some(language);
            self
        }
        /// Constructs a NewStatus
        ///
        /// # Example
        ///
        /// ```rust
        /// # use elefren::prelude::*;
        /// # fn main() -> Result<(), elefren::Error> {
        /// let status = StatusBuilder::new().status("awoo!").build()?;
        /// #   Ok(())
        /// # }
        /// ```
        pub fn build(&self) -> Result<NewStatus, crate::Error> {
            if self.status.is_none() && self.media_ids.is_none() {
                return Err(crate::Error::Other("status text or media ids are required in order to post a status".to_string()));
            }
            Ok(NewStatus{status: self.status.clone(),
                         in_reply_to_id: self.in_reply_to_id.clone(),
                         media_ids: self.media_ids.clone(),
                         sensitive: self.sensitive.clone(),
                         spoiler_text: self.spoiler_text.clone(),
                         visibility: self.visibility.clone(),
                         language: self.language.clone(),
                         content_type: self.content_type.clone(),})
        }
    }
    /// Represents a post that can be sent to the POST /api/v1/status endpoint
    pub struct NewStatus {
        #[serde(skip_serializing_if = "Option::is_none")]
        status: Option<String>,
        #[serde(skip_serializing_if = "Option::is_none")]
        in_reply_to_id: Option<String>,
        #[serde(skip_serializing_if = "Option::is_none")]
        media_ids: Option<Vec<String>>,
        #[serde(skip_serializing_if = "Option::is_none")]
        sensitive: Option<bool>,
        #[serde(skip_serializing_if = "Option::is_none")]
        spoiler_text: Option<String>,
        #[serde(skip_serializing_if = "Option::is_none")]
        visibility: Option<Visibility>,
        #[serde(skip_serializing_if = "Option::is_none")]
        language: Option<Language>,
        #[serde(skip_serializing_if = "Option::is_none")]
        content_type: Option<String>,
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::fmt::Debug for NewStatus {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            match *self {
                NewStatus {
                status: ref __self_0_0,
                in_reply_to_id: ref __self_0_1,
                media_ids: ref __self_0_2,
                sensitive: ref __self_0_3,
                spoiler_text: ref __self_0_4,
                visibility: ref __self_0_5,
                language: ref __self_0_6,
                content_type: ref __self_0_7 } => {
                    let mut debug_trait_builder = f.debug_struct("NewStatus");
                    let _ =
                        debug_trait_builder.field("status", &&(*__self_0_0));
                    let _ =
                        debug_trait_builder.field("in_reply_to_id",
                                                  &&(*__self_0_1));
                    let _ =
                        debug_trait_builder.field("media_ids",
                                                  &&(*__self_0_2));
                    let _ =
                        debug_trait_builder.field("sensitive",
                                                  &&(*__self_0_3));
                    let _ =
                        debug_trait_builder.field("spoiler_text",
                                                  &&(*__self_0_4));
                    let _ =
                        debug_trait_builder.field("visibility",
                                                  &&(*__self_0_5));
                    let _ =
                        debug_trait_builder.field("language",
                                                  &&(*__self_0_6));
                    let _ =
                        debug_trait_builder.field("content_type",
                                                  &&(*__self_0_7));
                    debug_trait_builder.finish()
                }
            }
        }
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::default::Default for NewStatus {
        #[inline]
        fn default() -> NewStatus {
            NewStatus{status: ::core::default::Default::default(),
                      in_reply_to_id: ::core::default::Default::default(),
                      media_ids: ::core::default::Default::default(),
                      sensitive: ::core::default::Default::default(),
                      spoiler_text: ::core::default::Default::default(),
                      visibility: ::core::default::Default::default(),
                      language: ::core::default::Default::default(),
                      content_type: ::core::default::Default::default(),}
        }
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::clone::Clone for NewStatus {
        #[inline]
        fn clone(&self) -> NewStatus {
            match *self {
                NewStatus {
                status: ref __self_0_0,
                in_reply_to_id: ref __self_0_1,
                media_ids: ref __self_0_2,
                sensitive: ref __self_0_3,
                spoiler_text: ref __self_0_4,
                visibility: ref __self_0_5,
                language: ref __self_0_6,
                content_type: ref __self_0_7 } =>
                NewStatus{status: ::core::clone::Clone::clone(&(*__self_0_0)),
                          in_reply_to_id:
                              ::core::clone::Clone::clone(&(*__self_0_1)),
                          media_ids:
                              ::core::clone::Clone::clone(&(*__self_0_2)),
                          sensitive:
                              ::core::clone::Clone::clone(&(*__self_0_3)),
                          spoiler_text:
                              ::core::clone::Clone::clone(&(*__self_0_4)),
                          visibility:
                              ::core::clone::Clone::clone(&(*__self_0_5)),
                          language:
                              ::core::clone::Clone::clone(&(*__self_0_6)),
                          content_type:
                              ::core::clone::Clone::clone(&(*__self_0_7)),},
            }
        }
    }
    #[doc(hidden)]
    #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
    const _IMPL_SERIALIZE_FOR_NewStatus: () =
        {
            #[allow(rust_2018_idioms, clippy :: useless_attribute)]
            extern crate serde as _serde;
            #[allow(unused_macros)]
            macro_rules! try {
                ($ __expr : expr) =>
                {
                    match $ __expr
                    {
                        _serde :: export :: Ok(__val) => __val, _serde ::
                        export :: Err(__err) =>
                        { return _serde :: export :: Err(__err) ; }
                    }
                }
            }
            #[automatically_derived]
            impl _serde::Serialize for NewStatus {
                fn serialize<__S>(&self, __serializer: __S)
                 -> _serde::export::Result<__S::Ok, __S::Error> where
                 __S: _serde::Serializer {
                    let mut __serde_state =
                        match _serde::Serializer::serialize_struct(__serializer,
                                                                   "NewStatus",
                                                                   false as
                                                                       usize +
                                                                       if Option::is_none(&self.status)
                                                                          {
                                                                           0
                                                                       } else {
                                                                           1
                                                                       } +
                                                                       if Option::is_none(&self.in_reply_to_id)
                                                                          {
                                                                           0
                                                                       } else {
                                                                           1
                                                                       } +
                                                                       if Option::is_none(&self.media_ids)
                                                                          {
                                                                           0
                                                                       } else {
                                                                           1
                                                                       } +
                                                                       if Option::is_none(&self.sensitive)
                                                                          {
                                                                           0
                                                                       } else {
                                                                           1
                                                                       } +
                                                                       if Option::is_none(&self.spoiler_text)
                                                                          {
                                                                           0
                                                                       } else {
                                                                           1
                                                                       } +
                                                                       if Option::is_none(&self.visibility)
                                                                          {
                                                                           0
                                                                       } else {
                                                                           1
                                                                       } +
                                                                       if Option::is_none(&self.language)
                                                                          {
                                                                           0
                                                                       } else {
                                                                           1
                                                                       } +
                                                                       if Option::is_none(&self.content_type)
                                                                          {
                                                                           0
                                                                       } else {
                                                                           1
                                                                       }) {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                    if !Option::is_none(&self.status) {
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "status",
                                                                            &self.status)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                    } else {
                        match _serde::ser::SerializeStruct::skip_field(&mut __serde_state,
                                                                       "status")
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                    }
                    if !Option::is_none(&self.in_reply_to_id) {
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "in_reply_to_id",
                                                                            &self.in_reply_to_id)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                    } else {
                        match _serde::ser::SerializeStruct::skip_field(&mut __serde_state,
                                                                       "in_reply_to_id")
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                    }
                    if !Option::is_none(&self.media_ids) {
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "media_ids",
                                                                            &self.media_ids)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                    } else {
                        match _serde::ser::SerializeStruct::skip_field(&mut __serde_state,
                                                                       "media_ids")
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                    }
                    if !Option::is_none(&self.sensitive) {
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "sensitive",
                                                                            &self.sensitive)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                    } else {
                        match _serde::ser::SerializeStruct::skip_field(&mut __serde_state,
                                                                       "sensitive")
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                    }
                    if !Option::is_none(&self.spoiler_text) {
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "spoiler_text",
                                                                            &self.spoiler_text)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                    } else {
                        match _serde::ser::SerializeStruct::skip_field(&mut __serde_state,
                                                                       "spoiler_text")
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                    }
                    if !Option::is_none(&self.visibility) {
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "visibility",
                                                                            &self.visibility)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                    } else {
                        match _serde::ser::SerializeStruct::skip_field(&mut __serde_state,
                                                                       "visibility")
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                    }
                    if !Option::is_none(&self.language) {
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "language",
                                                                            &self.language)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                    } else {
                        match _serde::ser::SerializeStruct::skip_field(&mut __serde_state,
                                                                       "language")
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                    }
                    if !Option::is_none(&self.content_type) {
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "content_type",
                                                                            &self.content_type)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                    } else {
                        match _serde::ser::SerializeStruct::skip_field(&mut __serde_state,
                                                                       "content_type")
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                    }
                    _serde::ser::SerializeStruct::end(__serde_state)
                }
            }
        };
    impl ::core::marker::StructuralPartialEq for NewStatus { }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::cmp::PartialEq for NewStatus {
        #[inline]
        fn eq(&self, other: &NewStatus) -> bool {
            match *other {
                NewStatus {
                status: ref __self_1_0,
                in_reply_to_id: ref __self_1_1,
                media_ids: ref __self_1_2,
                sensitive: ref __self_1_3,
                spoiler_text: ref __self_1_4,
                visibility: ref __self_1_5,
                language: ref __self_1_6,
                content_type: ref __self_1_7 } =>
                match *self {
                    NewStatus {
                    status: ref __self_0_0,
                    in_reply_to_id: ref __self_0_1,
                    media_ids: ref __self_0_2,
                    sensitive: ref __self_0_3,
                    spoiler_text: ref __self_0_4,
                    visibility: ref __self_0_5,
                    language: ref __self_0_6,
                    content_type: ref __self_0_7 } =>
                    (*__self_0_0) == (*__self_1_0) &&
                        (*__self_0_1) == (*__self_1_1) &&
                        (*__self_0_2) == (*__self_1_2) &&
                        (*__self_0_3) == (*__self_1_3) &&
                        (*__self_0_4) == (*__self_1_4) &&
                        (*__self_0_5) == (*__self_1_5) &&
                        (*__self_0_6) == (*__self_1_6) &&
                        (*__self_0_7) == (*__self_1_7),
                },
            }
        }
        #[inline]
        fn ne(&self, other: &NewStatus) -> bool {
            match *other {
                NewStatus {
                status: ref __self_1_0,
                in_reply_to_id: ref __self_1_1,
                media_ids: ref __self_1_2,
                sensitive: ref __self_1_3,
                spoiler_text: ref __self_1_4,
                visibility: ref __self_1_5,
                language: ref __self_1_6,
                content_type: ref __self_1_7 } =>
                match *self {
                    NewStatus {
                    status: ref __self_0_0,
                    in_reply_to_id: ref __self_0_1,
                    media_ids: ref __self_0_2,
                    sensitive: ref __self_0_3,
                    spoiler_text: ref __self_0_4,
                    visibility: ref __self_0_5,
                    language: ref __self_0_6,
                    content_type: ref __self_0_7 } =>
                    (*__self_0_0) != (*__self_1_0) ||
                        (*__self_0_1) != (*__self_1_1) ||
                        (*__self_0_2) != (*__self_1_2) ||
                        (*__self_0_3) != (*__self_1_3) ||
                        (*__self_0_4) != (*__self_1_4) ||
                        (*__self_0_5) != (*__self_1_5) ||
                        (*__self_0_6) != (*__self_1_6) ||
                        (*__self_0_7) != (*__self_1_7),
                },
            }
        }
    }
    /// The visibility of a status.
    #[serde(rename_all = "lowercase")]
    pub enum Visibility {

        /// A Direct message to a user
        Direct,

        /// Only available to followers
        Private,

        /// Not shown in public timelines
        Unlisted,

        /// Posted to public timelines
        Public,
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::clone::Clone for Visibility {
        #[inline]
        fn clone(&self) -> Visibility { { *self } }
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::marker::Copy for Visibility { }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::fmt::Debug for Visibility {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            match (&*self,) {
                (&Visibility::Direct,) => {
                    let mut debug_trait_builder = f.debug_tuple("Direct");
                    debug_trait_builder.finish()
                }
                (&Visibility::Private,) => {
                    let mut debug_trait_builder = f.debug_tuple("Private");
                    debug_trait_builder.finish()
                }
                (&Visibility::Unlisted,) => {
                    let mut debug_trait_builder = f.debug_tuple("Unlisted");
                    debug_trait_builder.finish()
                }
                (&Visibility::Public,) => {
                    let mut debug_trait_builder = f.debug_tuple("Public");
                    debug_trait_builder.finish()
                }
            }
        }
    }
    #[doc(hidden)]
    #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
    const _IMPL_DESERIALIZE_FOR_Visibility: () =
        {
            #[allow(rust_2018_idioms, clippy :: useless_attribute)]
            extern crate serde as _serde;
            #[allow(unused_macros)]
            macro_rules! try {
                ($ __expr : expr) =>
                {
                    match $ __expr
                    {
                        _serde :: export :: Ok(__val) => __val, _serde ::
                        export :: Err(__err) =>
                        { return _serde :: export :: Err(__err) ; }
                    }
                }
            }
            #[automatically_derived]
            impl <'de> _serde::Deserialize<'de> for Visibility {
                fn deserialize<__D>(__deserializer: __D)
                 -> _serde::export::Result<Self, __D::Error> where
                 __D: _serde::Deserializer<'de> {
                    #[allow(non_camel_case_types)]
                    enum __Field { __field0, __field1, __field2, __field3, }
                    struct __FieldVisitor;
                    impl <'de> _serde::de::Visitor<'de> for __FieldVisitor {
                        type Value = __Field;
                        fn expecting(&self,
                                     __formatter:
                                         &mut _serde::export::Formatter)
                         -> _serde::export::fmt::Result {
                            _serde::export::Formatter::write_str(__formatter,
                                                                 "variant identifier")
                        }
                        fn visit_u64<__E>(self, __value: u64)
                         -> _serde::export::Result<Self::Value, __E> where
                         __E: _serde::de::Error {
                            match __value {
                                0u64 => _serde::export::Ok(__Field::__field0),
                                1u64 => _serde::export::Ok(__Field::__field1),
                                2u64 => _serde::export::Ok(__Field::__field2),
                                3u64 => _serde::export::Ok(__Field::__field3),
                                _ =>
                                _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                                                                     &"variant index 0 <= i < 4")),
                            }
                        }
                        fn visit_str<__E>(self, __value: &str)
                         -> _serde::export::Result<Self::Value, __E> where
                         __E: _serde::de::Error {
                            match __value {
                                "direct" =>
                                _serde::export::Ok(__Field::__field0),
                                "private" =>
                                _serde::export::Ok(__Field::__field1),
                                "unlisted" =>
                                _serde::export::Ok(__Field::__field2),
                                "public" =>
                                _serde::export::Ok(__Field::__field3),
                                _ => {
                                    _serde::export::Err(_serde::de::Error::unknown_variant(__value,
                                                                                           VARIANTS))
                                }
                            }
                        }
                        fn visit_bytes<__E>(self, __value: &[u8])
                         -> _serde::export::Result<Self::Value, __E> where
                         __E: _serde::de::Error {
                            match __value {
                                b"direct" =>
                                _serde::export::Ok(__Field::__field0),
                                b"private" =>
                                _serde::export::Ok(__Field::__field1),
                                b"unlisted" =>
                                _serde::export::Ok(__Field::__field2),
                                b"public" =>
                                _serde::export::Ok(__Field::__field3),
                                _ => {
                                    let __value =
                                        &_serde::export::from_utf8_lossy(__value);
                                    _serde::export::Err(_serde::de::Error::unknown_variant(__value,
                                                                                           VARIANTS))
                                }
                            }
                        }
                    }
                    impl <'de> _serde::Deserialize<'de> for __Field {
                        #[inline]
                        fn deserialize<__D>(__deserializer: __D)
                         -> _serde::export::Result<Self, __D::Error> where
                         __D: _serde::Deserializer<'de> {
                            _serde::Deserializer::deserialize_identifier(__deserializer,
                                                                         __FieldVisitor)
                        }
                    }
                    struct __Visitor<'de> {
                        marker: _serde::export::PhantomData<Visibility>,
                        lifetime: _serde::export::PhantomData<&'de ()>,
                    }
                    impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> {
                        type Value = Visibility;
                        fn expecting(&self,
                                     __formatter:
                                         &mut _serde::export::Formatter)
                         -> _serde::export::fmt::Result {
                            _serde::export::Formatter::write_str(__formatter,
                                                                 "enum Visibility")
                        }
                        fn visit_enum<__A>(self, __data: __A)
                         -> _serde::export::Result<Self::Value, __A::Error>
                         where __A: _serde::de::EnumAccess<'de> {
                            match match _serde::de::EnumAccess::variant(__data)
                                      {
                                      _serde::export::Ok(__val) => __val,
                                      _serde::export::Err(__err) => {
                                          return _serde::export::Err(__err);
                                      }
                                  } {
                                (__Field::__field0, __variant) => {
                                    match _serde::de::VariantAccess::unit_variant(__variant)
                                        {
                                        _serde::export::Ok(__val) => __val,
                                        _serde::export::Err(__err) => {
                                            return _serde::export::Err(__err);
                                        }
                                    };
                                    _serde::export::Ok(Visibility::Direct)
                                }
                                (__Field::__field1, __variant) => {
                                    match _serde::de::VariantAccess::unit_variant(__variant)
                                        {
                                        _serde::export::Ok(__val) => __val,
                                        _serde::export::Err(__err) => {
                                            return _serde::export::Err(__err);
                                        }
                                    };
                                    _serde::export::Ok(Visibility::Private)
                                }
                                (__Field::__field2, __variant) => {
                                    match _serde::de::VariantAccess::unit_variant(__variant)
                                        {
                                        _serde::export::Ok(__val) => __val,
                                        _serde::export::Err(__err) => {
                                            return _serde::export::Err(__err);
                                        }
                                    };
                                    _serde::export::Ok(Visibility::Unlisted)
                                }
                                (__Field::__field3, __variant) => {
                                    match _serde::de::VariantAccess::unit_variant(__variant)
                                        {
                                        _serde::export::Ok(__val) => __val,
                                        _serde::export::Err(__err) => {
                                            return _serde::export::Err(__err);
                                        }
                                    };
                                    _serde::export::Ok(Visibility::Public)
                                }
                            }
                        }
                    }
                    const VARIANTS: &'static [&'static str] =
                        &["direct", "private", "unlisted", "public"];
                    _serde::Deserializer::deserialize_enum(__deserializer,
                                                           "Visibility",
                                                           VARIANTS,
                                                           __Visitor{marker:
                                                                         _serde::export::PhantomData::<Visibility>,
                                                                     lifetime:
                                                                         _serde::export::PhantomData,})
                }
            }
        };
    #[doc(hidden)]
    #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
    const _IMPL_SERIALIZE_FOR_Visibility: () =
        {
            #[allow(rust_2018_idioms, clippy :: useless_attribute)]
            extern crate serde as _serde;
            #[allow(unused_macros)]
            macro_rules! try {
                ($ __expr : expr) =>
                {
                    match $ __expr
                    {
                        _serde :: export :: Ok(__val) => __val, _serde ::
                        export :: Err(__err) =>
                        { return _serde :: export :: Err(__err) ; }
                    }
                }
            }
            #[automatically_derived]
            impl _serde::Serialize for Visibility {
                fn serialize<__S>(&self, __serializer: __S)
                 -> _serde::export::Result<__S::Ok, __S::Error> where
                 __S: _serde::Serializer {
                    match *self {
                        Visibility::Direct =>
                        _serde::Serializer::serialize_unit_variant(__serializer,
                                                                   "Visibility",
                                                                   0u32,
                                                                   "direct"),
                        Visibility::Private =>
                        _serde::Serializer::serialize_unit_variant(__serializer,
                                                                   "Visibility",
                                                                   1u32,
                                                                   "private"),
                        Visibility::Unlisted =>
                        _serde::Serializer::serialize_unit_variant(__serializer,
                                                                   "Visibility",
                                                                   2u32,
                                                                   "unlisted"),
                        Visibility::Public =>
                        _serde::Serializer::serialize_unit_variant(__serializer,
                                                                   "Visibility",
                                                                   3u32,
                                                                   "public"),
                    }
                }
            }
        };
    impl ::core::marker::StructuralPartialEq for Visibility { }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::cmp::PartialEq for Visibility {
        #[inline]
        fn eq(&self, other: &Visibility) -> bool {
            {
                let __self_vi =
                    unsafe { ::core::intrinsics::discriminant_value(&*self) };
                let __arg_1_vi =
                    unsafe {
                        ::core::intrinsics::discriminant_value(&*other)
                    };
                if true && __self_vi == __arg_1_vi {
                    match (&*self, &*other) { _ => true, }
                } else { false }
            }
        }
    }
    impl Default for Visibility {
        fn default() -> Self { Visibility::Public }
    }
}
#[macro_use]
mod macros {
    macro_rules! methods {
        ($ ($ method : ident,) +) =>
        {
            $
            (fn $ method < T : for < 'de > serde :: Deserialize < 'de >>
             (& self, url : String) -> Result < T >
             {
                 let response = self . send(self . client . $ method(& url)) ?
                 ; deserialise(response)
             }) +
        } ;
    }
    macro_rules! paged_routes {
        (($ method : ident) $ name : ident : $ url : expr => $ ret : ty, $
         ($ rest : tt) *) =>
        {
            doc_comment !
            {
                concat !
                ("Equivalent to `", stringify ! ($ method), " /api/v1/", $
                 url, "`\n# Errors\nIf `access_token` is not set.", "\n",
                 "```no_run", "# extern crate elefren;\n",
                 "# use elefren::prelude::*;\n",
                 "# fn main() -> Result<(), Box<::std::error::Error>> {\n",
                 "# let data = Data {\n",
                 "#     base: \"https://example.com\".into(),\n",
                 "#     client_id: \"taosuah\".into(),\n",
                 "#     client_secret: \"htnjdiuae\".into(),\n",
                 "#     redirect: \"https://example.com\".into(),\n",
                 "#     token: \"tsaohueaheis\".into(),\n", "# };\n",
                 "let client = Mastodon::from(data);\n", "client.", stringify
                 ! ($ name), "();\n", "#   Ok(())\n", "# }\n", "```"), async
                fn $ name(& self) -> Result < Page < '_, $ ret >>
                {
                    let url = self . route(concat ! ("/api/v1/", $ url)) ; let
                    response = self . send(self . client . $ method(& url)) ?
                    ; Page :: new(self, response)
                }
            } paged_routes ! { $ ($ rest) * }
        } ;
        ((get($ ($ (# [$ m : meta]) * $ param : ident : $ typ : ty,) *)) $
         name : ident : $ url : expr => $ ret : ty, $ ($ rest : tt) *) =>
        {
            doc_comment !
            {
                concat !
                ("Equivalent to `get /api/v1/", $ url,
                 "`\n# Errors\nIf `access_token` is not set."), async fn $
                name < 'a > (& self, $ ($ param : $ typ,) *) -> Result < Page
                < '_, $ ret >>
                {
                    use serde_urlencoded ; # [derive(Serialize)] struct Data <
                    'a >
                    {
                        $ ($ (# [$ m]) * $ param : $ typ,) * # [serde(skip)]
                        _marker : :: std :: marker :: PhantomData < & 'a () >,
                    } let qs_data = Data
                    {
                        $ ($ param : $ param,) * _marker : :: std :: marker ::
                        PhantomData,
                    } ; let qs = serde_urlencoded :: to_string(& qs_data) ? ;
                    let url = format !
                    (concat ! ("/api/v1/", $ url, "?{}"), & qs) ; let response
                    = self . send(self . client . get(& url)) ? ; Page ::
                    new(self, response)
                }
            } paged_routes ! { $ ($ rest) * }
        } ; () => { }
    }
    macro_rules! route_v2 {
        ((get($ ($ param : ident : $ typ : ty,) *)) $ name : ident : $ url :
         expr => $ ret : ty, $ ($ rest : tt) *) =>
        {
            doc_comment !
            {
                concat !
                ("Equivalent to `get /api/v2/", $ url,
                 "`\n# Errors\nIf `access_token` is not set."), fn $ name < 'a
                > (& self, $ ($ param : $ typ,) *) -> Result < $ ret >
                {
                    use serde_urlencoded ; # [derive(Serialize)] struct Data <
                    'a >
                    {
                        $ ($ param : $ typ,) * # [serde(skip)] _marker : ::
                        std :: marker :: PhantomData < & 'a () >,
                    } let qs_data = Data
                    {
                        $ ($ param : $ param,) * _marker : :: std :: marker ::
                        PhantomData,
                    } ; let qs = serde_urlencoded :: to_string(& qs_data) ? ;
                    let url = format !
                    (concat ! ("/api/v2/", $ url, "?{}"), & qs) ;
                    Ok(self . get(self . route(& url)) ?)
                }
            } route_v2 ! { $ ($ rest) * }
        } ; () => { }
    }
    macro_rules! route {
        ((post multipart($ ($ param : ident : $ typ : ty,) *)) $ name : ident
         : $ url : expr => $ ret : ty, $ ($ rest : tt) *) =>
        {
            doc_comment !
            {
                concat !
                ("Equivalent to `post /api/v1/", $ url,
                 "`\n# Errors\nIf `access_token` is not set."), fn $
                name(& self, $ ($ param : $ typ,) *) -> Result < $ ret >
                {
                    use reqwest :: multipart :: Form ; let form_data = Form ::
                    new() $
                    (. file(stringify ! ($ param), $ param . as_ref()) ?) * ;
                    let response = self .
                    send(self . client .
                         post(& self . route(concat ! ("/api/v1/", $ url))) .
                         multipart(form_data)) ? ; let status = response .
                    status() . clone() ; if status . is_client_error()
                    { return Err(Error :: Client(status)) ; } else if status .
                    is_server_error()
                    { return Err(Error :: Server(status)) ; }
                    deserialise(response)
                }
            } route ! { $ ($ rest) * }
        } ;
        ((get($ ($ param : ident : $ typ : ty,) *)) $ name : ident : $ url :
         expr => $ ret : ty, $ ($ rest : tt) *) =>
        {
            doc_comment !
            {
                concat !
                ("Equivalent to `get /api/v1/", $ url,
                 "`\n# Errors\nIf `access_token` is not set."), fn $ name < 'a
                > (& self, $ ($ param : $ typ,) *) -> Result < $ ret >
                {
                    use serde_urlencoded ; # [derive(Serialize)] struct Data <
                    'a >
                    {
                        $ ($ param : $ typ,) * # [serde(skip)] _marker : ::
                        std :: marker :: PhantomData < & 'a () >,
                    } let qs_data = Data
                    {
                        $ ($ param : $ param,) * _marker : :: std :: marker ::
                        PhantomData,
                    } ; let qs = serde_urlencoded :: to_string(& qs_data) ? ;
                    let url = format !
                    (concat ! ("/api/v1/", $ url, "?{}"), & qs) ;
                    Ok(self . get(self . route(& url)) ?)
                }
            } route ! { $ ($ rest) * }
        } ;
        (($ method : ident($ ($ param : ident : $ typ : ty,) *)) $ name :
         ident : $ url : expr => $ ret : ty, $ ($ rest : tt) *) =>
        {
            doc_comment !
            {
                concat !
                ("Equivalent to `", stringify ! ($ method), " /api/v1/", $
                 url, "`\n# Errors\nIf `access_token` is not set.",), fn $
                name(& self, $ ($ param : $ typ,) *) -> Result < $ ret >
                {
                    let form_data = json !
                    ({ $ (stringify ! ($ param) : $ param,) * }) ; let
                    response = self .
                    send(self . client . $
                         method(& self . route(concat ! ("/api/v1/", $ url)))
                         . json(& form_data)) ? ; let status = response .
                    status() . clone() ; if status . is_client_error()
                    { return Err(Error :: Client(status)) ; } else if status .
                    is_server_error()
                    { return Err(Error :: Server(status)) ; }
                    deserialise(response)
                }
            } route ! { $ ($ rest) * }
        } ;
        (($ method : ident) $ name : ident : $ url : expr => $ ret : ty, $
         ($ rest : tt) *) =>
        {
            doc_comment !
            {
                concat !
                ("Equivalent to `", stringify ! ($ method), " /api/v1/", $
                 url, "`\n# Errors\nIf `access_token` is not set.", "\n",
                 "```no_run", "# extern crate elefren;\n",
                 "# use elefren::prelude::*;\n",
                 "# fn main() -> Result<(), Box<::std::error::Error>> {\n",
                 "# let data = Data {\n",
                 "#     base: \"https://example.com\".into(),\n",
                 "#     client_id: \"taosuah\".into(),\n",
                 "#     client_secret: \"htnjdiuae\".into(),\n",
                 "#     redirect: \"https://example.com\".into(),\n",
                 "#     token: \"tsaohueaheis\".into(),\n", "# };\n",
                 "let client = Mastodon::from(data);\n", "client.", stringify
                 ! ($ name), "();\n", "#   Ok(())\n", "# }\n", "```"), fn $
                name(& self) -> Result < $ ret >
                {
                    self . $
                    method(self . route(concat ! ("/api/v1/", $ url)))
                }
            } route ! { $ ($ rest) * }
        } ; () => { }
    }
    macro_rules! route_id {
        ($ (($ method : ident) $ name : ident : $ url : expr => $ ret : ty,)
         *) =>
        {
            $
            (doc_comment !
             {
                 concat !
                 ("Equivalent to `", stringify ! ($ method), " /api/v1/", $
                  url, "`\n# Errors\nIf `access_token` is not set.", "\n",
                  "```no_run", "# extern crate elefren;\n",
                  "# use elefren::prelude::*;\n",
                  "# fn main() -> Result<(), Box<::std::error::Error>> {\n",
                  "# let data = Data {\n",
                  "#     base: \"https://example.com\".into(),\n",
                  "#     client_id: \"taosuah\".into(),\n",
                  "#     client_secret: \"htnjdiuae\".into(),\n",
                  "#     redirect: \"https://example.com\".into(),\n",
                  "#     token: \"tsaohueaheis\".into(),\n", "# };\n",
                  "let client = Mastodon::from(data);\n", "client.", stringify
                  ! ($ name), "(\"42\");\n", "#   Ok(())\n", "# }\n", "```"),
                 fn $ name(& self, id : & str) -> Result < $ ret >
                 {
                     self . $
                     method(self .
                            route(& format !
                                  (concat ! ("/api/v1/", $ url), id)))
                 }
             }) *
        }
    }
    macro_rules! paged_routes_with_id {
        (($ method : ident) $ name : ident : $ url : expr => $ ret : ty, $
         ($ rest : tt) *) =>
        {
            doc_comment !
            {
                concat !
                ("Equivalent to `", stringify ! ($ method), " /api/v1/", $
                 url, "`\n# Errors\nIf `access_token` is not set.", "\n",
                 "```no_run", "# extern crate elefren;\n",
                 "# use elefren::prelude::*;\n",
                 "# fn main() -> Result<(), Box<::std::error::Error>> {\n",
                 "# let data = Data {\n",
                 "#     base: \"https://example.com\".into(),\n",
                 "#     client_id: \"taosuah\".into(),\n",
                 "#     client_secret: \"htnjdiuae\".into(),\n",
                 "#     redirect: \"https://example.com\".into(),\n",
                 "#     token: \"tsaohueaheis\".into(),\n", "# };\n",
                 "let client = Mastodon::from(data);\n", "client.", stringify
                 ! ($ name), "(\"some-id\");\n", "#   Ok(())\n", "# }\n",
                 "```"), fn $ name(& self, id : & str) -> Result < Page < $
                ret >>
                {
                    let url = self .
                    route(& format ! (concat ! ("/api/v1/", $ url), id)) ; let
                    response = self . send(self . client . $ method(& url)) ?
                    ; Page :: new(self, response)
                }
            } paged_routes_with_id ! { $ ($ rest) * }
        } ; () => { }
    }
}
/// Automatically import the things you need
pub mod prelude {
    pub use crate::scopes::Scopes;
    pub use crate::Data;
    pub use crate::Mastodon;
    pub use crate::MastodonClient;
    pub use crate::NewStatus;
    pub use crate::Registration;
    pub use crate::StatusBuilder;
    pub use crate::StatusesRequest;
}
/// Your mastodon application client, handles all requests to and from Mastodon.
pub struct Mastodon {
    client: Client,
    /// Raw data about your mastodon instance.
    pub data: Data,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for Mastodon {
    #[inline]
    fn clone(&self) -> Mastodon {
        match *self {
            Mastodon { client: ref __self_0_0, data: ref __self_0_1 } =>
            Mastodon{client: ::core::clone::Clone::clone(&(*__self_0_0)),
                     data: ::core::clone::Clone::clone(&(*__self_0_1)),},
        }
    }
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for Mastodon {
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        match *self {
            Mastodon { client: ref __self_0_0, data: ref __self_0_1 } => {
                let mut debug_trait_builder = f.debug_struct("Mastodon");
                let _ = debug_trait_builder.field("client", &&(*__self_0_0));
                let _ = debug_trait_builder.field("data", &&(*__self_0_1));
                debug_trait_builder.finish()
            }
        }
    }
}
impl Mastodon {
    fn get<T: for<'de> serde::Deserialize<'de>>(&self, url: String)
     -> Result<T> {
        let response = self.send(self.client.get(&url))?;
        deserialise(response)
    }
    fn post<T: for<'de> serde::Deserialize<'de>>(&self, url: String)
     -> Result<T> {
        let response = self.send(self.client.post(&url))?;
        deserialise(response)
    }
    fn delete<T: for<'de> serde::Deserialize<'de>>(&self, url: String)
     -> Result<T> {
        let response = self.send(self.client.delete(&url))?;
        deserialise(response)
    }
    fn route(&self, url: &str) -> String {
        {
            let res =
                ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["", ""],
                                                                    &match (&self.base,
                                                                            &url)
                                                                         {
                                                                         (arg0,
                                                                          arg1)
                                                                         =>
                                                                         [::core::fmt::ArgumentV1::new(arg0,
                                                                                                       ::core::fmt::Display::fmt),
                                                                          ::core::fmt::ArgumentV1::new(arg1,
                                                                                                       ::core::fmt::Display::fmt)],
                                                                     }));
            res
        }
    }
    pub(crate) fn send(&self, req: RequestBuilder) -> Result<Response> {
        let req = req.bearer_auth(&self.token).build()?;
        Ok(self.client.execute(req)?)
    }
}
impl From<Data> for Mastodon {
    /// Creates a mastodon instance from the data struct.
    fn from(data: Data) -> Mastodon {
        let mut builder = MastodonBuilder::new();
        builder.data(data);
        builder.build().expect("We know `data` is present, so this should be fine")
    }
}
impl MastodonClient for Mastodon {
    #[doc =
      "Equivalent to `get /api/v1/favourites`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.favourites();\n#   Ok(())\n# }\n```"]
    async fn favourites(&self) -> Result<Page<'_, Status>> {
        let url = self.route("/api/v1/favourites");
        let response = self.send(self.client.get(&url))?;
        Page::new(self, response)
    }
    #[doc =
      "Equivalent to `get /api/v1/blocks`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.blocks();\n#   Ok(())\n# }\n```"]
    async fn blocks(&self) -> Result<Page<'_, Account>> {
        let url = self.route("/api/v1/blocks");
        let response = self.send(self.client.get(&url))?;
        Page::new(self, response)
    }
    #[doc =
      "Equivalent to `get /api/v1/domain_blocks`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.domain_blocks();\n#   Ok(())\n# }\n```"]
    async fn domain_blocks(&self) -> Result<Page<'_, String>> {
        let url = self.route("/api/v1/domain_blocks");
        let response = self.send(self.client.get(&url))?;
        Page::new(self, response)
    }
    #[doc =
      "Equivalent to `get /api/v1/follow_requests`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.follow_requests();\n#   Ok(())\n# }\n```"]
    async fn follow_requests(&self) -> Result<Page<'_, Account>> {
        let url = self.route("/api/v1/follow_requests");
        let response = self.send(self.client.get(&url))?;
        Page::new(self, response)
    }
    #[doc =
      "Equivalent to `get /api/v1/timelines/home`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.get_home_timeline();\n#   Ok(())\n# }\n```"]
    async fn get_home_timeline(&self) -> Result<Page<'_, Status>> {
        let url = self.route("/api/v1/timelines/home");
        let response = self.send(self.client.get(&url))?;
        Page::new(self, response)
    }
    #[doc =
      "Equivalent to `get /api/v1/custom_emojis`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.get_emojis();\n#   Ok(())\n# }\n```"]
    async fn get_emojis(&self) -> Result<Page<'_, Emoji>> {
        let url = self.route("/api/v1/custom_emojis");
        let response = self.send(self.client.get(&url))?;
        Page::new(self, response)
    }
    #[doc =
      "Equivalent to `get /api/v1/mutes`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.mutes();\n#   Ok(())\n# }\n```"]
    async fn mutes(&self) -> Result<Page<'_, Account>> {
        let url = self.route("/api/v1/mutes");
        let response = self.send(self.client.get(&url))?;
        Page::new(self, response)
    }
    #[doc =
      "Equivalent to `get /api/v1/notifications`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.notifications();\n#   Ok(())\n# }\n```"]
    async fn notifications(&self) -> Result<Page<'_, Notification>> {
        let url = self.route("/api/v1/notifications");
        let response = self.send(self.client.get(&url))?;
        Page::new(self, response)
    }
    #[doc =
      "Equivalent to `get /api/v1/reports`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.reports();\n#   Ok(())\n# }\n```"]
    async fn reports(&self) -> Result<Page<'_, Report>> {
        let url = self.route("/api/v1/reports");
        let response = self.send(self.client.get(&url))?;
        Page::new(self, response)
    }
    #[doc =
      "Equivalent to `get /api/v1/accounts/search`\n# Errors\nIf `access_token` is not set."]
    async fn search_accounts<'a>(&self, q: &'a str, limit: Option<u64>,
                                 following: bool)
     -> Result<Page<'_, Account>> {
        use serde_urlencoded;
        struct Data<'a> {
            q: &'a str,
            #[serde(skip_serializing_if = "Option::is_none")]
            limit: Option<u64>,
            following: bool,
            #[serde(skip)]
            _marker: ::std::marker::PhantomData<&'a ()>,
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_SERIALIZE_FOR_Data: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'a> _serde::Serialize for Data<'a> {
                    fn serialize<__S>(&self, __serializer: __S)
                     -> _serde::export::Result<__S::Ok, __S::Error> where
                     __S: _serde::Serializer {
                        let mut __serde_state =
                            match _serde::Serializer::serialize_struct(__serializer,
                                                                       "Data",
                                                                       false
                                                                           as
                                                                           usize
                                                                           + 1
                                                                           +
                                                                           if Option::is_none(&self.limit)
                                                                              {
                                                                               0
                                                                           } else {
                                                                               1
                                                                           } +
                                                                           1)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "q",
                                                                            &self.q)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        if !Option::is_none(&self.limit) {
                            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                "limit",
                                                                                &self.limit)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        } else {
                            match _serde::ser::SerializeStruct::skip_field(&mut __serde_state,
                                                                           "limit")
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        }
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "following",
                                                                            &self.following)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        _serde::ser::SerializeStruct::end(__serde_state)
                    }
                }
            };
        let qs_data =
            Data{q: q,
                 limit: limit,
                 following: following,
                 _marker: ::std::marker::PhantomData,};
        let qs = serde_urlencoded::to_string(&qs_data)?;
        let url =
            {
                let res =
                    ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/accounts/search?"],
                                                                        &match (&&qs,)
                                                                             {
                                                                             (arg0,)
                                                                             =>
                                                                             [::core::fmt::ArgumentV1::new(arg0,
                                                                                                           ::core::fmt::Display::fmt)],
                                                                         }));
                res
            };
        let response = self.send(self.client.get(&url))?;
        Page::new(self, response)
    }
    #[doc =
      "Equivalent to `get /api/v1/endorsements`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.get_endorsements();\n#   Ok(())\n# }\n```"]
    async fn get_endorsements(&self) -> Result<Page<'_, Account>> {
        let url = self.route("/api/v1/endorsements");
        let response = self.send(self.client.get(&url))?;
        Page::new(self, response)
    }
    #[doc =
      "Equivalent to `get /api/v1/accounts/{}/followers`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.followers(\"some-id\");\n#   Ok(())\n# }\n```"]
    fn followers(&self, id: &str) -> Result<Page<Account>> {
        let url =
            self.route(&{
                            let res =
                                ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/accounts/",
                                                                                      "/followers"],
                                                                                    &match (&id,)
                                                                                         {
                                                                                         (arg0,)
                                                                                         =>
                                                                                         [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                       ::core::fmt::Display::fmt)],
                                                                                     }));
                            res
                        });
        let response = self.send(self.client.get(&url))?;
        Page::new(self, response)
    }
    #[doc =
      "Equivalent to `get /api/v1/accounts/{}/following`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.following(\"some-id\");\n#   Ok(())\n# }\n```"]
    fn following(&self, id: &str) -> Result<Page<Account>> {
        let url =
            self.route(&{
                            let res =
                                ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/accounts/",
                                                                                      "/following"],
                                                                                    &match (&id,)
                                                                                         {
                                                                                         (arg0,)
                                                                                         =>
                                                                                         [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                       ::core::fmt::Display::fmt)],
                                                                                     }));
                            res
                        });
        let response = self.send(self.client.get(&url))?;
        Page::new(self, response)
    }
    #[doc =
      "Equivalent to `get /api/v1/statuses/{}/reblogged_by`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.reblogged_by(\"some-id\");\n#   Ok(())\n# }\n```"]
    fn reblogged_by(&self, id: &str) -> Result<Page<Account>> {
        let url =
            self.route(&{
                            let res =
                                ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/statuses/",
                                                                                      "/reblogged_by"],
                                                                                    &match (&id,)
                                                                                         {
                                                                                         (arg0,)
                                                                                         =>
                                                                                         [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                       ::core::fmt::Display::fmt)],
                                                                                     }));
                            res
                        });
        let response = self.send(self.client.get(&url))?;
        Page::new(self, response)
    }
    #[doc =
      "Equivalent to `get /api/v1/statuses/{}/favourited_by`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.favourited_by(\"some-id\");\n#   Ok(())\n# }\n```"]
    fn favourited_by(&self, id: &str) -> Result<Page<Account>> {
        let url =
            self.route(&{
                            let res =
                                ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/statuses/",
                                                                                      "/favourited_by"],
                                                                                    &match (&id,)
                                                                                         {
                                                                                         (arg0,)
                                                                                         =>
                                                                                         [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                       ::core::fmt::Display::fmt)],
                                                                                     }));
                            res
                        });
        let response = self.send(self.client.get(&url))?;
        Page::new(self, response)
    }
    #[doc =
      "Equivalent to `delete /api/v1/domain_blocks`\n# Errors\nIf `access_token` is not set."]
    fn unblock_domain(&self, domain: String) -> Result<Empty> {
        let form_data =
            ::serde_json::Value::Object({
                                            let mut object =
                                                ::serde_json::Map::new();
                                            let _ =
                                                object.insert(("domain").into(),
                                                              ::serde_json::to_value(&domain).unwrap());
                                            object
                                        });
        let response =
            self.send(self.client.delete(&self.route("/api/v1/domain_blocks")).json(&form_data))?;
        let status = response.status().clone();
        if status.is_client_error() {
            return Err(Error::Client(status));
        } else if status.is_server_error() {
            return Err(Error::Server(status));
        }
        deserialise(response)
    }
    #[doc =
      "Equivalent to `get /api/v1/instance`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.instance();\n#   Ok(())\n# }\n```"]
    fn instance(&self) -> Result<Instance> {
        self.get(self.route("/api/v1/instance"))
    }
    #[doc =
      "Equivalent to `get /api/v1/accounts/verify_credentials`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.verify_credentials();\n#   Ok(())\n# }\n```"]
    fn verify_credentials(&self) -> Result<Account> {
        self.get(self.route("/api/v1/accounts/verify_credentials"))
    }
    #[doc =
      "Equivalent to `post /api/v1/reports`\n# Errors\nIf `access_token` is not set."]
    fn report(&self, account_id: &str, status_ids: Vec<&str>, comment: String)
     -> Result<Report> {
        let form_data =
            ::serde_json::Value::Object({
                                            let mut object =
                                                ::serde_json::Map::new();
                                            let _ =
                                                object.insert(("account_id").into(),
                                                              ::serde_json::to_value(&account_id).unwrap());
                                            let _ =
                                                object.insert(("status_ids").into(),
                                                              ::serde_json::to_value(&status_ids).unwrap());
                                            let _ =
                                                object.insert(("comment").into(),
                                                              ::serde_json::to_value(&comment).unwrap());
                                            object
                                        });
        let response =
            self.send(self.client.post(&self.route("/api/v1/reports")).json(&form_data))?;
        let status = response.status().clone();
        if status.is_client_error() {
            return Err(Error::Client(status));
        } else if status.is_server_error() {
            return Err(Error::Server(status));
        }
        deserialise(response)
    }
    #[doc =
      "Equivalent to `post /api/v1/domain_blocks`\n# Errors\nIf `access_token` is not set."]
    fn block_domain(&self, domain: String) -> Result<Empty> {
        let form_data =
            ::serde_json::Value::Object({
                                            let mut object =
                                                ::serde_json::Map::new();
                                            let _ =
                                                object.insert(("domain").into(),
                                                              ::serde_json::to_value(&domain).unwrap());
                                            object
                                        });
        let response =
            self.send(self.client.post(&self.route("/api/v1/domain_blocks")).json(&form_data))?;
        let status = response.status().clone();
        if status.is_client_error() {
            return Err(Error::Client(status));
        } else if status.is_server_error() {
            return Err(Error::Server(status));
        }
        deserialise(response)
    }
    #[doc =
      "Equivalent to `post /api/v1/accounts/follow_requests/authorize`\n# Errors\nIf `access_token` is not set."]
    fn authorize_follow_request(&self, id: &str) -> Result<Empty> {
        let form_data =
            ::serde_json::Value::Object({
                                            let mut object =
                                                ::serde_json::Map::new();
                                            let _ =
                                                object.insert(("id").into(),
                                                              ::serde_json::to_value(&id).unwrap());
                                            object
                                        });
        let response =
            self.send(self.client.post(&self.route("/api/v1/accounts/follow_requests/authorize")).json(&form_data))?;
        let status = response.status().clone();
        if status.is_client_error() {
            return Err(Error::Client(status));
        } else if status.is_server_error() {
            return Err(Error::Server(status));
        }
        deserialise(response)
    }
    #[doc =
      "Equivalent to `post /api/v1/accounts/follow_requests/reject`\n# Errors\nIf `access_token` is not set."]
    fn reject_follow_request(&self, id: &str) -> Result<Empty> {
        let form_data =
            ::serde_json::Value::Object({
                                            let mut object =
                                                ::serde_json::Map::new();
                                            let _ =
                                                object.insert(("id").into(),
                                                              ::serde_json::to_value(&id).unwrap());
                                            object
                                        });
        let response =
            self.send(self.client.post(&self.route("/api/v1/accounts/follow_requests/reject")).json(&form_data))?;
        let status = response.status().clone();
        if status.is_client_error() {
            return Err(Error::Client(status));
        } else if status.is_server_error() {
            return Err(Error::Server(status));
        }
        deserialise(response)
    }
    #[doc =
      "Equivalent to `get /api/v1/search`\n# Errors\nIf `access_token` is not set."]
    fn search<'a>(&self, q: &'a str, resolve: bool) -> Result<SearchResult> {
        use serde_urlencoded;
        struct Data<'a> {
            q: &'a str,
            resolve: bool,
            #[serde(skip)]
            _marker: ::std::marker::PhantomData<&'a ()>,
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_SERIALIZE_FOR_Data: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'a> _serde::Serialize for Data<'a> {
                    fn serialize<__S>(&self, __serializer: __S)
                     -> _serde::export::Result<__S::Ok, __S::Error> where
                     __S: _serde::Serializer {
                        let mut __serde_state =
                            match _serde::Serializer::serialize_struct(__serializer,
                                                                       "Data",
                                                                       false
                                                                           as
                                                                           usize
                                                                           + 1
                                                                           +
                                                                           1)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "q",
                                                                            &self.q)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "resolve",
                                                                            &self.resolve)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        _serde::ser::SerializeStruct::end(__serde_state)
                    }
                }
            };
        let qs_data =
            Data{q: q,
                 resolve: resolve,
                 _marker: ::std::marker::PhantomData,};
        let qs = serde_urlencoded::to_string(&qs_data)?;
        let url =
            {
                let res =
                    ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/search?"],
                                                                        &match (&&qs,)
                                                                             {
                                                                             (arg0,)
                                                                             =>
                                                                             [::core::fmt::ArgumentV1::new(arg0,
                                                                                                           ::core::fmt::Display::fmt)],
                                                                         }));
                res
            };
        Ok(self.get(self.route(&url))?)
    }
    #[doc =
      "Equivalent to `get /api/v1/timelines/public`\n# Errors\nIf `access_token` is not set."]
    fn get_public_timeline<'a>(&self, local: bool) -> Result<Vec<Status>> {
        use serde_urlencoded;
        struct Data<'a> {
            local: bool,
            #[serde(skip)]
            _marker: ::std::marker::PhantomData<&'a ()>,
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_SERIALIZE_FOR_Data: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'a> _serde::Serialize for Data<'a> {
                    fn serialize<__S>(&self, __serializer: __S)
                     -> _serde::export::Result<__S::Ok, __S::Error> where
                     __S: _serde::Serializer {
                        let mut __serde_state =
                            match _serde::Serializer::serialize_struct(__serializer,
                                                                       "Data",
                                                                       false
                                                                           as
                                                                           usize
                                                                           +
                                                                           1)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "local",
                                                                            &self.local)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        _serde::ser::SerializeStruct::end(__serde_state)
                    }
                }
            };
        let qs_data =
            Data{local: local, _marker: ::std::marker::PhantomData,};
        let qs = serde_urlencoded::to_string(&qs_data)?;
        let url =
            {
                let res =
                    ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/timelines/public?"],
                                                                        &match (&&qs,)
                                                                             {
                                                                             (arg0,)
                                                                             =>
                                                                             [::core::fmt::ArgumentV1::new(arg0,
                                                                                                           ::core::fmt::Display::fmt)],
                                                                         }));
                res
            };
        Ok(self.get(self.route(&url))?)
    }
    #[doc =
      "Equivalent to `post /api/v1/follows`\n# Errors\nIf `access_token` is not set."]
    fn follows(&self, uri: Cow<'static, str>) -> Result<Account> {
        let form_data =
            ::serde_json::Value::Object({
                                            let mut object =
                                                ::serde_json::Map::new();
                                            let _ =
                                                object.insert(("uri").into(),
                                                              ::serde_json::to_value(&uri).unwrap());
                                            object
                                        });
        let response =
            self.send(self.client.post(&self.route("/api/v1/follows")).json(&form_data))?;
        let status = response.status().clone();
        if status.is_client_error() {
            return Err(Error::Client(status));
        } else if status.is_server_error() {
            return Err(Error::Server(status));
        }
        deserialise(response)
    }
    #[doc =
      "Equivalent to `post /api/v1/media`\n# Errors\nIf `access_token` is not set."]
    fn media(&self, file: Cow<'static, str>) -> Result<Attachment> {
        use reqwest::multipart::Form;
        let form_data = Form::new().file("file", file.as_ref())?;
        let response =
            self.send(self.client.post(&self.route("/api/v1/media")).multipart(form_data))?;
        let status = response.status().clone();
        if status.is_client_error() {
            return Err(Error::Client(status));
        } else if status.is_server_error() {
            return Err(Error::Server(status));
        }
        deserialise(response)
    }
    #[doc =
      "Equivalent to `post /api/v1/notifications/clear`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.clear_notifications();\n#   Ok(())\n# }\n```"]
    fn clear_notifications(&self) -> Result<Empty> {
        self.post(self.route("/api/v1/notifications/clear"))
    }
    #[doc =
      "Equivalent to `post /api/v1/notifications/dismiss`\n# Errors\nIf `access_token` is not set."]
    fn dismiss_notification(&self, id: &str) -> Result<Empty> {
        let form_data =
            ::serde_json::Value::Object({
                                            let mut object =
                                                ::serde_json::Map::new();
                                            let _ =
                                                object.insert(("id").into(),
                                                              ::serde_json::to_value(&id).unwrap());
                                            object
                                        });
        let response =
            self.send(self.client.post(&self.route("/api/v1/notifications/dismiss")).json(&form_data))?;
        let status = response.status().clone();
        if status.is_client_error() {
            return Err(Error::Client(status));
        } else if status.is_server_error() {
            return Err(Error::Server(status));
        }
        deserialise(response)
    }
    #[doc =
      "Equivalent to `get /api/v1/push/subscription`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.get_push_subscription();\n#   Ok(())\n# }\n```"]
    fn get_push_subscription(&self) -> Result<Subscription> {
        self.get(self.route("/api/v1/push/subscription"))
    }
    #[doc =
      "Equivalent to `delete /api/v1/push/subscription`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.delete_push_subscription();\n#   Ok(())\n# }\n```"]
    fn delete_push_subscription(&self) -> Result<Empty> {
        self.delete(self.route("/api/v1/push/subscription"))
    }
    #[doc =
      "Equivalent to `get /api/v1/filters`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.get_filters();\n#   Ok(())\n# }\n```"]
    fn get_filters(&self) -> Result<Vec<Filter>> {
        self.get(self.route("/api/v1/filters"))
    }
    #[doc =
      "Equivalent to `get /api/v1/suggestions`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.get_follow_suggestions();\n#   Ok(())\n# }\n```"]
    fn get_follow_suggestions(&self) -> Result<Vec<Account>> {
        self.get(self.route("/api/v1/suggestions"))
    }
    #[doc =
      "Equivalent to `get /api/v2/search`\n# Errors\nIf `access_token` is not set."]
    fn search_v2<'a>(&self, q: &'a str, resolve: bool)
     -> Result<SearchResultV2> {
        use serde_urlencoded;
        struct Data<'a> {
            q: &'a str,
            resolve: bool,
            #[serde(skip)]
            _marker: ::std::marker::PhantomData<&'a ()>,
        }
        #[doc(hidden)]
        #[allow(non_upper_case_globals, unused_attributes,
                unused_qualifications)]
        const _IMPL_SERIALIZE_FOR_Data: () =
            {
                #[allow(rust_2018_idioms, clippy :: useless_attribute)]
                extern crate serde as _serde;
                #[allow(unused_macros)]
                macro_rules! try {
                    ($ __expr : expr) =>
                    {
                        match $ __expr
                        {
                            _serde :: export :: Ok(__val) => __val, _serde ::
                            export :: Err(__err) =>
                            { return _serde :: export :: Err(__err) ; }
                        }
                    }
                }
                #[automatically_derived]
                impl <'a> _serde::Serialize for Data<'a> {
                    fn serialize<__S>(&self, __serializer: __S)
                     -> _serde::export::Result<__S::Ok, __S::Error> where
                     __S: _serde::Serializer {
                        let mut __serde_state =
                            match _serde::Serializer::serialize_struct(__serializer,
                                                                       "Data",
                                                                       false
                                                                           as
                                                                           usize
                                                                           + 1
                                                                           +
                                                                           1)
                                {
                                _serde::export::Ok(__val) => __val,
                                _serde::export::Err(__err) => {
                                    return _serde::export::Err(__err);
                                }
                            };
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "q",
                                                                            &self.q)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                            "resolve",
                                                                            &self.resolve)
                            {
                            _serde::export::Ok(__val) => __val,
                            _serde::export::Err(__err) => {
                                return _serde::export::Err(__err);
                            }
                        };
                        _serde::ser::SerializeStruct::end(__serde_state)
                    }
                }
            };
        let qs_data =
            Data{q: q,
                 resolve: resolve,
                 _marker: ::std::marker::PhantomData,};
        let qs = serde_urlencoded::to_string(&qs_data)?;
        let url =
            {
                let res =
                    ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v2/search?"],
                                                                        &match (&&qs,)
                                                                             {
                                                                             (arg0,)
                                                                             =>
                                                                             [::core::fmt::ArgumentV1::new(arg0,
                                                                                                           ::core::fmt::Display::fmt)],
                                                                         }));
                res
            };
        Ok(self.get(self.route(&url))?)
    }
    #[doc =
      "Equivalent to `get /api/v1/accounts/{}`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.get_account(\"42\");\n#   Ok(())\n# }\n```"]
    fn get_account(&self, id: &str) -> Result<Account> {
        self.get(self.route(&{
                                 let res =
                                     ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/accounts/"],
                                                                                         &match (&id,)
                                                                                              {
                                                                                              (arg0,)
                                                                                              =>
                                                                                              [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                            ::core::fmt::Display::fmt)],
                                                                                          }));
                                 res
                             }))
    }
    #[doc =
      "Equivalent to `post /api/v1/accounts/{}/follow`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.follow(\"42\");\n#   Ok(())\n# }\n```"]
    fn follow(&self, id: &str) -> Result<Relationship> {
        self.post(self.route(&{
                                  let res =
                                      ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/accounts/",
                                                                                            "/follow"],
                                                                                          &match (&id,)
                                                                                               {
                                                                                               (arg0,)
                                                                                               =>
                                                                                               [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                             ::core::fmt::Display::fmt)],
                                                                                           }));
                                  res
                              }))
    }
    #[doc =
      "Equivalent to `post /api/v1/accounts/{}/unfollow`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.unfollow(\"42\");\n#   Ok(())\n# }\n```"]
    fn unfollow(&self, id: &str) -> Result<Relationship> {
        self.post(self.route(&{
                                  let res =
                                      ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/accounts/",
                                                                                            "/unfollow"],
                                                                                          &match (&id,)
                                                                                               {
                                                                                               (arg0,)
                                                                                               =>
                                                                                               [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                             ::core::fmt::Display::fmt)],
                                                                                           }));
                                  res
                              }))
    }
    #[doc =
      "Equivalent to `post /api/v1/accounts/{}/block`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.block(\"42\");\n#   Ok(())\n# }\n```"]
    fn block(&self, id: &str) -> Result<Relationship> {
        self.post(self.route(&{
                                  let res =
                                      ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/accounts/",
                                                                                            "/block"],
                                                                                          &match (&id,)
                                                                                               {
                                                                                               (arg0,)
                                                                                               =>
                                                                                               [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                             ::core::fmt::Display::fmt)],
                                                                                           }));
                                  res
                              }))
    }
    #[doc =
      "Equivalent to `post /api/v1/accounts/{}/unblock`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.unblock(\"42\");\n#   Ok(())\n# }\n```"]
    fn unblock(&self, id: &str) -> Result<Relationship> {
        self.post(self.route(&{
                                  let res =
                                      ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/accounts/",
                                                                                            "/unblock"],
                                                                                          &match (&id,)
                                                                                               {
                                                                                               (arg0,)
                                                                                               =>
                                                                                               [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                             ::core::fmt::Display::fmt)],
                                                                                           }));
                                  res
                              }))
    }
    #[doc =
      "Equivalent to `get /api/v1/accounts/{}/mute`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.mute(\"42\");\n#   Ok(())\n# }\n```"]
    fn mute(&self, id: &str) -> Result<Relationship> {
        self.get(self.route(&{
                                 let res =
                                     ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/accounts/",
                                                                                           "/mute"],
                                                                                         &match (&id,)
                                                                                              {
                                                                                              (arg0,)
                                                                                              =>
                                                                                              [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                            ::core::fmt::Display::fmt)],
                                                                                          }));
                                 res
                             }))
    }
    #[doc =
      "Equivalent to `get /api/v1/accounts/{}/unmute`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.unmute(\"42\");\n#   Ok(())\n# }\n```"]
    fn unmute(&self, id: &str) -> Result<Relationship> {
        self.get(self.route(&{
                                 let res =
                                     ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/accounts/",
                                                                                           "/unmute"],
                                                                                         &match (&id,)
                                                                                              {
                                                                                              (arg0,)
                                                                                              =>
                                                                                              [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                            ::core::fmt::Display::fmt)],
                                                                                          }));
                                 res
                             }))
    }
    #[doc =
      "Equivalent to `get /api/v1/notifications/{}`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.get_notification(\"42\");\n#   Ok(())\n# }\n```"]
    fn get_notification(&self, id: &str) -> Result<Notification> {
        self.get(self.route(&{
                                 let res =
                                     ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/notifications/"],
                                                                                         &match (&id,)
                                                                                              {
                                                                                              (arg0,)
                                                                                              =>
                                                                                              [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                            ::core::fmt::Display::fmt)],
                                                                                          }));
                                 res
                             }))
    }
    #[doc =
      "Equivalent to `get /api/v1/statuses/{}`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.get_status(\"42\");\n#   Ok(())\n# }\n```"]
    fn get_status(&self, id: &str) -> Result<Status> {
        self.get(self.route(&{
                                 let res =
                                     ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/statuses/"],
                                                                                         &match (&id,)
                                                                                              {
                                                                                              (arg0,)
                                                                                              =>
                                                                                              [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                            ::core::fmt::Display::fmt)],
                                                                                          }));
                                 res
                             }))
    }
    #[doc =
      "Equivalent to `get /api/v1/statuses/{}/context`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.get_context(\"42\");\n#   Ok(())\n# }\n```"]
    fn get_context(&self, id: &str) -> Result<Context> {
        self.get(self.route(&{
                                 let res =
                                     ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/statuses/",
                                                                                           "/context"],
                                                                                         &match (&id,)
                                                                                              {
                                                                                              (arg0,)
                                                                                              =>
                                                                                              [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                            ::core::fmt::Display::fmt)],
                                                                                          }));
                                 res
                             }))
    }
    #[doc =
      "Equivalent to `get /api/v1/statuses/{}/card`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.get_card(\"42\");\n#   Ok(())\n# }\n```"]
    fn get_card(&self, id: &str) -> Result<Card> {
        self.get(self.route(&{
                                 let res =
                                     ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/statuses/",
                                                                                           "/card"],
                                                                                         &match (&id,)
                                                                                              {
                                                                                              (arg0,)
                                                                                              =>
                                                                                              [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                            ::core::fmt::Display::fmt)],
                                                                                          }));
                                 res
                             }))
    }
    #[doc =
      "Equivalent to `post /api/v1/statuses/{}/reblog`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.reblog(\"42\");\n#   Ok(())\n# }\n```"]
    fn reblog(&self, id: &str) -> Result<Status> {
        self.post(self.route(&{
                                  let res =
                                      ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/statuses/",
                                                                                            "/reblog"],
                                                                                          &match (&id,)
                                                                                               {
                                                                                               (arg0,)
                                                                                               =>
                                                                                               [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                             ::core::fmt::Display::fmt)],
                                                                                           }));
                                  res
                              }))
    }
    #[doc =
      "Equivalent to `post /api/v1/statuses/{}/unreblog`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.unreblog(\"42\");\n#   Ok(())\n# }\n```"]
    fn unreblog(&self, id: &str) -> Result<Status> {
        self.post(self.route(&{
                                  let res =
                                      ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/statuses/",
                                                                                            "/unreblog"],
                                                                                          &match (&id,)
                                                                                               {
                                                                                               (arg0,)
                                                                                               =>
                                                                                               [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                             ::core::fmt::Display::fmt)],
                                                                                           }));
                                  res
                              }))
    }
    #[doc =
      "Equivalent to `post /api/v1/statuses/{}/favourite`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.favourite(\"42\");\n#   Ok(())\n# }\n```"]
    fn favourite(&self, id: &str) -> Result<Status> {
        self.post(self.route(&{
                                  let res =
                                      ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/statuses/",
                                                                                            "/favourite"],
                                                                                          &match (&id,)
                                                                                               {
                                                                                               (arg0,)
                                                                                               =>
                                                                                               [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                             ::core::fmt::Display::fmt)],
                                                                                           }));
                                  res
                              }))
    }
    #[doc =
      "Equivalent to `post /api/v1/statuses/{}/unfavourite`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.unfavourite(\"42\");\n#   Ok(())\n# }\n```"]
    fn unfavourite(&self, id: &str) -> Result<Status> {
        self.post(self.route(&{
                                  let res =
                                      ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/statuses/",
                                                                                            "/unfavourite"],
                                                                                          &match (&id,)
                                                                                               {
                                                                                               (arg0,)
                                                                                               =>
                                                                                               [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                             ::core::fmt::Display::fmt)],
                                                                                           }));
                                  res
                              }))
    }
    #[doc =
      "Equivalent to `delete /api/v1/statuses/{}`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.delete_status(\"42\");\n#   Ok(())\n# }\n```"]
    fn delete_status(&self, id: &str) -> Result<Empty> {
        self.delete(self.route(&{
                                    let res =
                                        ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/statuses/"],
                                                                                            &match (&id,)
                                                                                                 {
                                                                                                 (arg0,)
                                                                                                 =>
                                                                                                 [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                               ::core::fmt::Display::fmt)],
                                                                                             }));
                                    res
                                }))
    }
    #[doc =
      "Equivalent to `get /api/v1/filters/{}`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.get_filter(\"42\");\n#   Ok(())\n# }\n```"]
    fn get_filter(&self, id: &str) -> Result<Filter> {
        self.get(self.route(&{
                                 let res =
                                     ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/filters/"],
                                                                                         &match (&id,)
                                                                                              {
                                                                                              (arg0,)
                                                                                              =>
                                                                                              [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                            ::core::fmt::Display::fmt)],
                                                                                          }));
                                 res
                             }))
    }
    #[doc =
      "Equivalent to `delete /api/v1/filters/{}`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.delete_filter(\"42\");\n#   Ok(())\n# }\n```"]
    fn delete_filter(&self, id: &str) -> Result<Empty> {
        self.delete(self.route(&{
                                    let res =
                                        ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/filters/"],
                                                                                            &match (&id,)
                                                                                                 {
                                                                                                 (arg0,)
                                                                                                 =>
                                                                                                 [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                               ::core::fmt::Display::fmt)],
                                                                                             }));
                                    res
                                }))
    }
    #[doc =
      "Equivalent to `delete /api/v1/suggestions/{}`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.delete_from_suggestions(\"42\");\n#   Ok(())\n# }\n```"]
    fn delete_from_suggestions(&self, id: &str) -> Result<Empty> {
        self.delete(self.route(&{
                                    let res =
                                        ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/suggestions/"],
                                                                                            &match (&id,)
                                                                                                 {
                                                                                                 (arg0,)
                                                                                                 =>
                                                                                                 [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                               ::core::fmt::Display::fmt)],
                                                                                             }));
                                    res
                                }))
    }
    #[doc =
      "Equivalent to `post /api/v1/accounts/{}/pin`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.endorse_user(\"42\");\n#   Ok(())\n# }\n```"]
    fn endorse_user(&self, id: &str) -> Result<Relationship> {
        self.post(self.route(&{
                                  let res =
                                      ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/accounts/",
                                                                                            "/pin"],
                                                                                          &match (&id,)
                                                                                               {
                                                                                               (arg0,)
                                                                                               =>
                                                                                               [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                             ::core::fmt::Display::fmt)],
                                                                                           }));
                                  res
                              }))
    }
    #[doc =
      "Equivalent to `post /api/v1/accounts/{}/unpin`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n#     base: \"https://example.com\".into(),\n#     client_id: \"taosuah\".into(),\n#     client_secret: \"htnjdiuae\".into(),\n#     redirect: \"https://example.com\".into(),\n#     token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.unendorse_user(\"42\");\n#   Ok(())\n# }\n```"]
    fn unendorse_user(&self, id: &str) -> Result<Relationship> {
        self.post(self.route(&{
                                  let res =
                                      ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/accounts/",
                                                                                            "/unpin"],
                                                                                          &match (&id,)
                                                                                               {
                                                                                               (arg0,)
                                                                                               =>
                                                                                               [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                             ::core::fmt::Display::fmt)],
                                                                                           }));
                                  res
                              }))
    }
    fn add_filter(&self, request: &mut AddFilterRequest) -> Result<Filter> {
        let url = self.route("/api/v1/filters");
        let response = self.send(self.client.post(&url).json(&request))?;
        let status = response.status();
        if status.is_client_error() {
            return Err(Error::Client(status.clone()));
        } else if status.is_server_error() {
            return Err(Error::Server(status.clone()));
        }
        deserialise(response)
    }
    #[doc = " PUT /api/v1/filters/:id"]
    fn update_filter(&self, id: &str, request: &mut AddFilterRequest)
     -> Result<Filter> {
        let url =
            self.route(&{
                            let res =
                                ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/filters/"],
                                                                                    &match (&id,)
                                                                                         {
                                                                                         (arg0,)
                                                                                         =>
                                                                                         [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                       ::core::fmt::Display::fmt)],
                                                                                     }));
                            res
                        });
        let response = self.send(self.client.put(&url).json(&request))?;
        let status = response.status();
        if status.is_client_error() {
            return Err(Error::Client(status.clone()));
        } else if status.is_server_error() {
            return Err(Error::Server(status.clone()));
        }
        deserialise(response)
    }
    fn update_credentials(&self, builder: &mut UpdateCredsRequest)
     -> Result<Account> {
        let changes = builder.build()?;
        let url = self.route("/api/v1/accounts/update_credentials");
        let response = self.send(self.client.patch(&url).json(&changes))?;
        let status = response.status();
        if status.is_client_error() {
            return Err(Error::Client(status.clone()));
        } else if status.is_server_error() {
            return Err(Error::Server(status.clone()));
        }
        deserialise(response)
    }
    #[doc = " Post a new status to the account."]
    fn new_status(&self, status: NewStatus) -> Result<Status> {
        let response =
            self.send(self.client.post(&self.route("/api/v1/statuses")).json(&status))?;
        deserialise(response)
    }
    #[doc =
      " Get timeline filtered by a hashtag(eg. `#coffee`) either locally or"]
    #[doc = " federated."]
    fn get_tagged_timeline(&self, hashtag: String, local: bool)
     -> Result<Vec<Status>> {
        let base = "/api/v1/timelines/tag/";
        let url =
            if local {
                self.route(&{
                                let res =
                                    ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["",
                                                                                          "",
                                                                                          "?local=1"],
                                                                                        &match (&base,
                                                                                                &hashtag)
                                                                                             {
                                                                                             (arg0,
                                                                                              arg1)
                                                                                             =>
                                                                                             [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                           ::core::fmt::Display::fmt),
                                                                                              ::core::fmt::ArgumentV1::new(arg1,
                                                                                                                           ::core::fmt::Display::fmt)],
                                                                                         }));
                                res
                            })
            } else {
                self.route(&{
                                let res =
                                    ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["",
                                                                                          ""],
                                                                                        &match (&base,
                                                                                                &hashtag)
                                                                                             {
                                                                                             (arg0,
                                                                                              arg1)
                                                                                             =>
                                                                                             [::core::fmt::ArgumentV1::new(arg0,
                                                                                                                           ::core::fmt::Display::fmt),
                                                                                              ::core::fmt::ArgumentV1::new(arg1,
                                                                                                                           ::core::fmt::Display::fmt)],
                                                                                         }));
                                res
                            })
            };
        self.get(url)
    }
    #[doc =
      " Get statuses of a single account by id. Optionally only with pictures"]
    #[doc = " and or excluding replies."]
    #[doc = ""]
    #[doc = " # Example"]
    #[doc = ""]
    #[doc = " ```no_run"]
    #[doc = " # extern crate elefren;"]
    #[doc = " # use elefren::prelude::*;"]
    #[doc = " # use std::error::Error;"]
    #[doc = " # fn main() -> Result<(), Box<Error>> {"]
    #[doc = " # let data = Data {"]
    #[doc = " #   base: \"\".into(),"]
    #[doc = " #   client_id: \"\".into(),"]
    #[doc = " #   client_secret: \"\".into(),"]
    #[doc = " #   redirect: \"\".into(),"]
    #[doc = " #   token: \"\".into(),"]
    #[doc = " # };"]
    #[doc = " let client = Mastodon::from(data);"]
    #[doc = " let statuses = client.statuses(\"user-id\", None)?;"]
    #[doc = " # Ok(())"]
    #[doc = " # }"]
    #[doc = " ```"]
    #[doc = ""]
    #[doc = " ```no_run"]
    #[doc = " # extern crate elefren;"]
    #[doc = " # use elefren::prelude::*;"]
    #[doc = " # use std::error::Error;"]
    #[doc = " # fn main() -> Result<(), Box<Error>> {"]
    #[doc = " # let data = Data {"]
    #[doc = " #   base: \"\".into(),"]
    #[doc = " #   client_id: \"\".into(),"]
    #[doc = " #   client_secret: \"\".into(),"]
    #[doc = " #   redirect: \"\".into(),"]
    #[doc = " #   token: \"\".into(),"]
    #[doc = " # };"]
    #[doc = " let client = Mastodon::from(data);"]
    #[doc = " let mut request = StatusesRequest::new();"]
    #[doc = " request.only_media();"]
    #[doc = " let statuses = client.statuses(\"user-id\", request)?;"]
    #[doc = " # Ok(())"]
    #[doc = " # }"]
    #[doc = " ```"]
    fn statuses<'a, 'b: 'a, S>(&'b self, id: &'b str, request: S)
     -> Result<Page<Status>> where S: Into<Option<StatusesRequest<'a>>> {
        let mut url =
            {
                let res =
                    ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["",
                                                                          "/api/v1/accounts/",
                                                                          "/statuses"],
                                                                        &match (&self.base,
                                                                                &id)
                                                                             {
                                                                             (arg0,
                                                                              arg1)
                                                                             =>
                                                                             [::core::fmt::ArgumentV1::new(arg0,
                                                                                                           ::core::fmt::Display::fmt),
                                                                              ::core::fmt::ArgumentV1::new(arg1,
                                                                                                           ::core::fmt::Display::fmt)],
                                                                         }));
                res
            };
        if let Some(request) = request.into() {
            url =
                {
                    let res =
                        ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["",
                                                                              ""],
                                                                            &match (&url,
                                                                                    &request.to_querystring()?)
                                                                                 {
                                                                                 (arg0,
                                                                                  arg1)
                                                                                 =>
                                                                                 [::core::fmt::ArgumentV1::new(arg0,
                                                                                                               ::core::fmt::Display::fmt),
                                                                                  ::core::fmt::ArgumentV1::new(arg1,
                                                                                                               ::core::fmt::Display::fmt)],
                                                                             }));
                    res
                };
        }
        let response = self.send(self.client.get(&url))?;
        Page::new(self, response)
    }
    #[doc =
      " Returns the client account\'s relationship to a list of other accounts."]
    #[doc = " Such as whether they follow them or vice versa."]
    fn relationships(&self, ids: &[&str]) -> Result<Page<Relationship>> {
        let mut url = self.route("/api/v1/accounts/relationships?");
        if ids.len() == 1 {
            url += "id=";
            url += &ids[0];
        } else {
            for id in ids { url += "id[]="; url += &id; url += "&"; }
            url.pop();
        }
        let response = self.send(self.client.get(&url))?;
        Page::new(self, response)
    }
    #[doc = " Add a push notifications subscription"]
    fn add_push_subscription(&self, request: &AddPushRequest)
     -> Result<Subscription> {
        let request = request.build()?;
        let response =
            self.send(self.client.post(&self.route("/api/v1/push/subscription")).json(&request))?;
        deserialise(response)
    }
    #[doc =
      " Update the `data` portion of the push subscription associated with this"]
    #[doc = " access token"]
    fn update_push_data(&self, request: &UpdatePushRequest)
     -> Result<Subscription> {
        let request = request.build();
        let response =
            self.send(self.client.put(&self.route("/api/v1/push/subscription")).json(&request))?;
        deserialise(response)
    }
    #[doc = " Get all accounts that follow the authenticated user"]
    fn follows_me(&self) -> Result<Page<Account>> {
        let me = self.verify_credentials()?;
        Ok(self.followers(&me.id)?)
    }
    #[doc = " Get all accounts that the authenticated user follows"]
    fn followed_by_me(&self) -> Result<Page<Account>> {
        let me = self.verify_credentials()?;
        Ok(self.following(&me.id)?)
    }
}
impl ops::Deref for Mastodon {
    type Target = Data;
    fn deref(&self) -> &Self::Target { &self.data }
}
struct MastodonBuilder {
    client: Option<Client>,
    data: Option<Data>,
}
impl MastodonBuilder {
    pub fn new() -> Self { MastodonBuilder{client: None, data: None,} }
    pub fn client(&mut self, client: Client) -> &mut Self {
        self.client = Some(client);
        self
    }
    pub fn data(&mut self, data: Data) -> &mut Self {
        self.data = Some(data);
        self
    }
    pub fn build(self) -> Result<Mastodon> {
        Ok(if let Some(data) = self.data {
               Mastodon{client: self.client.unwrap_or_else(|| Client::new()),
                        data,}
           } else {
               return Err(Error::MissingField("missing field 'data'"));
           })
    }
}
/// Client that can make unauthenticated calls to a mastodon instance
pub struct MastodonUnauth {
    client: Client,
    base: url::Url,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for MastodonUnauth {
    #[inline]
    fn clone(&self) -> MastodonUnauth {
        match *self {
            MastodonUnauth { client: ref __self_0_0, base: ref __self_0_1 } =>
            MastodonUnauth{client:
                               ::core::clone::Clone::clone(&(*__self_0_0)),
                           base:
                               ::core::clone::Clone::clone(&(*__self_0_1)),},
        }
    }
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for MastodonUnauth {
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        match *self {
            MastodonUnauth { client: ref __self_0_0, base: ref __self_0_1 } =>
            {
                let mut debug_trait_builder =
                    f.debug_struct("MastodonUnauth");
                let _ = debug_trait_builder.field("client", &&(*__self_0_0));
                let _ = debug_trait_builder.field("base", &&(*__self_0_1));
                debug_trait_builder.finish()
            }
        }
    }
}
impl MastodonUnauth {
    /// Create a new unauthenticated client
    pub fn new(base: &str) -> Result<MastodonUnauth> {
        let base =
            if base.starts_with("https://") {
                base.to_string()
            } else {
                {
                    let res =
                        ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["https://"],
                                                                            &match (&base,)
                                                                                 {
                                                                                 (arg0,)
                                                                                 =>
                                                                                 [::core::fmt::ArgumentV1::new(arg0,
                                                                                                               ::core::fmt::Display::fmt)],
                                                                             }));
                    res
                }
            };
        Ok(MastodonUnauth{client: Client::new(),
                          base: url::Url::parse(&base)?,})
    }
}
impl MastodonUnauth {
    fn route(&self, url: &str) -> Result<url::Url> {
        Ok(self.base.join(url)?)
    }
    fn send(&self, req: RequestBuilder) -> Result<Response> {
        let req = req.build()?;
        Ok(self.client.execute(req)?)
    }
}
impl MastodonUnauthenticated for MastodonUnauth {
    /// GET /api/v1/statuses/:id
    fn get_status(&self, id: &str) -> Result<Status> {
        let route = self.route("/api/v1/statuses")?;
        let route = route.join(id)?;
        let response = self.send(self.client.get(route))?;
        deserialise(response)
    }
    /// GET /api/v1/statuses/:id/context
    fn get_context(&self, id: &str) -> Result<Context> {
        let route = self.route("/api/v1/statuses")?;
        let route = route.join(id)?;
        let route = route.join("context")?;
        let response = self.send(self.client.get(route))?;
        deserialise(response)
    }
    /// GET /api/v1/statuses/:id/card
    fn get_card(&self, id: &str) -> Result<Card> {
        let route = self.route("/api/v1/statuses")?;
        let route = route.join(id)?;
        let route = route.join("card")?;
        let response = self.send(self.client.get(route))?;
        deserialise(response)
    }
}
fn deserialise<T: for<'de> serde::Deserialize<'de>>(response: Response)
 -> Result<T> {
    let mut reader = Tap::new(response);
    match serde_json::from_reader(&mut reader) {
        Ok(t) => {
            {
                let lvl = ::log::Level::Debug;
                if lvl <= ::log::STATIC_MAX_LEVEL && lvl <= ::log::max_level()
                   {
                    ::log::__private_api_log(::core::fmt::Arguments::new_v1(&[""],
                                                                            &match (&String::from_utf8_lossy(&reader.bytes),)
                                                                                 {
                                                                                 (arg0,)
                                                                                 =>
                                                                                 [::core::fmt::ArgumentV1::new(arg0,
                                                                                                               ::core::fmt::Display::fmt)],
                                                                             }),
                                             lvl,
                                             &("elefren", "elefren",
                                               "src/lib.rs", 845u32));
                }
            };
            Ok(t)
        }
        Err(e) => {
            {
                let lvl = ::log::Level::Error;
                if lvl <= ::log::STATIC_MAX_LEVEL && lvl <= ::log::max_level()
                   {
                    ::log::__private_api_log(::core::fmt::Arguments::new_v1(&[""],
                                                                            &match (&String::from_utf8_lossy(&reader.bytes),)
                                                                                 {
                                                                                 (arg0,)
                                                                                 =>
                                                                                 [::core::fmt::ArgumentV1::new(arg0,
                                                                                                               ::core::fmt::Display::fmt)],
                                                                             }),
                                             lvl,
                                             &("elefren", "elefren",
                                               "src/lib.rs", 851u32));
                }
            };
            if let Ok(error) = serde_json::from_slice(&reader.bytes) {
                return Err(Error::Api(error));
            }
            Err(e.into())
        }
    }
}