atrium_api/

client.rs

// @generated - This file is generated by atrium-codegen. DO NOT EDIT.
//!Structs for ATP client, implements all HTTP APIs of XRPC.
///Client struct for the ATP service.
pub struct AtpServiceClient<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    pub service: Service<T>,
}
impl<T> AtpServiceClient<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    pub fn new(xrpc: T) -> Self {
        Self {
            service: Service::new(std::sync::Arc::new(xrpc)),
        }
    }
}
pub struct Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    pub app: app::Service<T>,
    pub chat: chat::Service<T>,
    pub com: com::Service<T>,
    pub tools: tools::Service<T>,
    pub(crate) _phantom: core::marker::PhantomData<T>,
}
pub mod app {
    pub struct Service<T>
    where
        T: atrium_xrpc::XrpcClient + Send + Sync,
    {
        #[cfg_attr(docsrs, doc(cfg(feature = "namespace-appbsky")))]
        #[cfg(feature = "namespace-appbsky")]
        pub bsky: bsky::Service<T>,
        pub(crate) _phantom: core::marker::PhantomData<T>,
    }
    #[cfg_attr(docsrs, doc(cfg(feature = "namespace-appbsky")))]
    #[cfg(feature = "namespace-appbsky")]
    pub mod bsky {
        pub struct Service<T>
        where
            T: atrium_xrpc::XrpcClient + Send + Sync,
        {
            pub actor: actor::Service<T>,
            pub ageassurance: ageassurance::Service<T>,
            pub bookmark: bookmark::Service<T>,
            pub contact: contact::Service<T>,
            pub draft: draft::Service<T>,
            pub embed: embed::Service<T>,
            pub feed: feed::Service<T>,
            pub graph: graph::Service<T>,
            pub labeler: labeler::Service<T>,
            pub notification: notification::Service<T>,
            pub unspecced: unspecced::Service<T>,
            pub video: video::Service<T>,
            pub(crate) _phantom: core::marker::PhantomData<T>,
        }
        pub mod actor {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod ageassurance {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod bookmark {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod contact {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod draft {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod embed {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod feed {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod graph {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod labeler {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod notification {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod unspecced {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod video {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
    }
}
pub mod chat {
    pub struct Service<T>
    where
        T: atrium_xrpc::XrpcClient + Send + Sync,
    {
        #[cfg_attr(docsrs, doc(cfg(feature = "namespace-chatbsky")))]
        #[cfg(feature = "namespace-chatbsky")]
        pub bsky: bsky::Service<T>,
        pub(crate) _phantom: core::marker::PhantomData<T>,
    }
    #[cfg_attr(docsrs, doc(cfg(feature = "namespace-chatbsky")))]
    #[cfg(feature = "namespace-chatbsky")]
    pub mod bsky {
        pub struct Service<T>
        where
            T: atrium_xrpc::XrpcClient + Send + Sync,
        {
            pub actor: actor::Service<T>,
            pub convo: convo::Service<T>,
            pub group: group::Service<T>,
            pub moderation: moderation::Service<T>,
            pub notification: notification::Service<T>,
            pub(crate) _phantom: core::marker::PhantomData<T>,
        }
        pub mod actor {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod convo {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod group {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod moderation {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod notification {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
    }
}
pub mod com {
    pub struct Service<T>
    where
        T: atrium_xrpc::XrpcClient + Send + Sync,
    {
        pub atproto: atproto::Service<T>,
        pub(crate) _phantom: core::marker::PhantomData<T>,
    }
    pub mod atproto {
        pub struct Service<T>
        where
            T: atrium_xrpc::XrpcClient + Send + Sync,
        {
            pub admin: admin::Service<T>,
            pub identity: identity::Service<T>,
            pub label: label::Service<T>,
            pub lexicon: lexicon::Service<T>,
            pub moderation: moderation::Service<T>,
            pub repo: repo::Service<T>,
            pub server: server::Service<T>,
            pub sync: sync::Service<T>,
            pub temp: temp::Service<T>,
            pub(crate) _phantom: core::marker::PhantomData<T>,
        }
        pub mod admin {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod identity {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod label {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod lexicon {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod moderation {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod repo {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod server {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod sync {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod temp {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
    }
}
pub mod tools {
    pub struct Service<T>
    where
        T: atrium_xrpc::XrpcClient + Send + Sync,
    {
        #[cfg_attr(docsrs, doc(cfg(feature = "namespace-toolsozone")))]
        #[cfg(feature = "namespace-toolsozone")]
        pub ozone: ozone::Service<T>,
        pub(crate) _phantom: core::marker::PhantomData<T>,
    }
    #[cfg_attr(docsrs, doc(cfg(feature = "namespace-toolsozone")))]
    #[cfg(feature = "namespace-toolsozone")]
    pub mod ozone {
        pub struct Service<T>
        where
            T: atrium_xrpc::XrpcClient + Send + Sync,
        {
            pub communication: communication::Service<T>,
            pub hosting: hosting::Service<T>,
            pub moderation: moderation::Service<T>,
            pub queue: queue::Service<T>,
            pub report: report::Service<T>,
            pub safelink: safelink::Service<T>,
            pub server: server::Service<T>,
            pub set: set::Service<T>,
            pub setting: setting::Service<T>,
            pub signature: signature::Service<T>,
            pub team: team::Service<T>,
            pub verification: verification::Service<T>,
            pub(crate) _phantom: core::marker::PhantomData<T>,
        }
        pub mod communication {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod hosting {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod moderation {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod queue {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod report {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod safelink {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod server {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod set {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod setting {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod signature {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod team {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
        pub mod verification {
            pub struct Service<T>
            where
                T: atrium_xrpc::XrpcClient + Send + Sync,
            {
                pub(crate) xrpc: std::sync::Arc<T>,
                pub(crate) _phantom: core::marker::PhantomData<T>,
            }
        }
    }
}
impl<T> self::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            app: app::Service::new(std::sync::Arc::clone(&xrpc)),
            chat: chat::Service::new(std::sync::Arc::clone(&xrpc)),
            com: com::Service::new(std::sync::Arc::clone(&xrpc)),
            tools: tools::Service::new(std::sync::Arc::clone(&xrpc)),
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<T> app::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            #[cfg(feature = "namespace-appbsky")]
            bsky: app::bsky::Service::new(std::sync::Arc::clone(&xrpc)),
            _phantom: core::marker::PhantomData,
        }
    }
}
#[cfg(feature = "namespace-appbsky")]
impl<T> app::bsky::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            actor: app::bsky::actor::Service::new(std::sync::Arc::clone(&xrpc)),
            ageassurance: app::bsky::ageassurance::Service::new(
                std::sync::Arc::clone(&xrpc),
            ),
            bookmark: app::bsky::bookmark::Service::new(std::sync::Arc::clone(&xrpc)),
            contact: app::bsky::contact::Service::new(std::sync::Arc::clone(&xrpc)),
            draft: app::bsky::draft::Service::new(std::sync::Arc::clone(&xrpc)),
            embed: app::bsky::embed::Service::new(std::sync::Arc::clone(&xrpc)),
            feed: app::bsky::feed::Service::new(std::sync::Arc::clone(&xrpc)),
            graph: app::bsky::graph::Service::new(std::sync::Arc::clone(&xrpc)),
            labeler: app::bsky::labeler::Service::new(std::sync::Arc::clone(&xrpc)),
            notification: app::bsky::notification::Service::new(
                std::sync::Arc::clone(&xrpc),
            ),
            unspecced: app::bsky::unspecced::Service::new(std::sync::Arc::clone(&xrpc)),
            video: app::bsky::video::Service::new(std::sync::Arc::clone(&xrpc)),
            _phantom: core::marker::PhantomData,
        }
    }
}
#[cfg(feature = "namespace-appbsky")]
impl<T> app::bsky::actor::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Get private preferences attached to the current account. Expected use is synchronization between multiple devices, and import/export during account migration. Requires auth.
    pub async fn get_preferences(
        &self,
        params: crate::app::bsky::actor::get_preferences::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::actor::get_preferences::Output,
        crate::app::bsky::actor::get_preferences::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::actor::get_preferences::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get detailed profile view of an actor. Does not require auth, but contains relevant metadata with auth.
    pub async fn get_profile(
        &self,
        params: crate::app::bsky::actor::get_profile::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::actor::get_profile::Output,
        crate::app::bsky::actor::get_profile::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::actor::get_profile::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get detailed profile views of multiple actors.
    pub async fn get_profiles(
        &self,
        params: crate::app::bsky::actor::get_profiles::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::actor::get_profiles::Output,
        crate::app::bsky::actor::get_profiles::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::actor::get_profiles::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a list of suggested actors. Expected use is discovery of accounts to follow during new account onboarding.
    pub async fn get_suggestions(
        &self,
        params: crate::app::bsky::actor::get_suggestions::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::actor::get_suggestions::Output,
        crate::app::bsky::actor::get_suggestions::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::actor::get_suggestions::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Set the private preferences attached to the account.
    pub async fn put_preferences(
        &self,
        input: crate::app::bsky::actor::put_preferences::Input,
    ) -> atrium_xrpc::Result<(), crate::app::bsky::actor::put_preferences::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::actor::put_preferences::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Find actors (profiles) matching search criteria. Does not require auth.
    pub async fn search_actors(
        &self,
        params: crate::app::bsky::actor::search_actors::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::actor::search_actors::Output,
        crate::app::bsky::actor::search_actors::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::actor::search_actors::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Find actor suggestions for a prefix search term. Expected use is for auto-completion during text field entry. Does not require auth.
    pub async fn search_actors_typeahead(
        &self,
        params: crate::app::bsky::actor::search_actors_typeahead::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::actor::search_actors_typeahead::Output,
        crate::app::bsky::actor::search_actors_typeahead::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::actor::search_actors_typeahead::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
#[cfg(feature = "namespace-appbsky")]
impl<T> app::bsky::ageassurance::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Initiate Age Assurance for an account.
    pub async fn begin(
        &self,
        input: crate::app::bsky::ageassurance::begin::Input,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::ageassurance::begin::Output,
        crate::app::bsky::ageassurance::begin::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::ageassurance::begin::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Returns Age Assurance configuration for use on the client.
    pub async fn get_config(
        &self,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::ageassurance::get_config::Output,
        crate::app::bsky::ageassurance::get_config::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::ageassurance::get_config::NSID.into(),
                    parameters: None,
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Returns server-computed Age Assurance state, if available, and any additional metadata needed to compute Age Assurance state client-side.
    pub async fn get_state(
        &self,
        params: crate::app::bsky::ageassurance::get_state::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::ageassurance::get_state::Output,
        crate::app::bsky::ageassurance::get_state::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::ageassurance::get_state::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
#[cfg(feature = "namespace-appbsky")]
impl<T> app::bsky::bookmark::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Creates a private bookmark for the specified record. Currently, only `app.bsky.feed.post` records are supported. Requires authentication.
    pub async fn create_bookmark(
        &self,
        input: crate::app::bsky::bookmark::create_bookmark::Input,
    ) -> atrium_xrpc::Result<(), crate::app::bsky::bookmark::create_bookmark::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::bookmark::create_bookmark::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Deletes a private bookmark for the specified record. Currently, only `app.bsky.feed.post` records are supported. Requires authentication.
    pub async fn delete_bookmark(
        &self,
        input: crate::app::bsky::bookmark::delete_bookmark::Input,
    ) -> atrium_xrpc::Result<(), crate::app::bsky::bookmark::delete_bookmark::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::bookmark::delete_bookmark::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Gets views of records bookmarked by the authenticated user. Requires authentication.
    pub async fn get_bookmarks(
        &self,
        params: crate::app::bsky::bookmark::get_bookmarks::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::bookmark::get_bookmarks::Output,
        crate::app::bsky::bookmark::get_bookmarks::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::bookmark::get_bookmarks::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
#[cfg(feature = "namespace-appbsky")]
impl<T> app::bsky::contact::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Removes a match that was found via contact import. It shouldn't appear again if the same contact is re-imported. Requires authentication.
    pub async fn dismiss_match(
        &self,
        input: crate::app::bsky::contact::dismiss_match::Input,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::contact::dismiss_match::Output,
        crate::app::bsky::contact::dismiss_match::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::contact::dismiss_match::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Returns the matched contacts (contacts that were mutually imported). Excludes dismissed matches. Requires authentication.
    pub async fn get_matches(
        &self,
        params: crate::app::bsky::contact::get_matches::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::contact::get_matches::Output,
        crate::app::bsky::contact::get_matches::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::contact::get_matches::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Gets the user's current contact import status. Requires authentication.
    pub async fn get_sync_status(
        &self,
        params: crate::app::bsky::contact::get_sync_status::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::contact::get_sync_status::Output,
        crate::app::bsky::contact::get_sync_status::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::contact::get_sync_status::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Import contacts for securely matching with other users. This follows the protocol explained in https://docs.bsky.app/blog/contact-import-rfc. Requires authentication.
    pub async fn import_contacts(
        &self,
        input: crate::app::bsky::contact::import_contacts::Input,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::contact::import_contacts::Output,
        crate::app::bsky::contact::import_contacts::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::contact::import_contacts::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Removes all stored hashes used for contact matching, existing matches, and sync status. Requires authentication.
    pub async fn remove_data(
        &self,
        input: crate::app::bsky::contact::remove_data::Input,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::contact::remove_data::Output,
        crate::app::bsky::contact::remove_data::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::contact::remove_data::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///System endpoint to send notifications related to contact imports. Requires role authentication.
    pub async fn send_notification(
        &self,
        input: crate::app::bsky::contact::send_notification::Input,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::contact::send_notification::Output,
        crate::app::bsky::contact::send_notification::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::contact::send_notification::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Starts a phone verification flow. The phone passed will receive a code via SMS that should be passed to `app.bsky.contact.verifyPhone`. Requires authentication.
    pub async fn start_phone_verification(
        &self,
        input: crate::app::bsky::contact::start_phone_verification::Input,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::contact::start_phone_verification::Output,
        crate::app::bsky::contact::start_phone_verification::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::contact::start_phone_verification::NSID
                        .into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Verifies control over a phone number with a code received via SMS and starts a contact import session. Requires authentication.
    pub async fn verify_phone(
        &self,
        input: crate::app::bsky::contact::verify_phone::Input,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::contact::verify_phone::Output,
        crate::app::bsky::contact::verify_phone::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::contact::verify_phone::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
#[cfg(feature = "namespace-appbsky")]
impl<T> app::bsky::draft::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Inserts a draft using private storage (stash). An upper limit of drafts might be enforced. Requires authentication.
    pub async fn create_draft(
        &self,
        input: crate::app::bsky::draft::create_draft::Input,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::draft::create_draft::Output,
        crate::app::bsky::draft::create_draft::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::draft::create_draft::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Deletes a draft by ID. Requires authentication.
    pub async fn delete_draft(
        &self,
        input: crate::app::bsky::draft::delete_draft::Input,
    ) -> atrium_xrpc::Result<(), crate::app::bsky::draft::delete_draft::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::draft::delete_draft::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Gets views of user drafts. Requires authentication.
    pub async fn get_drafts(
        &self,
        params: crate::app::bsky::draft::get_drafts::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::draft::get_drafts::Output,
        crate::app::bsky::draft::get_drafts::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::draft::get_drafts::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Updates a draft using private storage (stash). If the draft ID points to a non-existing ID, the update will be silently ignored. This is done because updates don't enforce draft limit, so it accepts all writes, but will ignore invalid ones. Requires authentication.
    pub async fn update_draft(
        &self,
        input: crate::app::bsky::draft::update_draft::Input,
    ) -> atrium_xrpc::Result<(), crate::app::bsky::draft::update_draft::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::draft::update_draft::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
#[cfg(feature = "namespace-appbsky")]
impl<T> app::bsky::embed::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Resolve one or more AT-URIs into the data needed to render an enhanced external embed. Returns `associatedRefs` (strongRefs to embed into a post's external.associatedRefs), the raw `associatedRecords`, and a hydrated `view`. The response is empty (`{}`) when no records were resolvable, or when validation determined the resolved records don't actually back the requested URL; clients should fall back to their own link-card rendering in that case and skip writing strongRefs to the post.
    pub async fn get_embed_external_view(
        &self,
        params: crate::app::bsky::embed::get_embed_external_view::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::embed::get_embed_external_view::Output,
        crate::app::bsky::embed::get_embed_external_view::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::embed::get_embed_external_view::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
#[cfg(feature = "namespace-appbsky")]
impl<T> app::bsky::feed::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Get information about a feed generator, including policies and offered feed URIs. Does not require auth; implemented by Feed Generator services (not App View).
    pub async fn describe_feed_generator(
        &self,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::feed::describe_feed_generator::Output,
        crate::app::bsky::feed::describe_feed_generator::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::feed::describe_feed_generator::NSID.into(),
                    parameters: None,
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a list of feeds (feed generator records) created by the actor (in the actor's repo).
    pub async fn get_actor_feeds(
        &self,
        params: crate::app::bsky::feed::get_actor_feeds::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::feed::get_actor_feeds::Output,
        crate::app::bsky::feed::get_actor_feeds::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::feed::get_actor_feeds::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a list of posts liked by an actor. Requires auth, actor must be the requesting account.
    pub async fn get_actor_likes(
        &self,
        params: crate::app::bsky::feed::get_actor_likes::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::feed::get_actor_likes::Output,
        crate::app::bsky::feed::get_actor_likes::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::feed::get_actor_likes::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a view of an actor's 'author feed' (post and reposts by the author). Does not require auth.
    pub async fn get_author_feed(
        &self,
        params: crate::app::bsky::feed::get_author_feed::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::feed::get_author_feed::Output,
        crate::app::bsky::feed::get_author_feed::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::feed::get_author_feed::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a hydrated feed from an actor's selected feed generator. Implemented by App View.
    pub async fn get_feed(
        &self,
        params: crate::app::bsky::feed::get_feed::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::feed::get_feed::Output,
        crate::app::bsky::feed::get_feed::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::feed::get_feed::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get information about a feed generator. Implemented by AppView.
    pub async fn get_feed_generator(
        &self,
        params: crate::app::bsky::feed::get_feed_generator::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::feed::get_feed_generator::Output,
        crate::app::bsky::feed::get_feed_generator::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::feed::get_feed_generator::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get information about a list of feed generators.
    pub async fn get_feed_generators(
        &self,
        params: crate::app::bsky::feed::get_feed_generators::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::feed::get_feed_generators::Output,
        crate::app::bsky::feed::get_feed_generators::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::feed::get_feed_generators::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a skeleton of a feed provided by a feed generator. Auth is optional, depending on provider requirements, and provides the DID of the requester. Implemented by Feed Generator Service.
    pub async fn get_feed_skeleton(
        &self,
        params: crate::app::bsky::feed::get_feed_skeleton::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::feed::get_feed_skeleton::Output,
        crate::app::bsky::feed::get_feed_skeleton::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::feed::get_feed_skeleton::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get like records which reference a subject (by AT-URI and CID).
    pub async fn get_likes(
        &self,
        params: crate::app::bsky::feed::get_likes::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::feed::get_likes::Output,
        crate::app::bsky::feed::get_likes::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::feed::get_likes::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a feed of recent posts from a list (posts and reposts from any actors on the list). Does not require auth.
    pub async fn get_list_feed(
        &self,
        params: crate::app::bsky::feed::get_list_feed::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::feed::get_list_feed::Output,
        crate::app::bsky::feed::get_list_feed::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::feed::get_list_feed::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get posts in a thread. Does not require auth, but additional metadata and filtering will be applied for authed requests.
    pub async fn get_post_thread(
        &self,
        params: crate::app::bsky::feed::get_post_thread::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::feed::get_post_thread::Output,
        crate::app::bsky::feed::get_post_thread::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::feed::get_post_thread::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Gets post views for a specified list of posts (by AT-URI). This is sometimes referred to as 'hydrating' a 'feed skeleton'.
    pub async fn get_posts(
        &self,
        params: crate::app::bsky::feed::get_posts::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::feed::get_posts::Output,
        crate::app::bsky::feed::get_posts::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::feed::get_posts::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a list of quotes for a given post.
    pub async fn get_quotes(
        &self,
        params: crate::app::bsky::feed::get_quotes::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::feed::get_quotes::Output,
        crate::app::bsky::feed::get_quotes::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::feed::get_quotes::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a list of reposts for a given post.
    pub async fn get_reposted_by(
        &self,
        params: crate::app::bsky::feed::get_reposted_by::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::feed::get_reposted_by::Output,
        crate::app::bsky::feed::get_reposted_by::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::feed::get_reposted_by::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a list of suggested feeds (feed generators) for the requesting account.
    pub async fn get_suggested_feeds(
        &self,
        params: crate::app::bsky::feed::get_suggested_feeds::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::feed::get_suggested_feeds::Output,
        crate::app::bsky::feed::get_suggested_feeds::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::feed::get_suggested_feeds::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a view of the requesting account's home timeline. This is expected to be some form of reverse-chronological feed.
    pub async fn get_timeline(
        &self,
        params: crate::app::bsky::feed::get_timeline::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::feed::get_timeline::Output,
        crate::app::bsky::feed::get_timeline::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::feed::get_timeline::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Find posts matching search criteria, returning views of those posts. Note that this API endpoint may require authentication (eg, not public) for some service providers and implementations.
    pub async fn search_posts(
        &self,
        params: crate::app::bsky::feed::search_posts::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::feed::search_posts::Output,
        crate::app::bsky::feed::search_posts::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::feed::search_posts::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Find posts matching a search query or filters, returning search hits for matching post records.
    pub async fn search_posts_v2(
        &self,
        params: crate::app::bsky::feed::search_posts_v2::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::feed::search_posts_v2::Output,
        crate::app::bsky::feed::search_posts_v2::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::feed::search_posts_v2::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Send information about interactions with feed items back to the feed generator that served them.
    pub async fn send_interactions(
        &self,
        input: crate::app::bsky::feed::send_interactions::Input,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::feed::send_interactions::Output,
        crate::app::bsky::feed::send_interactions::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::feed::send_interactions::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
#[cfg(feature = "namespace-appbsky")]
impl<T> app::bsky::graph::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Get a list of starter packs created by the actor.
    pub async fn get_actor_starter_packs(
        &self,
        params: crate::app::bsky::graph::get_actor_starter_packs::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::graph::get_actor_starter_packs::Output,
        crate::app::bsky::graph::get_actor_starter_packs::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::graph::get_actor_starter_packs::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Enumerates which accounts the requesting account is currently blocking. Requires auth.
    pub async fn get_blocks(
        &self,
        params: crate::app::bsky::graph::get_blocks::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::graph::get_blocks::Output,
        crate::app::bsky::graph::get_blocks::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::graph::get_blocks::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Enumerates accounts which follow a specified account (actor).
    pub async fn get_followers(
        &self,
        params: crate::app::bsky::graph::get_followers::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::graph::get_followers::Output,
        crate::app::bsky::graph::get_followers::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::graph::get_followers::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Enumerates accounts which a specified account (actor) follows.
    pub async fn get_follows(
        &self,
        params: crate::app::bsky::graph::get_follows::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::graph::get_follows::Output,
        crate::app::bsky::graph::get_follows::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::graph::get_follows::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Enumerates accounts which follow a specified account (actor) and are followed by the viewer.
    pub async fn get_known_followers(
        &self,
        params: crate::app::bsky::graph::get_known_followers::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::graph::get_known_followers::Output,
        crate::app::bsky::graph::get_known_followers::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::graph::get_known_followers::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Gets a 'view' (with additional context) of a specified list.
    pub async fn get_list(
        &self,
        params: crate::app::bsky::graph::get_list::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::graph::get_list::Output,
        crate::app::bsky::graph::get_list::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::graph::get_list::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get mod lists that the requesting account (actor) is blocking. Requires auth.
    pub async fn get_list_blocks(
        &self,
        params: crate::app::bsky::graph::get_list_blocks::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::graph::get_list_blocks::Output,
        crate::app::bsky::graph::get_list_blocks::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::graph::get_list_blocks::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Enumerates mod lists that the requesting account (actor) currently has muted. Requires auth.
    pub async fn get_list_mutes(
        &self,
        params: crate::app::bsky::graph::get_list_mutes::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::graph::get_list_mutes::Output,
        crate::app::bsky::graph::get_list_mutes::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::graph::get_list_mutes::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Enumerates the lists created by a specified account (actor).
    pub async fn get_lists(
        &self,
        params: crate::app::bsky::graph::get_lists::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::graph::get_lists::Output,
        crate::app::bsky::graph::get_lists::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::graph::get_lists::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Enumerates the lists created by the session user, and includes membership information about `actor` in those lists. Only supports curation and moderation lists (no reference lists, used in starter packs). Requires auth.
    pub async fn get_lists_with_membership(
        &self,
        params: crate::app::bsky::graph::get_lists_with_membership::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::graph::get_lists_with_membership::Output,
        crate::app::bsky::graph::get_lists_with_membership::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::graph::get_lists_with_membership::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Enumerates accounts that the requesting account (actor) currently has fully muted. Mutes scoped to specific kinds of content (only reposts, only quote posts) are not included. Responses may contain more items than the requested limit. Requires auth.
    pub async fn get_mutes(
        &self,
        params: crate::app::bsky::graph::get_mutes::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::graph::get_mutes::Output,
        crate::app::bsky::graph::get_mutes::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::graph::get_mutes::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Enumerates public relationships between one account, and a list of other accounts. Does not require auth.
    pub async fn get_relationships(
        &self,
        params: crate::app::bsky::graph::get_relationships::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::graph::get_relationships::Output,
        crate::app::bsky::graph::get_relationships::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::graph::get_relationships::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Gets a view of a starter pack.
    pub async fn get_starter_pack(
        &self,
        params: crate::app::bsky::graph::get_starter_pack::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::graph::get_starter_pack::Output,
        crate::app::bsky::graph::get_starter_pack::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::graph::get_starter_pack::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get views for a list of starter packs.
    pub async fn get_starter_packs(
        &self,
        params: crate::app::bsky::graph::get_starter_packs::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::graph::get_starter_packs::Output,
        crate::app::bsky::graph::get_starter_packs::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::graph::get_starter_packs::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Enumerates the starter packs created by the session user, and includes membership information about `actor` in those starter packs. Requires auth.
    pub async fn get_starter_packs_with_membership(
        &self,
        params: crate::app::bsky::graph::get_starter_packs_with_membership::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::graph::get_starter_packs_with_membership::Output,
        crate::app::bsky::graph::get_starter_packs_with_membership::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::graph::get_starter_packs_with_membership::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Enumerates follows similar to a given account (actor). Expected use is to recommend additional accounts immediately after following one account.
    pub async fn get_suggested_follows_by_actor(
        &self,
        params: crate::app::bsky::graph::get_suggested_follows_by_actor::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::graph::get_suggested_follows_by_actor::Output,
        crate::app::bsky::graph::get_suggested_follows_by_actor::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::graph::get_suggested_follows_by_actor::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Creates a mute relationship for the specified account. If a mute already exists for the account, it is updated in place: the stored scope is replaced with the scope in this request. Mutes are private in Bluesky. Requires auth.
    pub async fn mute_actor(
        &self,
        input: crate::app::bsky::graph::mute_actor::Input,
    ) -> atrium_xrpc::Result<(), crate::app::bsky::graph::mute_actor::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::graph::mute_actor::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Creates a mute relationship for the specified list of accounts. Mutes are private in Bluesky. Requires auth.
    pub async fn mute_actor_list(
        &self,
        input: crate::app::bsky::graph::mute_actor_list::Input,
    ) -> atrium_xrpc::Result<(), crate::app::bsky::graph::mute_actor_list::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::graph::mute_actor_list::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Mutes a thread preventing notifications from the thread and any of its children. Mutes are private in Bluesky. Requires auth.
    pub async fn mute_thread(
        &self,
        input: crate::app::bsky::graph::mute_thread::Input,
    ) -> atrium_xrpc::Result<(), crate::app::bsky::graph::mute_thread::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::graph::mute_thread::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Find starter packs matching search criteria. Does not require auth.
    pub async fn search_starter_packs(
        &self,
        params: crate::app::bsky::graph::search_starter_packs::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::graph::search_starter_packs::Output,
        crate::app::bsky::graph::search_starter_packs::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::graph::search_starter_packs::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Find starter packs matching search criteria. Does not require auth.
    pub async fn search_starter_packs_v2(
        &self,
        params: crate::app::bsky::graph::search_starter_packs_v2::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::graph::search_starter_packs_v2::Output,
        crate::app::bsky::graph::search_starter_packs_v2::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::graph::search_starter_packs_v2::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Unmutes the specified account. Requires auth.
    pub async fn unmute_actor(
        &self,
        input: crate::app::bsky::graph::unmute_actor::Input,
    ) -> atrium_xrpc::Result<(), crate::app::bsky::graph::unmute_actor::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::graph::unmute_actor::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Unmutes the specified list of accounts. Requires auth.
    pub async fn unmute_actor_list(
        &self,
        input: crate::app::bsky::graph::unmute_actor_list::Input,
    ) -> atrium_xrpc::Result<(), crate::app::bsky::graph::unmute_actor_list::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::graph::unmute_actor_list::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Unmutes the specified thread. Requires auth.
    pub async fn unmute_thread(
        &self,
        input: crate::app::bsky::graph::unmute_thread::Input,
    ) -> atrium_xrpc::Result<(), crate::app::bsky::graph::unmute_thread::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::graph::unmute_thread::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
#[cfg(feature = "namespace-appbsky")]
impl<T> app::bsky::labeler::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Get information about a list of labeler services.
    pub async fn get_services(
        &self,
        params: crate::app::bsky::labeler::get_services::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::labeler::get_services::Output,
        crate::app::bsky::labeler::get_services::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::labeler::get_services::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
#[cfg(feature = "namespace-appbsky")]
impl<T> app::bsky::notification::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Get notification-related preferences for an account. Requires auth.
    pub async fn get_preferences(
        &self,
        params: crate::app::bsky::notification::get_preferences::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::notification::get_preferences::Output,
        crate::app::bsky::notification::get_preferences::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::notification::get_preferences::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Count the number of unread notifications for the requesting account. Requires auth.
    pub async fn get_unread_count(
        &self,
        params: crate::app::bsky::notification::get_unread_count::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::notification::get_unread_count::Output,
        crate::app::bsky::notification::get_unread_count::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::notification::get_unread_count::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Enumerate all accounts to which the requesting account is subscribed to receive notifications for. Requires auth.
    pub async fn list_activity_subscriptions(
        &self,
        params: crate::app::bsky::notification::list_activity_subscriptions::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::notification::list_activity_subscriptions::Output,
        crate::app::bsky::notification::list_activity_subscriptions::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::notification::list_activity_subscriptions::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Enumerate notifications for the requesting account. Requires auth.
    pub async fn list_notifications(
        &self,
        params: crate::app::bsky::notification::list_notifications::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::notification::list_notifications::Output,
        crate::app::bsky::notification::list_notifications::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::notification::list_notifications::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Puts an activity subscription entry. The key should be omitted for creation and provided for updates. Requires auth.
    pub async fn put_activity_subscription(
        &self,
        input: crate::app::bsky::notification::put_activity_subscription::Input,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::notification::put_activity_subscription::Output,
        crate::app::bsky::notification::put_activity_subscription::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::notification::put_activity_subscription::NSID
                        .into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Set notification-related preferences for an account. Requires auth.
    pub async fn put_preferences(
        &self,
        input: crate::app::bsky::notification::put_preferences::Input,
    ) -> atrium_xrpc::Result<
        (),
        crate::app::bsky::notification::put_preferences::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::notification::put_preferences::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Set notification-related preferences for an account. Requires auth.
    pub async fn put_preferences_v2(
        &self,
        input: crate::app::bsky::notification::put_preferences_v2::Input,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::notification::put_preferences_v2::Output,
        crate::app::bsky::notification::put_preferences_v2::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::notification::put_preferences_v2::NSID
                        .into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Register to receive push notifications, via a specified service, for the requesting account. Requires auth.
    pub async fn register_push(
        &self,
        input: crate::app::bsky::notification::register_push::Input,
    ) -> atrium_xrpc::Result<(), crate::app::bsky::notification::register_push::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::notification::register_push::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///The inverse of registerPush - inform a specified service that push notifications should no longer be sent to the given token for the requesting account. Requires auth.
    pub async fn unregister_push(
        &self,
        input: crate::app::bsky::notification::unregister_push::Input,
    ) -> atrium_xrpc::Result<
        (),
        crate::app::bsky::notification::unregister_push::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::notification::unregister_push::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Notify server that the requesting account has seen notifications. Requires auth.
    pub async fn update_seen(
        &self,
        input: crate::app::bsky::notification::update_seen::Input,
    ) -> atrium_xrpc::Result<(), crate::app::bsky::notification::update_seen::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::notification::update_seen::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
#[cfg(feature = "namespace-appbsky")]
impl<T> app::bsky::unspecced::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Returns the current state of the age assurance process for an account. This is used to check if the user has completed age assurance or if further action is required.
    pub async fn get_age_assurance_state(
        &self,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::get_age_assurance_state::Output,
        crate::app::bsky::unspecced::get_age_assurance_state::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::get_age_assurance_state::NSID
                        .into(),
                    parameters: None,
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get miscellaneous runtime configuration.
    pub async fn get_config(
        &self,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::get_config::Output,
        crate::app::bsky::unspecced::get_config::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::get_config::NSID.into(),
                    parameters: None,
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a list of suggested starterpacks for onboarding
    pub async fn get_onboarding_suggested_starter_packs(
        &self,
        params: crate::app::bsky::unspecced::get_onboarding_suggested_starter_packs::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::get_onboarding_suggested_starter_packs::Output,
        crate::app::bsky::unspecced::get_onboarding_suggested_starter_packs::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::get_onboarding_suggested_starter_packs::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a skeleton of suggested starterpacks for onboarding. Intended to be called and hydrated by app.bsky.unspecced.getOnboardingSuggestedStarterPacks
    pub async fn get_onboarding_suggested_starter_packs_skeleton(
        &self,
        params: crate::app::bsky::unspecced::get_onboarding_suggested_starter_packs_skeleton::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::get_onboarding_suggested_starter_packs_skeleton::Output,
        crate::app::bsky::unspecced::get_onboarding_suggested_starter_packs_skeleton::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::get_onboarding_suggested_starter_packs_skeleton::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a skeleton of suggested users for onboarding. Intended to be called and hydrated by app.bsky.unspecced.getSuggestedOnboardingUsers
    pub async fn get_onboarding_suggested_users_skeleton(
        &self,
        params: crate::app::bsky::unspecced::get_onboarding_suggested_users_skeleton::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::get_onboarding_suggested_users_skeleton::Output,
        crate::app::bsky::unspecced::get_onboarding_suggested_users_skeleton::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::get_onboarding_suggested_users_skeleton::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///An unspecced view of globally popular feed generators.
    pub async fn get_popular_feed_generators(
        &self,
        params: crate::app::bsky::unspecced::get_popular_feed_generators::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::get_popular_feed_generators::Output,
        crate::app::bsky::unspecced::get_popular_feed_generators::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::get_popular_feed_generators::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///(NOTE: this endpoint is under development and WILL change without notice. Don't use it until it is moved out of `unspecced` or your application WILL break) Get additional posts under a thread e.g. replies hidden by threadgate. Based on an anchor post at any depth of the tree, returns top-level replies below that anchor. It does not include ancestors nor the anchor itself. This should be called after exhausting `app.bsky.unspecced.getPostThreadV2`. Does not require auth, but additional metadata and filtering will be applied for authed requests.
    pub async fn get_post_thread_other_v2(
        &self,
        params: crate::app::bsky::unspecced::get_post_thread_other_v2::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::get_post_thread_other_v2::Output,
        crate::app::bsky::unspecced::get_post_thread_other_v2::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::get_post_thread_other_v2::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///(NOTE: this endpoint is under development and WILL change without notice. Don't use it until it is moved out of `unspecced` or your application WILL break) Get posts in a thread. It is based in an anchor post at any depth of the tree, and returns posts above it (recursively resolving the parent, without further branching to their replies) and below it (recursive replies, with branching to their replies). Does not require auth, but additional metadata and filtering will be applied for authed requests.
    pub async fn get_post_thread_v2(
        &self,
        params: crate::app::bsky::unspecced::get_post_thread_v2::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::get_post_thread_v2::Output,
        crate::app::bsky::unspecced::get_post_thread_v2::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::get_post_thread_v2::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a list of suggested feeds
    pub async fn get_suggested_feeds(
        &self,
        params: crate::app::bsky::unspecced::get_suggested_feeds::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::get_suggested_feeds::Output,
        crate::app::bsky::unspecced::get_suggested_feeds::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::get_suggested_feeds::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a skeleton of suggested feeds. Intended to be called and hydrated by app.bsky.unspecced.getSuggestedFeeds
    pub async fn get_suggested_feeds_skeleton(
        &self,
        params: crate::app::bsky::unspecced::get_suggested_feeds_skeleton::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::get_suggested_feeds_skeleton::Output,
        crate::app::bsky::unspecced::get_suggested_feeds_skeleton::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::get_suggested_feeds_skeleton::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a list of suggested users for onboarding
    pub async fn get_suggested_onboarding_users(
        &self,
        params: crate::app::bsky::unspecced::get_suggested_onboarding_users::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::get_suggested_onboarding_users::Output,
        crate::app::bsky::unspecced::get_suggested_onboarding_users::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::get_suggested_onboarding_users::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a list of suggested starterpacks
    pub async fn get_suggested_starter_packs(
        &self,
        params: crate::app::bsky::unspecced::get_suggested_starter_packs::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::get_suggested_starter_packs::Output,
        crate::app::bsky::unspecced::get_suggested_starter_packs::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::get_suggested_starter_packs::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a skeleton of suggested starterpacks. Intended to be called and hydrated by app.bsky.unspecced.getSuggestedStarterpacks
    pub async fn get_suggested_starter_packs_skeleton(
        &self,
        params: crate::app::bsky::unspecced::get_suggested_starter_packs_skeleton::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::get_suggested_starter_packs_skeleton::Output,
        crate::app::bsky::unspecced::get_suggested_starter_packs_skeleton::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::get_suggested_starter_packs_skeleton::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a list of suggested users
    pub async fn get_suggested_users(
        &self,
        params: crate::app::bsky::unspecced::get_suggested_users::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::get_suggested_users::Output,
        crate::app::bsky::unspecced::get_suggested_users::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::get_suggested_users::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a list of suggested users for the Discover page
    pub async fn get_suggested_users_for_discover(
        &self,
        params: crate::app::bsky::unspecced::get_suggested_users_for_discover::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::get_suggested_users_for_discover::Output,
        crate::app::bsky::unspecced::get_suggested_users_for_discover::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::get_suggested_users_for_discover::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a skeleton of suggested users for the Discover page. Intended to be called and hydrated by app.bsky.unspecced.getSuggestedUsersForDiscover
    pub async fn get_suggested_users_for_discover_skeleton(
        &self,
        params: crate::app::bsky::unspecced::get_suggested_users_for_discover_skeleton::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::get_suggested_users_for_discover_skeleton::Output,
        crate::app::bsky::unspecced::get_suggested_users_for_discover_skeleton::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::get_suggested_users_for_discover_skeleton::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a list of suggested users for the Explore page
    pub async fn get_suggested_users_for_explore(
        &self,
        params: crate::app::bsky::unspecced::get_suggested_users_for_explore::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::get_suggested_users_for_explore::Output,
        crate::app::bsky::unspecced::get_suggested_users_for_explore::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::get_suggested_users_for_explore::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a skeleton of suggested users for the Explore page. Intended to be called and hydrated by app.bsky.unspecced.getSuggestedUsersForExplore
    pub async fn get_suggested_users_for_explore_skeleton(
        &self,
        params: crate::app::bsky::unspecced::get_suggested_users_for_explore_skeleton::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::get_suggested_users_for_explore_skeleton::Output,
        crate::app::bsky::unspecced::get_suggested_users_for_explore_skeleton::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::get_suggested_users_for_explore_skeleton::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a list of suggested users for the See More page
    pub async fn get_suggested_users_for_see_more(
        &self,
        params: crate::app::bsky::unspecced::get_suggested_users_for_see_more::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::get_suggested_users_for_see_more::Output,
        crate::app::bsky::unspecced::get_suggested_users_for_see_more::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::get_suggested_users_for_see_more::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a skeleton of suggested users for the See More page. Intended to be called and hydrated by app.bsky.unspecced.getSuggestedUsersForSeeMore
    pub async fn get_suggested_users_for_see_more_skeleton(
        &self,
        params: crate::app::bsky::unspecced::get_suggested_users_for_see_more_skeleton::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::get_suggested_users_for_see_more_skeleton::Output,
        crate::app::bsky::unspecced::get_suggested_users_for_see_more_skeleton::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::get_suggested_users_for_see_more_skeleton::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a skeleton of suggested users. Intended to be called and hydrated by app.bsky.unspecced.getSuggestedUsers
    pub async fn get_suggested_users_skeleton(
        &self,
        params: crate::app::bsky::unspecced::get_suggested_users_skeleton::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::get_suggested_users_skeleton::Output,
        crate::app::bsky::unspecced::get_suggested_users_skeleton::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::get_suggested_users_skeleton::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a skeleton of suggested actors. Intended to be called and then hydrated through app.bsky.actor.getSuggestions
    pub async fn get_suggestions_skeleton(
        &self,
        params: crate::app::bsky::unspecced::get_suggestions_skeleton::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::get_suggestions_skeleton::Output,
        crate::app::bsky::unspecced::get_suggestions_skeleton::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::get_suggestions_skeleton::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a list of suggestions (feeds and users) tagged with categories
    pub async fn get_tagged_suggestions(
        &self,
        params: crate::app::bsky::unspecced::get_tagged_suggestions::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::get_tagged_suggestions::Output,
        crate::app::bsky::unspecced::get_tagged_suggestions::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::get_tagged_suggestions::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a list of trending topics
    pub async fn get_trending_topics(
        &self,
        params: crate::app::bsky::unspecced::get_trending_topics::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::get_trending_topics::Output,
        crate::app::bsky::unspecced::get_trending_topics::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::get_trending_topics::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get the current trends on the network
    pub async fn get_trends(
        &self,
        params: crate::app::bsky::unspecced::get_trends::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::get_trends::Output,
        crate::app::bsky::unspecced::get_trends::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::get_trends::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get the skeleton of trends on the network. Intended to be called and then hydrated through app.bsky.unspecced.getTrends
    pub async fn get_trends_skeleton(
        &self,
        params: crate::app::bsky::unspecced::get_trends_skeleton::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::get_trends_skeleton::Output,
        crate::app::bsky::unspecced::get_trends_skeleton::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::get_trends_skeleton::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Initiate age assurance for an account. This is a one-time action that will start the process of verifying the user's age.
    pub async fn init_age_assurance(
        &self,
        input: crate::app::bsky::unspecced::init_age_assurance::Input,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::init_age_assurance::Output,
        crate::app::bsky::unspecced::init_age_assurance::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::unspecced::init_age_assurance::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Backend Actors (profile) search, returns only skeleton.
    pub async fn search_actors_skeleton(
        &self,
        params: crate::app::bsky::unspecced::search_actors_skeleton::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::search_actors_skeleton::Output,
        crate::app::bsky::unspecced::search_actors_skeleton::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::search_actors_skeleton::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Backend Posts search, returns only skeleton
    pub async fn search_posts_skeleton(
        &self,
        params: crate::app::bsky::unspecced::search_posts_skeleton::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::search_posts_skeleton::Output,
        crate::app::bsky::unspecced::search_posts_skeleton::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::search_posts_skeleton::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Backend Starter Pack search, returns only skeleton.
    pub async fn search_starter_packs_skeleton(
        &self,
        params: crate::app::bsky::unspecced::search_starter_packs_skeleton::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::unspecced::search_starter_packs_skeleton::Output,
        crate::app::bsky::unspecced::search_starter_packs_skeleton::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::unspecced::search_starter_packs_skeleton::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
#[cfg(feature = "namespace-appbsky")]
impl<T> app::bsky::video::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Abort an upload only while it is created, releasing its quota reservation immediately. Terminal sessions are unchanged and return their terminal outcome. A finishing session returns UploadNotReady.
    pub async fn abort_upload(
        &self,
        input: crate::app::bsky::video::abort_upload::Input,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::video::abort_upload::Output,
        crate::app::bsky::video::abort_upload::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::video::abort_upload::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Finish an upload. This call is idempotent and safe to retry. On deduplication completedJobId may differ from the input jobId; poll getJobStatus with completedJobId. Probe-based validation failures surface later as JOB_STATE_FAILED from getJobStatus, not as errors from this call.
    pub async fn finish_upload(
        &self,
        input: crate::app::bsky::video::finish_upload::Input,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::video::finish_upload::Output,
        crate::app::bsky::video::finish_upload::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::video::finish_upload::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get status details for a video processing job.
    pub async fn get_job_status(
        &self,
        params: crate::app::bsky::video::get_job_status::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::video::get_job_status::Output,
        crate::app::bsky::video::get_job_status::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::video::get_job_status::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get video upload limits for the authenticated user.
    pub async fn get_upload_limits(
        &self,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::video::get_upload_limits::Output,
        crate::app::bsky::video::get_upload_limits::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::video::get_upload_limits::NSID.into(),
                    parameters: None,
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get the authoritative status of the upload phase. Terminal states remain readable. completedJobId and jobStatus are present only for completed sessions; failureReason is present only for failed sessions.
    pub async fn get_upload_status(
        &self,
        params: crate::app::bsky::video::get_upload_status::Parameters,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::video::get_upload_status::Output,
        crate::app::bsky::video::get_upload_status::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::app::bsky::video::get_upload_status::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Start a multipart video upload. The declared size is exact, while optional media properties are advisory and used only for early failure; the authoritative probe runs asynchronously after upload.
    pub async fn start_upload(
        &self,
        input: crate::app::bsky::video::start_upload::Input,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::video::start_upload::Output,
        crate::app::bsky::video::start_upload::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::video::start_upload::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Upload one part. Parts are idempotent and may be retried or re-sent while the session is created. Each expected length is derived from the upload size and part size, and Content-Length must match exactly. ETags are never exposed to clients.
    pub async fn upload_part(
        &self,
        input: Vec<u8>,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::video::upload_part::Output,
        crate::app::bsky::video::upload_part::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                Vec<u8>,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::video::upload_part::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Bytes(input)),
                    encoding: Some(String::from("application/octet-stream")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Upload a video to be processed then stored on the PDS.
    pub async fn upload_video(
        &self,
        input: Vec<u8>,
    ) -> atrium_xrpc::Result<
        crate::app::bsky::video::upload_video::Output,
        crate::app::bsky::video::upload_video::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                Vec<u8>,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::app::bsky::video::upload_video::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Bytes(input)),
                    encoding: Some(String::from("video/mp4")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
impl<T> chat::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            #[cfg(feature = "namespace-chatbsky")]
            bsky: chat::bsky::Service::new(std::sync::Arc::clone(&xrpc)),
            _phantom: core::marker::PhantomData,
        }
    }
}
#[cfg(feature = "namespace-chatbsky")]
impl<T> chat::bsky::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            actor: chat::bsky::actor::Service::new(std::sync::Arc::clone(&xrpc)),
            convo: chat::bsky::convo::Service::new(std::sync::Arc::clone(&xrpc)),
            group: chat::bsky::group::Service::new(std::sync::Arc::clone(&xrpc)),
            moderation: chat::bsky::moderation::Service::new(
                std::sync::Arc::clone(&xrpc),
            ),
            notification: chat::bsky::notification::Service::new(
                std::sync::Arc::clone(&xrpc),
            ),
            _phantom: core::marker::PhantomData,
        }
    }
}
#[cfg(feature = "namespace-chatbsky")]
impl<T> chat::bsky::actor::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    pub async fn delete_account(
        &self,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::actor::delete_account::Output,
        crate::chat::bsky::actor::delete_account::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::actor::delete_account::NSID.into(),
                    parameters: None,
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    pub async fn export_account_data(
        &self,
    ) -> atrium_xrpc::Result<
        Vec<u8>,
        crate::chat::bsky::actor::export_account_data::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                (),
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::chat::bsky::actor::export_account_data::NSID.into(),
                    parameters: None,
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(bytes) => Ok(bytes),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get the authenticated viewer's chat status: whether their account is chat-disabled and whether their group-membership additions are restricted to accounts they follow.
    pub async fn get_status(
        &self,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::actor::get_status::Output,
        crate::chat::bsky::actor::get_status::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::chat::bsky::actor::get_status::NSID.into(),
                    parameters: None,
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
#[cfg(feature = "namespace-chatbsky")]
impl<T> chat::bsky::convo::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Marks a conversation as accepted, so it is shown in the list of accepted convos instead on the request convos.
    pub async fn accept_convo(
        &self,
        input: crate::chat::bsky::convo::accept_convo::Input,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::convo::accept_convo::Output,
        crate::chat::bsky::convo::accept_convo::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::convo::accept_convo::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Adds an emoji reaction to a message. Requires authentication. It is idempotent, so multiple calls from the same user with the same emoji result in a single reaction.
    pub async fn add_reaction(
        &self,
        input: crate::chat::bsky::convo::add_reaction::Input,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::convo::add_reaction::Output,
        crate::chat::bsky::convo::add_reaction::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::convo::add_reaction::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Marks a message as deleted for the viewer, so they won't see that message in future enumerations.
    pub async fn delete_message_for_self(
        &self,
        input: crate::chat::bsky::convo::delete_message_for_self::Input,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::convo::delete_message_for_self::Output,
        crate::chat::bsky::convo::delete_message_for_self::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::convo::delete_message_for_self::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Gets an existing conversation by its ID.
    pub async fn get_convo(
        &self,
        params: crate::chat::bsky::convo::get_convo::Parameters,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::convo::get_convo::Output,
        crate::chat::bsky::convo::get_convo::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::chat::bsky::convo::get_convo::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Check whether the requester and the other members can start a 1-1 chat. Only applicable to direct (non-group) conversations. If an existing convo is found for these members, it is returned. Does not create a new convo if it doesn't exist.
    pub async fn get_convo_availability(
        &self,
        params: crate::chat::bsky::convo::get_convo_availability::Parameters,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::convo::get_convo_availability::Output,
        crate::chat::bsky::convo::get_convo_availability::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::chat::bsky::convo::get_convo_availability::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get or create a 1-1 conversation for the given members. Always returns the same direct (non-group) conversation. To create a group conversation, use createGroup.
    pub async fn get_convo_for_members(
        &self,
        params: crate::chat::bsky::convo::get_convo_for_members::Parameters,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::convo::get_convo_for_members::Output,
        crate::chat::bsky::convo::get_convo_for_members::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::chat::bsky::convo::get_convo_for_members::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Returns a paginated list of members from a conversation.
    pub async fn get_convo_members(
        &self,
        params: crate::chat::bsky::convo::get_convo_members::Parameters,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::convo::get_convo_members::Output,
        crate::chat::bsky::convo::get_convo_members::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::chat::bsky::convo::get_convo_members::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    pub async fn get_log(
        &self,
        params: crate::chat::bsky::convo::get_log::Parameters,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::convo::get_log::Output,
        crate::chat::bsky::convo::get_log::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::chat::bsky::convo::get_log::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Returns a page of messages from a conversation.
    pub async fn get_messages(
        &self,
        params: crate::chat::bsky::convo::get_messages::Parameters,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::convo::get_messages::Output,
        crate::chat::bsky::convo::get_messages::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::chat::bsky::convo::get_messages::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Returns unread conversation counts for conversations that are unlocked, not muted, split by convo status. Direct convos are excluded when a block relationship exists between the actor and the other member, or when the other member's account is deleted or deactivated. Group convos are considered unread if they have unread join request counts.
    pub async fn get_unread_counts(
        &self,
        params: crate::chat::bsky::convo::get_unread_counts::Parameters,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::convo::get_unread_counts::Output,
        crate::chat::bsky::convo::get_unread_counts::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::chat::bsky::convo::get_unread_counts::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Leaves a conversation (direct or group). For group, this effectively removes membership. For direct, membership is never removed, only changed to remove from enumerations by the user who left.
    pub async fn leave_convo(
        &self,
        input: crate::chat::bsky::convo::leave_convo::Input,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::convo::leave_convo::Output,
        crate::chat::bsky::convo::leave_convo::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::convo::leave_convo::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Returns a page of incoming conversation requests for the user. Direct convo requests are returned as convoView; group join requests made by the user are returned as joinRequestConvoView.
    pub async fn list_convo_requests(
        &self,
        params: crate::chat::bsky::convo::list_convo_requests::Parameters,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::convo::list_convo_requests::Output,
        crate::chat::bsky::convo::list_convo_requests::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::chat::bsky::convo::list_convo_requests::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Returns a page of conversations (direct or group) for the user.
    pub async fn list_convos(
        &self,
        params: crate::chat::bsky::convo::list_convos::Parameters,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::convo::list_convos::Output,
        crate::chat::bsky::convo::list_convos::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::chat::bsky::convo::list_convos::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Locks a group convo so no more content (messages, reactions) can be added to it.
    pub async fn lock_convo(
        &self,
        input: crate::chat::bsky::convo::lock_convo::Input,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::convo::lock_convo::Output,
        crate::chat::bsky::convo::lock_convo::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::convo::lock_convo::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Mutes a conversation, preventing notifications related to it.
    pub async fn mute_convo(
        &self,
        input: crate::chat::bsky::convo::mute_convo::Input,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::convo::mute_convo::Output,
        crate::chat::bsky::convo::mute_convo::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::convo::mute_convo::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Removes an emoji reaction from a message. Requires authentication. It is idempotent, so multiple calls from the same user with the same emoji result in that reaction not being present, even if it already wasn't.
    pub async fn remove_reaction(
        &self,
        input: crate::chat::bsky::convo::remove_reaction::Input,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::convo::remove_reaction::Output,
        crate::chat::bsky::convo::remove_reaction::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::convo::remove_reaction::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Sends a message to a conversation.
    pub async fn send_message(
        &self,
        input: crate::chat::bsky::convo::send_message::Input,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::convo::send_message::Output,
        crate::chat::bsky::convo::send_message::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::convo::send_message::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Sends a batch of messages to a conversation.
    pub async fn send_message_batch(
        &self,
        input: crate::chat::bsky::convo::send_message_batch::Input,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::convo::send_message_batch::Output,
        crate::chat::bsky::convo::send_message_batch::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::convo::send_message_batch::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Unlocks a group convo so it is able to receive new content.
    pub async fn unlock_convo(
        &self,
        input: crate::chat::bsky::convo::unlock_convo::Input,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::convo::unlock_convo::Output,
        crate::chat::bsky::convo::unlock_convo::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::convo::unlock_convo::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Unmutes a conversation, allowing notifications related to it.
    pub async fn unmute_convo(
        &self,
        input: crate::chat::bsky::convo::unmute_convo::Input,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::convo::unmute_convo::Output,
        crate::chat::bsky::convo::unmute_convo::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::convo::unmute_convo::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Sets conversations from a user as read to the latest message, with filters.
    pub async fn update_all_read(
        &self,
        input: crate::chat::bsky::convo::update_all_read::Input,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::convo::update_all_read::Output,
        crate::chat::bsky::convo::update_all_read::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::convo::update_all_read::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Updates the read state of a conversation from, optionally specifying the last read message.
    pub async fn update_read(
        &self,
        input: crate::chat::bsky::convo::update_read::Input,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::convo::update_read::Output,
        crate::chat::bsky::convo::update_read::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::convo::update_read::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
#[cfg(feature = "namespace-chatbsky")]
impl<T> chat::bsky::group::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Adds members to a group. The members are added in 'request' status, so they have to accept it. This creates convo memberships.
    pub async fn add_members(
        &self,
        input: crate::chat::bsky::group::add_members::Input,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::group::add_members::Output,
        crate::chat::bsky::group::add_members::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::group::add_members::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Approves a request to join a group (via join link) the user owns. Action taken by the group owner.
    pub async fn approve_join_request(
        &self,
        input: crate::chat::bsky::group::approve_join_request::Input,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::group::approve_join_request::Output,
        crate::chat::bsky::group::approve_join_request::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::group::approve_join_request::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Creates a group convo, specifying the members to be added to it. Unlike getConvoForMembers, this isn't idempotent. It will create new groups even if the membership is identical to pre-existing groups. Will create 'request' membership for all members, except the owner who is 'accepted'.
    pub async fn create_group(
        &self,
        input: crate::chat::bsky::group::create_group::Input,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::group::create_group::Output,
        crate::chat::bsky::group::create_group::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::group::create_group::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Creates a join link for the group convo.
    pub async fn create_join_link(
        &self,
        input: crate::chat::bsky::group::create_join_link::Input,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::group::create_join_link::Output,
        crate::chat::bsky::group::create_join_link::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::group::create_join_link::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Disables the active join link for the group convo.
    pub async fn disable_join_link(
        &self,
        input: crate::chat::bsky::group::disable_join_link::Input,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::group::disable_join_link::Output,
        crate::chat::bsky::group::disable_join_link::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::group::disable_join_link::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Edits group settings.
    pub async fn edit_group(
        &self,
        input: crate::chat::bsky::group::edit_group::Input,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::group::edit_group::Output,
        crate::chat::bsky::group::edit_group::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::group::edit_group::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Edits the existing join link settings for the group convo.
    pub async fn edit_join_link(
        &self,
        input: crate::chat::bsky::group::edit_join_link::Input,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::group::edit_join_link::Output,
        crate::chat::bsky::group::edit_join_link::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::group::edit_join_link::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Re-enables a previously disabled join link for the group convo.
    pub async fn enable_join_link(
        &self,
        input: crate::chat::bsky::group::enable_join_link::Input,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::group::enable_join_link::Output,
        crate::chat::bsky::group::enable_join_link::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::group::enable_join_link::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get public information about groups from join links. The output array matches the input codes one-to-one by position (and each view also carries its 'code'). Disabled codes return a disabledJoinLinkPreviewView, and codes that do not map to a previewable link return an invalidJoinLinkPreviewView.
    pub async fn get_join_link_previews(
        &self,
        params: crate::chat::bsky::group::get_join_link_previews::Parameters,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::group::get_join_link_previews::Output,
        crate::chat::bsky::group::get_join_link_previews::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::chat::bsky::group::get_join_link_previews::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Lists a page of request to join a group (via join link) the user owns. Shows the data from the owner's point of view.
    pub async fn list_join_requests(
        &self,
        params: crate::chat::bsky::group::list_join_requests::Parameters,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::group::list_join_requests::Output,
        crate::chat::bsky::group::list_join_requests::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::chat::bsky::group::list_join_requests::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Returns a page of group conversations that both the requester and the specified actor are members of.
    pub async fn list_mutual_groups(
        &self,
        params: crate::chat::bsky::group::list_mutual_groups::Parameters,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::group::list_mutual_groups::Output,
        crate::chat::bsky::group::list_mutual_groups::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::chat::bsky::group::list_mutual_groups::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Rejects a request to join a group (via join link) the user owns. Action taken by the group owner.
    pub async fn reject_join_request(
        &self,
        input: crate::chat::bsky::group::reject_join_request::Input,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::group::reject_join_request::Output,
        crate::chat::bsky::group::reject_join_request::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::group::reject_join_request::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Removes members from a group. This deletes convo memberships, doesn't just set a status.
    pub async fn remove_members(
        &self,
        input: crate::chat::bsky::group::remove_members::Input,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::group::remove_members::Output,
        crate::chat::bsky::group::remove_members::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::group::remove_members::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Sends a request to join a group (via join link) to the group owner. Action taken by the prospective group member.
    pub async fn request_join(
        &self,
        input: crate::chat::bsky::group::request_join::Input,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::group::request_join::Output,
        crate::chat::bsky::group::request_join::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::group::request_join::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Marks all join requests as read for the group owner.
    pub async fn update_join_requests_read(
        &self,
        input: crate::chat::bsky::group::update_join_requests_read::Input,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::group::update_join_requests_read::Output,
        crate::chat::bsky::group::update_join_requests_read::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::group::update_join_requests_read::NSID
                        .into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Withdraws a pending request to join a group. Action taken by the prospective member who originally requested to join.
    pub async fn withdraw_join_request(
        &self,
        input: crate::chat::bsky::group::withdraw_join_request::Input,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::group::withdraw_join_request::Output,
        crate::chat::bsky::group::withdraw_join_request::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::group::withdraw_join_request::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
#[cfg(feature = "namespace-chatbsky")]
impl<T> chat::bsky::moderation::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    pub async fn get_actor_metadata(
        &self,
        params: crate::chat::bsky::moderation::get_actor_metadata::Parameters,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::moderation::get_actor_metadata::Output,
        crate::chat::bsky::moderation::get_actor_metadata::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::chat::bsky::moderation::get_actor_metadata::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Gets an existing conversation by its ID, for moderation purposes. Does not require the requester to be a member of the conversation.
    pub async fn get_convo(
        &self,
        params: crate::chat::bsky::moderation::get_convo::Parameters,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::moderation::get_convo::Output,
        crate::chat::bsky::moderation::get_convo::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::chat::bsky::moderation::get_convo::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Returns a paginated list of members from a conversation, for moderation purposes. Does not require the requester to be a member of the conversation.
    pub async fn get_convo_members(
        &self,
        params: crate::chat::bsky::moderation::get_convo_members::Parameters,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::moderation::get_convo_members::Output,
        crate::chat::bsky::moderation::get_convo_members::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::chat::bsky::moderation::get_convo_members::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Gets existing conversations by their IDs, for moderation purposes. Does not require the requester to be a member of the conversations. Unknown IDs are silently omitted from the response.
    pub async fn get_convos(
        &self,
        params: crate::chat::bsky::moderation::get_convos::Parameters,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::moderation::get_convos::Output,
        crate::chat::bsky::moderation::get_convos::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::chat::bsky::moderation::get_convos::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    pub async fn get_message_context(
        &self,
        params: crate::chat::bsky::moderation::get_message_context::Parameters,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::moderation::get_message_context::Output,
        crate::chat::bsky::moderation::get_message_context::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::chat::bsky::moderation::get_message_context::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    pub async fn update_actor_access(
        &self,
        input: crate::chat::bsky::moderation::update_actor_access::Input,
    ) -> atrium_xrpc::Result<
        (),
        crate::chat::bsky::moderation::update_actor_access::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::moderation::update_actor_access::NSID
                        .into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
#[cfg(feature = "namespace-chatbsky")]
impl<T> chat::bsky::notification::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Get the requesting account's chat notification preferences. Defaults are returned for accounts that have not set any preferences. Requires auth.
    pub async fn get_preferences(
        &self,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::notification::get_preferences::Output,
        crate::chat::bsky::notification::get_preferences::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::chat::bsky::notification::get_preferences::NSID.into(),
                    parameters: None,
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Set the requesting account's chat notification preferences. Only the provided preferences are updated; omitted preferences are left unchanged.
    pub async fn put_preferences(
        &self,
        input: crate::chat::bsky::notification::put_preferences::Input,
    ) -> atrium_xrpc::Result<
        crate::chat::bsky::notification::put_preferences::Output,
        crate::chat::bsky::notification::put_preferences::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::chat::bsky::notification::put_preferences::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
impl<T> com::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            atproto: com::atproto::Service::new(std::sync::Arc::clone(&xrpc)),
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<T> com::atproto::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            admin: com::atproto::admin::Service::new(std::sync::Arc::clone(&xrpc)),
            identity: com::atproto::identity::Service::new(std::sync::Arc::clone(&xrpc)),
            label: com::atproto::label::Service::new(std::sync::Arc::clone(&xrpc)),
            lexicon: com::atproto::lexicon::Service::new(std::sync::Arc::clone(&xrpc)),
            moderation: com::atproto::moderation::Service::new(
                std::sync::Arc::clone(&xrpc),
            ),
            repo: com::atproto::repo::Service::new(std::sync::Arc::clone(&xrpc)),
            server: com::atproto::server::Service::new(std::sync::Arc::clone(&xrpc)),
            sync: com::atproto::sync::Service::new(std::sync::Arc::clone(&xrpc)),
            temp: com::atproto::temp::Service::new(std::sync::Arc::clone(&xrpc)),
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<T> com::atproto::admin::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Delete a user account as an administrator.
    pub async fn delete_account(
        &self,
        input: crate::com::atproto::admin::delete_account::Input,
    ) -> atrium_xrpc::Result<(), crate::com::atproto::admin::delete_account::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::admin::delete_account::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Disable an account from receiving new invite codes, but does not invalidate existing codes.
    pub async fn disable_account_invites(
        &self,
        input: crate::com::atproto::admin::disable_account_invites::Input,
    ) -> atrium_xrpc::Result<
        (),
        crate::com::atproto::admin::disable_account_invites::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::admin::disable_account_invites::NSID
                        .into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Disable some set of codes and/or all codes associated with a set of users.
    pub async fn disable_invite_codes(
        &self,
        input: crate::com::atproto::admin::disable_invite_codes::Input,
    ) -> atrium_xrpc::Result<
        (),
        crate::com::atproto::admin::disable_invite_codes::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::admin::disable_invite_codes::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Re-enable an account's ability to receive invite codes.
    pub async fn enable_account_invites(
        &self,
        input: crate::com::atproto::admin::enable_account_invites::Input,
    ) -> atrium_xrpc::Result<
        (),
        crate::com::atproto::admin::enable_account_invites::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::admin::enable_account_invites::NSID
                        .into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get details about an account.
    pub async fn get_account_info(
        &self,
        params: crate::com::atproto::admin::get_account_info::Parameters,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::admin::get_account_info::Output,
        crate::com::atproto::admin::get_account_info::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::admin::get_account_info::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get details about some accounts.
    pub async fn get_account_infos(
        &self,
        params: crate::com::atproto::admin::get_account_infos::Parameters,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::admin::get_account_infos::Output,
        crate::com::atproto::admin::get_account_infos::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::admin::get_account_infos::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get an admin view of invite codes.
    pub async fn get_invite_codes(
        &self,
        params: crate::com::atproto::admin::get_invite_codes::Parameters,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::admin::get_invite_codes::Output,
        crate::com::atproto::admin::get_invite_codes::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::admin::get_invite_codes::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get the service-specific admin status of a subject (account, record, or blob).
    pub async fn get_subject_status(
        &self,
        params: crate::com::atproto::admin::get_subject_status::Parameters,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::admin::get_subject_status::Output,
        crate::com::atproto::admin::get_subject_status::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::admin::get_subject_status::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get list of accounts that matches your search query.
    pub async fn search_accounts(
        &self,
        params: crate::com::atproto::admin::search_accounts::Parameters,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::admin::search_accounts::Output,
        crate::com::atproto::admin::search_accounts::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::admin::search_accounts::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Send email to a user's account email address.
    pub async fn send_email(
        &self,
        input: crate::com::atproto::admin::send_email::Input,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::admin::send_email::Output,
        crate::com::atproto::admin::send_email::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::admin::send_email::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Administrative action to update an account's email.
    pub async fn update_account_email(
        &self,
        input: crate::com::atproto::admin::update_account_email::Input,
    ) -> atrium_xrpc::Result<
        (),
        crate::com::atproto::admin::update_account_email::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::admin::update_account_email::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Administrative action to update an account's handle.
    pub async fn update_account_handle(
        &self,
        input: crate::com::atproto::admin::update_account_handle::Input,
    ) -> atrium_xrpc::Result<
        (),
        crate::com::atproto::admin::update_account_handle::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::admin::update_account_handle::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Update the password for a user account as an administrator.
    pub async fn update_account_password(
        &self,
        input: crate::com::atproto::admin::update_account_password::Input,
    ) -> atrium_xrpc::Result<
        (),
        crate::com::atproto::admin::update_account_password::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::admin::update_account_password::NSID
                        .into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Administrative action to update an account's signing key in their Did document.
    pub async fn update_account_signing_key(
        &self,
        input: crate::com::atproto::admin::update_account_signing_key::Input,
    ) -> atrium_xrpc::Result<
        (),
        crate::com::atproto::admin::update_account_signing_key::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::admin::update_account_signing_key::NSID
                        .into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Update the service-specific admin status of a subject (account, record, or blob).
    pub async fn update_subject_status(
        &self,
        input: crate::com::atproto::admin::update_subject_status::Input,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::admin::update_subject_status::Output,
        crate::com::atproto::admin::update_subject_status::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::admin::update_subject_status::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
impl<T> com::atproto::identity::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Describe the credentials that should be included in the DID doc of an account that is migrating to this service.
    pub async fn get_recommended_did_credentials(
        &self,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::identity::get_recommended_did_credentials::Output,
        crate::com::atproto::identity::get_recommended_did_credentials::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::identity::get_recommended_did_credentials::NSID
                        .into(),
                    parameters: None,
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Request that the server re-resolve an identity (DID and handle). The server may ignore this request, or require authentication, depending on the role, implementation, and policy of the server.
    pub async fn refresh_identity(
        &self,
        input: crate::com::atproto::identity::refresh_identity::Input,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::identity::refresh_identity::Output,
        crate::com::atproto::identity::refresh_identity::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::identity::refresh_identity::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Request an email with a code to in order to request a signed PLC operation. Requires Auth.
    pub async fn request_plc_operation_signature(
        &self,
    ) -> atrium_xrpc::Result<
        (),
        crate::com::atproto::identity::request_plc_operation_signature::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                (),
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::identity::request_plc_operation_signature::NSID
                        .into(),
                    parameters: None,
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Resolves DID to DID document. Does not bi-directionally verify handle.
    pub async fn resolve_did(
        &self,
        params: crate::com::atproto::identity::resolve_did::Parameters,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::identity::resolve_did::Output,
        crate::com::atproto::identity::resolve_did::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::identity::resolve_did::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Resolves an atproto handle (hostname) to a DID. Does not necessarily bi-directionally verify against the the DID document.
    pub async fn resolve_handle(
        &self,
        params: crate::com::atproto::identity::resolve_handle::Parameters,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::identity::resolve_handle::Output,
        crate::com::atproto::identity::resolve_handle::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::identity::resolve_handle::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Resolves an identity (DID or Handle) to a full identity (DID document and verified handle).
    pub async fn resolve_identity(
        &self,
        params: crate::com::atproto::identity::resolve_identity::Parameters,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::identity::resolve_identity::Output,
        crate::com::atproto::identity::resolve_identity::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::identity::resolve_identity::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Signs a PLC operation to update some value(s) in the requesting DID's document.
    pub async fn sign_plc_operation(
        &self,
        input: crate::com::atproto::identity::sign_plc_operation::Input,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::identity::sign_plc_operation::Output,
        crate::com::atproto::identity::sign_plc_operation::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::identity::sign_plc_operation::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Validates a PLC operation to ensure that it doesn't violate a service's constraints or get the identity into a bad state, then submits it to the PLC registry
    pub async fn submit_plc_operation(
        &self,
        input: crate::com::atproto::identity::submit_plc_operation::Input,
    ) -> atrium_xrpc::Result<
        (),
        crate::com::atproto::identity::submit_plc_operation::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::identity::submit_plc_operation::NSID
                        .into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Updates the current account's handle. Verifies handle validity, and updates did:plc document if necessary. Implemented by PDS, and requires auth.
    pub async fn update_handle(
        &self,
        input: crate::com::atproto::identity::update_handle::Input,
    ) -> atrium_xrpc::Result<(), crate::com::atproto::identity::update_handle::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::identity::update_handle::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
impl<T> com::atproto::label::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Find labels relevant to the provided AT-URI patterns. Public endpoint for moderation services, though may return different or additional results with auth.
    pub async fn query_labels(
        &self,
        params: crate::com::atproto::label::query_labels::Parameters,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::label::query_labels::Output,
        crate::com::atproto::label::query_labels::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::label::query_labels::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
impl<T> com::atproto::lexicon::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Resolves an atproto lexicon (NSID) to a schema.
    pub async fn resolve_lexicon(
        &self,
        params: crate::com::atproto::lexicon::resolve_lexicon::Parameters,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::lexicon::resolve_lexicon::Output,
        crate::com::atproto::lexicon::resolve_lexicon::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::lexicon::resolve_lexicon::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
impl<T> com::atproto::moderation::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Submit a moderation report regarding an atproto account or record. Implemented by moderation services (with PDS proxying), and requires auth.
    pub async fn create_report(
        &self,
        input: crate::com::atproto::moderation::create_report::Input,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::moderation::create_report::Output,
        crate::com::atproto::moderation::create_report::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::moderation::create_report::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
impl<T> com::atproto::repo::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Apply a batch transaction of repository creates, updates, and deletes. Requires auth, implemented by PDS.
    pub async fn apply_writes(
        &self,
        input: crate::com::atproto::repo::apply_writes::Input,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::repo::apply_writes::Output,
        crate::com::atproto::repo::apply_writes::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::repo::apply_writes::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Create a single new repository record. Requires auth, implemented by PDS.
    pub async fn create_record(
        &self,
        input: crate::com::atproto::repo::create_record::Input,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::repo::create_record::Output,
        crate::com::atproto::repo::create_record::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::repo::create_record::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Delete a repository record, or ensure it doesn't exist. Requires auth, implemented by PDS.
    pub async fn delete_record(
        &self,
        input: crate::com::atproto::repo::delete_record::Input,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::repo::delete_record::Output,
        crate::com::atproto::repo::delete_record::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::repo::delete_record::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get information about an account and repository, including the list of collections. Does not require auth.
    pub async fn describe_repo(
        &self,
        params: crate::com::atproto::repo::describe_repo::Parameters,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::repo::describe_repo::Output,
        crate::com::atproto::repo::describe_repo::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::repo::describe_repo::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a single record from a repository. Does not require auth.
    pub async fn get_record(
        &self,
        params: crate::com::atproto::repo::get_record::Parameters,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::repo::get_record::Output,
        crate::com::atproto::repo::get_record::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::repo::get_record::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Import a repo in the form of a CAR file. Requires Content-Length HTTP header to be set.
    pub async fn import_repo(
        &self,
        input: Vec<u8>,
    ) -> atrium_xrpc::Result<(), crate::com::atproto::repo::import_repo::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                Vec<u8>,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::repo::import_repo::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Bytes(input)),
                    encoding: Some(String::from("application/vnd.ipld.car")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Returns a list of missing blobs for the requesting account. Intended to be used in the account migration flow.
    pub async fn list_missing_blobs(
        &self,
        params: crate::com::atproto::repo::list_missing_blobs::Parameters,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::repo::list_missing_blobs::Output,
        crate::com::atproto::repo::list_missing_blobs::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::repo::list_missing_blobs::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///List a range of records in a repository, matching a specific collection. Does not require auth.
    pub async fn list_records(
        &self,
        params: crate::com::atproto::repo::list_records::Parameters,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::repo::list_records::Output,
        crate::com::atproto::repo::list_records::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::repo::list_records::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Write a repository record, creating or updating it as needed. Requires auth, implemented by PDS.
    pub async fn put_record(
        &self,
        input: crate::com::atproto::repo::put_record::Input,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::repo::put_record::Output,
        crate::com::atproto::repo::put_record::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::repo::put_record::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Upload a new blob, to be referenced from a repository record. The blob will be deleted if it is not referenced within a time window (eg, minutes). Blob restrictions (mimetype, size, etc) are enforced when the reference is created. Requires auth, implemented by PDS.
    pub async fn upload_blob(
        &self,
        input: Vec<u8>,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::repo::upload_blob::Output,
        crate::com::atproto::repo::upload_blob::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                Vec<u8>,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::repo::upload_blob::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Bytes(input)),
                    encoding: Some(String::from("*/*")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
impl<T> com::atproto::server::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Activates a currently deactivated account. Used to finalize account migration after the account's repo is imported and identity is setup.
    pub async fn activate_account(
        &self,
    ) -> atrium_xrpc::Result<(), crate::com::atproto::server::activate_account::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                (),
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::server::activate_account::NSID.into(),
                    parameters: None,
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Returns the status of an account, especially as pertaining to import or recovery. Can be called many times over the course of an account migration. Requires auth and can only be called pertaining to oneself.
    pub async fn check_account_status(
        &self,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::server::check_account_status::Output,
        crate::com::atproto::server::check_account_status::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::server::check_account_status::NSID.into(),
                    parameters: None,
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Confirm an email using a token from com.atproto.server.requestEmailConfirmation.
    pub async fn confirm_email(
        &self,
        input: crate::com::atproto::server::confirm_email::Input,
    ) -> atrium_xrpc::Result<(), crate::com::atproto::server::confirm_email::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::server::confirm_email::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Create an account. Implemented by PDS.
    pub async fn create_account(
        &self,
        input: crate::com::atproto::server::create_account::Input,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::server::create_account::Output,
        crate::com::atproto::server::create_account::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::server::create_account::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Create an App Password.
    pub async fn create_app_password(
        &self,
        input: crate::com::atproto::server::create_app_password::Input,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::server::create_app_password::Output,
        crate::com::atproto::server::create_app_password::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::server::create_app_password::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Create an invite code.
    pub async fn create_invite_code(
        &self,
        input: crate::com::atproto::server::create_invite_code::Input,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::server::create_invite_code::Output,
        crate::com::atproto::server::create_invite_code::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::server::create_invite_code::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Create invite codes.
    pub async fn create_invite_codes(
        &self,
        input: crate::com::atproto::server::create_invite_codes::Input,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::server::create_invite_codes::Output,
        crate::com::atproto::server::create_invite_codes::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::server::create_invite_codes::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Create an authentication session.
    pub async fn create_session(
        &self,
        input: crate::com::atproto::server::create_session::Input,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::server::create_session::Output,
        crate::com::atproto::server::create_session::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::server::create_session::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Deactivates a currently active account. Stops serving of repo, and future writes to repo until reactivated. Used to finalize account migration with the old host after the account has been activated on the new host.
    pub async fn deactivate_account(
        &self,
        input: crate::com::atproto::server::deactivate_account::Input,
    ) -> atrium_xrpc::Result<
        (),
        crate::com::atproto::server::deactivate_account::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::server::deactivate_account::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Delete an actor's account with a token and password. Can only be called after requesting a deletion token. Requires auth.
    pub async fn delete_account(
        &self,
        input: crate::com::atproto::server::delete_account::Input,
    ) -> atrium_xrpc::Result<(), crate::com::atproto::server::delete_account::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::server::delete_account::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Delete the current session. Requires auth using the 'refreshJwt' (not the 'accessJwt').
    pub async fn delete_session(
        &self,
    ) -> atrium_xrpc::Result<(), crate::com::atproto::server::delete_session::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                (),
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::server::delete_session::NSID.into(),
                    parameters: None,
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Describes the server's account creation requirements and capabilities. Implemented by PDS.
    pub async fn describe_server(
        &self,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::server::describe_server::Output,
        crate::com::atproto::server::describe_server::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::server::describe_server::NSID.into(),
                    parameters: None,
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get all invite codes for the current account. Requires auth.
    pub async fn get_account_invite_codes(
        &self,
        params: crate::com::atproto::server::get_account_invite_codes::Parameters,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::server::get_account_invite_codes::Output,
        crate::com::atproto::server::get_account_invite_codes::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::server::get_account_invite_codes::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a signed token on behalf of the requesting DID for the requested service.
    pub async fn get_service_auth(
        &self,
        params: crate::com::atproto::server::get_service_auth::Parameters,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::server::get_service_auth::Output,
        crate::com::atproto::server::get_service_auth::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::server::get_service_auth::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get information about the current auth session. Requires auth.
    pub async fn get_session(
        &self,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::server::get_session::Output,
        crate::com::atproto::server::get_session::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::server::get_session::NSID.into(),
                    parameters: None,
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///List all App Passwords.
    pub async fn list_app_passwords(
        &self,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::server::list_app_passwords::Output,
        crate::com::atproto::server::list_app_passwords::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::server::list_app_passwords::NSID.into(),
                    parameters: None,
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Refresh an authentication session. Requires auth using the 'refreshJwt' (not the 'accessJwt').
    pub async fn refresh_session(
        &self,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::server::refresh_session::Output,
        crate::com::atproto::server::refresh_session::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::server::refresh_session::NSID.into(),
                    parameters: None,
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Initiate a user account deletion via email.
    pub async fn request_account_delete(
        &self,
    ) -> atrium_xrpc::Result<
        (),
        crate::com::atproto::server::request_account_delete::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                (),
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::server::request_account_delete::NSID
                        .into(),
                    parameters: None,
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Request an email with a code to confirm ownership of email.
    pub async fn request_email_confirmation(
        &self,
    ) -> atrium_xrpc::Result<
        (),
        crate::com::atproto::server::request_email_confirmation::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                (),
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::server::request_email_confirmation::NSID
                        .into(),
                    parameters: None,
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Request a token in order to update email.
    pub async fn request_email_update(
        &self,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::server::request_email_update::Output,
        crate::com::atproto::server::request_email_update::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::server::request_email_update::NSID.into(),
                    parameters: None,
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Initiate a user account password reset via email.
    pub async fn request_password_reset(
        &self,
        input: crate::com::atproto::server::request_password_reset::Input,
    ) -> atrium_xrpc::Result<
        (),
        crate::com::atproto::server::request_password_reset::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::server::request_password_reset::NSID
                        .into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Reserve a repo signing key, for use with account creation. Necessary so that a DID PLC update operation can be constructed during an account migraiton. Public and does not require auth; implemented by PDS. NOTE: this endpoint may change when full account migration is implemented.
    pub async fn reserve_signing_key(
        &self,
        input: crate::com::atproto::server::reserve_signing_key::Input,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::server::reserve_signing_key::Output,
        crate::com::atproto::server::reserve_signing_key::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::server::reserve_signing_key::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Reset a user account password using a token.
    pub async fn reset_password(
        &self,
        input: crate::com::atproto::server::reset_password::Input,
    ) -> atrium_xrpc::Result<(), crate::com::atproto::server::reset_password::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::server::reset_password::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Revoke an App Password by name.
    pub async fn revoke_app_password(
        &self,
        input: crate::com::atproto::server::revoke_app_password::Input,
    ) -> atrium_xrpc::Result<
        (),
        crate::com::atproto::server::revoke_app_password::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::server::revoke_app_password::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Update an account's email.
    pub async fn update_email(
        &self,
        input: crate::com::atproto::server::update_email::Input,
    ) -> atrium_xrpc::Result<(), crate::com::atproto::server::update_email::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::server::update_email::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
impl<T> com::atproto::sync::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Get a blob associated with a given account. Returns the full blob as originally uploaded. Does not require auth; implemented by PDS.
    pub async fn get_blob(
        &self,
        params: crate::com::atproto::sync::get_blob::Parameters,
    ) -> atrium_xrpc::Result<Vec<u8>, crate::com::atproto::sync::get_blob::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::sync::get_blob::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(bytes) => Ok(bytes),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get data blocks from a given repo, by CID. For example, intermediate MST nodes, or records. Does not require auth; implemented by PDS.
    pub async fn get_blocks(
        &self,
        params: crate::com::atproto::sync::get_blocks::Parameters,
    ) -> atrium_xrpc::Result<Vec<u8>, crate::com::atproto::sync::get_blocks::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::sync::get_blocks::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(bytes) => Ok(bytes),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///DEPRECATED - please use com.atproto.sync.getRepo instead
    pub async fn get_checkout(
        &self,
        params: crate::com::atproto::sync::get_checkout::Parameters,
    ) -> atrium_xrpc::Result<Vec<u8>, crate::com::atproto::sync::get_checkout::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::sync::get_checkout::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(bytes) => Ok(bytes),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///DEPRECATED - please use com.atproto.sync.getLatestCommit instead
    pub async fn get_head(
        &self,
        params: crate::com::atproto::sync::get_head::Parameters,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::sync::get_head::Output,
        crate::com::atproto::sync::get_head::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::sync::get_head::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Returns information about a specified upstream host, as consumed by the server. Implemented by relays.
    pub async fn get_host_status(
        &self,
        params: crate::com::atproto::sync::get_host_status::Parameters,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::sync::get_host_status::Output,
        crate::com::atproto::sync::get_host_status::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::sync::get_host_status::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get the current commit CID & revision of the specified repo. Does not require auth.
    pub async fn get_latest_commit(
        &self,
        params: crate::com::atproto::sync::get_latest_commit::Parameters,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::sync::get_latest_commit::Output,
        crate::com::atproto::sync::get_latest_commit::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::sync::get_latest_commit::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get data blocks needed to prove the existence or non-existence of record in the current version of repo. Does not require auth.
    pub async fn get_record(
        &self,
        params: crate::com::atproto::sync::get_record::Parameters,
    ) -> atrium_xrpc::Result<Vec<u8>, crate::com::atproto::sync::get_record::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::sync::get_record::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(bytes) => Ok(bytes),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Download a repository export as CAR file. Optionally only a 'diff' since a previous revision. Does not require auth; implemented by PDS.
    pub async fn get_repo(
        &self,
        params: crate::com::atproto::sync::get_repo::Parameters,
    ) -> atrium_xrpc::Result<Vec<u8>, crate::com::atproto::sync::get_repo::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::sync::get_repo::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(bytes) => Ok(bytes),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get the hosting status for a repository, on this server. Expected to be implemented by PDS and Relay.
    pub async fn get_repo_status(
        &self,
        params: crate::com::atproto::sync::get_repo_status::Parameters,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::sync::get_repo_status::Output,
        crate::com::atproto::sync::get_repo_status::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::sync::get_repo_status::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///List blob CIDs for an account, since some repo revision. Does not require auth; implemented by PDS.
    pub async fn list_blobs(
        &self,
        params: crate::com::atproto::sync::list_blobs::Parameters,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::sync::list_blobs::Output,
        crate::com::atproto::sync::list_blobs::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::sync::list_blobs::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Enumerates upstream hosts (eg, PDS or relay instances) that this service consumes from. Implemented by relays.
    pub async fn list_hosts(
        &self,
        params: crate::com::atproto::sync::list_hosts::Parameters,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::sync::list_hosts::Output,
        crate::com::atproto::sync::list_hosts::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::sync::list_hosts::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Enumerates all the DID, rev, and commit CID for all repos hosted by this service. Does not require auth; implemented by PDS and Relay.
    pub async fn list_repos(
        &self,
        params: crate::com::atproto::sync::list_repos::Parameters,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::sync::list_repos::Output,
        crate::com::atproto::sync::list_repos::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::sync::list_repos::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Enumerates all the DIDs which have records with the given collection NSID.
    pub async fn list_repos_by_collection(
        &self,
        params: crate::com::atproto::sync::list_repos_by_collection::Parameters,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::sync::list_repos_by_collection::Output,
        crate::com::atproto::sync::list_repos_by_collection::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::sync::list_repos_by_collection::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Notify a crawling service of a recent update, and that crawling should resume. Intended use is after a gap between repo stream events caused the crawling service to disconnect. Does not require auth; implemented by Relay. DEPRECATED: just use com.atproto.sync.requestCrawl
    pub async fn notify_of_update(
        &self,
        input: crate::com::atproto::sync::notify_of_update::Input,
    ) -> atrium_xrpc::Result<(), crate::com::atproto::sync::notify_of_update::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::sync::notify_of_update::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Request a service to persistently crawl hosted repos. Expected use is new PDS instances declaring their existence to Relays. Does not require auth.
    pub async fn request_crawl(
        &self,
        input: crate::com::atproto::sync::request_crawl::Input,
    ) -> atrium_xrpc::Result<(), crate::com::atproto::sync::request_crawl::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::sync::request_crawl::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
impl<T> com::atproto::temp::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Add a handle to the set of reserved handles.
    pub async fn add_reserved_handle(
        &self,
        input: crate::com::atproto::temp::add_reserved_handle::Input,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::temp::add_reserved_handle::Output,
        crate::com::atproto::temp::add_reserved_handle::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::temp::add_reserved_handle::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Checks whether the provided handle is available. If the handle is not available, available suggestions will be returned. Optional inputs will be used to generate suggestions.
    pub async fn check_handle_availability(
        &self,
        params: crate::com::atproto::temp::check_handle_availability::Parameters,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::temp::check_handle_availability::Output,
        crate::com::atproto::temp::check_handle_availability::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::temp::check_handle_availability::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Check accounts location in signup queue.
    pub async fn check_signup_queue(
        &self,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::temp::check_signup_queue::Output,
        crate::com::atproto::temp::check_signup_queue::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::temp::check_signup_queue::NSID.into(),
                    parameters: None,
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Allows finding the oauth permission scope from a reference
    pub async fn dereference_scope(
        &self,
        params: crate::com::atproto::temp::dereference_scope::Parameters,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::temp::dereference_scope::Output,
        crate::com::atproto::temp::dereference_scope::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::temp::dereference_scope::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///DEPRECATED: use queryLabels or subscribeLabels instead -- Fetch all labels from a labeler created after a certain date.
    pub async fn fetch_labels(
        &self,
        params: crate::com::atproto::temp::fetch_labels::Parameters,
    ) -> atrium_xrpc::Result<
        crate::com::atproto::temp::fetch_labels::Output,
        crate::com::atproto::temp::fetch_labels::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::com::atproto::temp::fetch_labels::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Request a verification code to be sent to the supplied phone number
    pub async fn request_phone_verification(
        &self,
        input: crate::com::atproto::temp::request_phone_verification::Input,
    ) -> atrium_xrpc::Result<
        (),
        crate::com::atproto::temp::request_phone_verification::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::temp::request_phone_verification::NSID
                        .into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Revoke sessions, password, and app passwords associated with account. May be resolved by a password reset.
    pub async fn revoke_account_credentials(
        &self,
        input: crate::com::atproto::temp::revoke_account_credentials::Input,
    ) -> atrium_xrpc::Result<
        (),
        crate::com::atproto::temp::revoke_account_credentials::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::com::atproto::temp::revoke_account_credentials::NSID
                        .into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
impl<T> tools::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            #[cfg(feature = "namespace-toolsozone")]
            ozone: tools::ozone::Service::new(std::sync::Arc::clone(&xrpc)),
            _phantom: core::marker::PhantomData,
        }
    }
}
#[cfg(feature = "namespace-toolsozone")]
impl<T> tools::ozone::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            communication: tools::ozone::communication::Service::new(
                std::sync::Arc::clone(&xrpc),
            ),
            hosting: tools::ozone::hosting::Service::new(std::sync::Arc::clone(&xrpc)),
            moderation: tools::ozone::moderation::Service::new(
                std::sync::Arc::clone(&xrpc),
            ),
            queue: tools::ozone::queue::Service::new(std::sync::Arc::clone(&xrpc)),
            report: tools::ozone::report::Service::new(std::sync::Arc::clone(&xrpc)),
            safelink: tools::ozone::safelink::Service::new(std::sync::Arc::clone(&xrpc)),
            server: tools::ozone::server::Service::new(std::sync::Arc::clone(&xrpc)),
            set: tools::ozone::set::Service::new(std::sync::Arc::clone(&xrpc)),
            setting: tools::ozone::setting::Service::new(std::sync::Arc::clone(&xrpc)),
            signature: tools::ozone::signature::Service::new(
                std::sync::Arc::clone(&xrpc),
            ),
            team: tools::ozone::team::Service::new(std::sync::Arc::clone(&xrpc)),
            verification: tools::ozone::verification::Service::new(
                std::sync::Arc::clone(&xrpc),
            ),
            _phantom: core::marker::PhantomData,
        }
    }
}
#[cfg(feature = "namespace-toolsozone")]
impl<T> tools::ozone::communication::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Administrative action to create a new, re-usable communication (email for now) template.
    pub async fn create_template(
        &self,
        input: crate::tools::ozone::communication::create_template::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::communication::create_template::Output,
        crate::tools::ozone::communication::create_template::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::communication::create_template::NSID
                        .into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Delete a communication template.
    pub async fn delete_template(
        &self,
        input: crate::tools::ozone::communication::delete_template::Input,
    ) -> atrium_xrpc::Result<
        (),
        crate::tools::ozone::communication::delete_template::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::communication::delete_template::NSID
                        .into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get list of all communication templates.
    pub async fn list_templates(
        &self,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::communication::list_templates::Output,
        crate::tools::ozone::communication::list_templates::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::communication::list_templates::NSID
                        .into(),
                    parameters: None,
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Administrative action to update an existing communication template. Allows passing partial fields to patch specific fields only.
    pub async fn update_template(
        &self,
        input: crate::tools::ozone::communication::update_template::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::communication::update_template::Output,
        crate::tools::ozone::communication::update_template::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::communication::update_template::NSID
                        .into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
#[cfg(feature = "namespace-toolsozone")]
impl<T> tools::ozone::hosting::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Get account history, e.g. log of updated email addresses or other identity information.
    pub async fn get_account_history(
        &self,
        params: crate::tools::ozone::hosting::get_account_history::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::hosting::get_account_history::Output,
        crate::tools::ozone::hosting::get_account_history::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::hosting::get_account_history::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
#[cfg(feature = "namespace-toolsozone")]
impl<T> tools::ozone::moderation::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Cancel all pending scheduled moderation actions for specified subjects
    pub async fn cancel_scheduled_actions(
        &self,
        input: crate::tools::ozone::moderation::cancel_scheduled_actions::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::moderation::cancel_scheduled_actions::Output,
        crate::tools::ozone::moderation::cancel_scheduled_actions::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::moderation::cancel_scheduled_actions::NSID
                        .into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Take a moderation action on an actor.
    pub async fn emit_event(
        &self,
        input: crate::tools::ozone::moderation::emit_event::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::moderation::emit_event::Output,
        crate::tools::ozone::moderation::emit_event::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::moderation::emit_event::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get timeline of all available events of an account. This includes moderation events, account history and did history.
    pub async fn get_account_timeline(
        &self,
        params: crate::tools::ozone::moderation::get_account_timeline::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::moderation::get_account_timeline::Output,
        crate::tools::ozone::moderation::get_account_timeline::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::moderation::get_account_timeline::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get details about a moderation event.
    pub async fn get_event(
        &self,
        params: crate::tools::ozone::moderation::get_event::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::moderation::get_event::Output,
        crate::tools::ozone::moderation::get_event::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::moderation::get_event::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get details about a record.
    pub async fn get_record(
        &self,
        params: crate::tools::ozone::moderation::get_record::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::moderation::get_record::Output,
        crate::tools::ozone::moderation::get_record::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::moderation::get_record::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get details about some records.
    pub async fn get_records(
        &self,
        params: crate::tools::ozone::moderation::get_records::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::moderation::get_records::Output,
        crate::tools::ozone::moderation::get_records::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::moderation::get_records::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get details about a repository.
    pub async fn get_repo(
        &self,
        params: crate::tools::ozone::moderation::get_repo::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::moderation::get_repo::Output,
        crate::tools::ozone::moderation::get_repo::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::moderation::get_repo::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get reporter stats for a list of users.
    pub async fn get_reporter_stats(
        &self,
        params: crate::tools::ozone::moderation::get_reporter_stats::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::moderation::get_reporter_stats::Output,
        crate::tools::ozone::moderation::get_reporter_stats::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::moderation::get_reporter_stats::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get details about some repositories.
    pub async fn get_repos(
        &self,
        params: crate::tools::ozone::moderation::get_repos::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::moderation::get_repos::Output,
        crate::tools::ozone::moderation::get_repos::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::moderation::get_repos::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get details about subjects.
    pub async fn get_subjects(
        &self,
        params: crate::tools::ozone::moderation::get_subjects::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::moderation::get_subjects::Output,
        crate::tools::ozone::moderation::get_subjects::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::moderation::get_subjects::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///List scheduled moderation actions with optional filtering
    pub async fn list_scheduled_actions(
        &self,
        input: crate::tools::ozone::moderation::list_scheduled_actions::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::moderation::list_scheduled_actions::Output,
        crate::tools::ozone::moderation::list_scheduled_actions::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::moderation::list_scheduled_actions::NSID
                        .into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///List moderation events related to a subject.
    pub async fn query_events(
        &self,
        params: crate::tools::ozone::moderation::query_events::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::moderation::query_events::Output,
        crate::tools::ozone::moderation::query_events::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::moderation::query_events::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///View moderation statuses of subjects (record or repo).
    pub async fn query_statuses(
        &self,
        params: crate::tools::ozone::moderation::query_statuses::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::moderation::query_statuses::Output,
        crate::tools::ozone::moderation::query_statuses::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::moderation::query_statuses::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Schedule a moderation action to be executed at a future time
    pub async fn schedule_action(
        &self,
        input: crate::tools::ozone::moderation::schedule_action::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::moderation::schedule_action::Output,
        crate::tools::ozone::moderation::schedule_action::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::moderation::schedule_action::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Find repositories based on a search term.
    pub async fn search_repos(
        &self,
        params: crate::tools::ozone::moderation::search_repos::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::moderation::search_repos::Output,
        crate::tools::ozone::moderation::search_repos::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::moderation::search_repos::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
#[cfg(feature = "namespace-toolsozone")]
impl<T> tools::ozone::queue::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Assign a user to a queue.
    pub async fn assign_moderator(
        &self,
        input: crate::tools::ozone::queue::assign_moderator::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::queue::assign_moderator::Output,
        crate::tools::ozone::queue::assign_moderator::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::queue::assign_moderator::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Create a new moderation queue. A queue can have optional matching criteria that ozone's queue router will use to match reports. A queue with no criteria must have reports assigned to it manually via (1) `modTool.meta.queueId` in `tools.ozone.moderation.emitEvent` or (2) `tools.ozone.report.reassignQueue`.
    pub async fn create_queue(
        &self,
        input: crate::tools::ozone::queue::create_queue::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::queue::create_queue::Output,
        crate::tools::ozone::queue::create_queue::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::queue::create_queue::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Delete a moderation queue. Optionally migrate reports to another queue.
    pub async fn delete_queue(
        &self,
        input: crate::tools::ozone::queue::delete_queue::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::queue::delete_queue::Output,
        crate::tools::ozone::queue::delete_queue::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::queue::delete_queue::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get moderator assignments, optionally filtered by active status, queue, or moderator.
    pub async fn get_assignments(
        &self,
        params: crate::tools::ozone::queue::get_assignments::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::queue::get_assignments::Output,
        crate::tools::ozone::queue::get_assignments::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::queue::get_assignments::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///List all configured moderation queues with statistics.
    pub async fn list_queues(
        &self,
        params: crate::tools::ozone::queue::list_queues::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::queue::list_queues::Output,
        crate::tools::ozone::queue::list_queues::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::queue::list_queues::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Route reports within an ID range to matching queues based.
    pub async fn route_reports(
        &self,
        input: crate::tools::ozone::queue::route_reports::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::queue::route_reports::Output,
        crate::tools::ozone::queue::route_reports::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::queue::route_reports::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Remove a user's assignment from a queue.
    pub async fn unassign_moderator(
        &self,
        input: crate::tools::ozone::queue::unassign_moderator::Input,
    ) -> atrium_xrpc::Result<(), crate::tools::ozone::queue::unassign_moderator::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::queue::unassign_moderator::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Update queue properties.
    pub async fn update_queue(
        &self,
        input: crate::tools::ozone::queue::update_queue::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::queue::update_queue::Output,
        crate::tools::ozone::queue::update_queue::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::queue::update_queue::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
#[cfg(feature = "namespace-toolsozone")]
impl<T> tools::ozone::report::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Assign a report to a user. Defaults to the caller. Admins may assign to any moderator.
    pub async fn assign_moderator(
        &self,
        input: crate::tools::ozone::report::assign_moderator::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::report::assign_moderator::Output,
        crate::tools::ozone::report::assign_moderator::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::report::assign_moderator::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Close all reports on a subject matching the given criteria. Reports whose current status does not permit a transition to closed are skipped silently. Intended for automated flows that resolve reports without taking action on the subject.
    pub async fn close_reports(
        &self,
        input: crate::tools::ozone::report::close_reports::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::report::close_reports::Output,
        crate::tools::ozone::report::close_reports::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::report::close_reports::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Register an activity on a report. For state-change activity types, validates the transition and updates report.status atomically.
    pub async fn create_activity(
        &self,
        input: crate::tools::ozone::report::create_activity::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::report::create_activity::Output,
        crate::tools::ozone::report::create_activity::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::report::create_activity::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get assignments for reports.
    pub async fn get_assignments(
        &self,
        params: crate::tools::ozone::report::get_assignments::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::report::get_assignments::Output,
        crate::tools::ozone::report::get_assignments::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::report::get_assignments::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get historical daily report statistics. Returns a paginated list of daily stat snapshots, newest first. Filter by queue, moderator, or report type.
    pub async fn get_historical_stats(
        &self,
        params: crate::tools::ozone::report::get_historical_stats::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::report::get_historical_stats::Output,
        crate::tools::ozone::report::get_historical_stats::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::report::get_historical_stats::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get the most recent report.
    pub async fn get_latest_report(
        &self,
        params: crate::tools::ozone::report::get_latest_report::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::report::get_latest_report::Output,
        crate::tools::ozone::report::get_latest_report::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::report::get_latest_report::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get live report statistics from the past 24 hours. Filter by queue, moderator, or report type. Omit all parameters for aggregate stats.
    pub async fn get_live_stats(
        &self,
        params: crate::tools::ozone::report::get_live_stats::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::report::get_live_stats::Output,
        crate::tools::ozone::report::get_live_stats::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::report::get_live_stats::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get details about a single moderation report by ID.
    pub async fn get_report(
        &self,
        params: crate::tools::ozone::report::get_report::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::report::get_report::Output,
        crate::tools::ozone::report::get_report::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::report::get_report::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///List all activities for a report, sorted most-recent-first.
    pub async fn list_activities(
        &self,
        params: crate::tools::ozone::report::list_activities::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::report::list_activities::Output,
        crate::tools::ozone::report::list_activities::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::report::list_activities::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Query report activities across all reports, ordered by createdAt. Used by downstream pollers; for per-report activity history use listActivities.
    pub async fn query_activities(
        &self,
        params: crate::tools::ozone::report::query_activities::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::report::query_activities::Output,
        crate::tools::ozone::report::query_activities::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::report::query_activities::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///View moderation reports. Reports are individual instances of content being reported, as opposed to subject statuses which aggregate reports at the subject level.
    pub async fn query_reports(
        &self,
        params: crate::tools::ozone::report::query_reports::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::report::query_reports::Output,
        crate::tools::ozone::report::query_reports::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::report::query_reports::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Manually reassign a report to a different queue (or unassign it). Records a queueActivity entry on the report.
    pub async fn reassign_queue(
        &self,
        input: crate::tools::ozone::report::reassign_queue::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::report::reassign_queue::Output,
        crate::tools::ozone::report::reassign_queue::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::report::reassign_queue::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Recompute report statistics for a date range. Useful for backfilling after failures or data corrections.
    pub async fn refresh_stats(
        &self,
        input: crate::tools::ozone::report::refresh_stats::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::report::refresh_stats::Output,
        crate::tools::ozone::report::refresh_stats::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::report::refresh_stats::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Remove report assignment.
    pub async fn unassign_moderator(
        &self,
        input: crate::tools::ozone::report::unassign_moderator::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::report::unassign_moderator::Output,
        crate::tools::ozone::report::unassign_moderator::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::report::unassign_moderator::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
#[cfg(feature = "namespace-toolsozone")]
impl<T> tools::ozone::safelink::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Add a new URL safety rule
    pub async fn add_rule(
        &self,
        input: crate::tools::ozone::safelink::add_rule::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::safelink::add_rule::Output,
        crate::tools::ozone::safelink::add_rule::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::safelink::add_rule::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Query URL safety audit events
    pub async fn query_events(
        &self,
        input: crate::tools::ozone::safelink::query_events::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::safelink::query_events::Output,
        crate::tools::ozone::safelink::query_events::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::safelink::query_events::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Query URL safety rules
    pub async fn query_rules(
        &self,
        input: crate::tools::ozone::safelink::query_rules::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::safelink::query_rules::Output,
        crate::tools::ozone::safelink::query_rules::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::safelink::query_rules::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Remove an existing URL safety rule
    pub async fn remove_rule(
        &self,
        input: crate::tools::ozone::safelink::remove_rule::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::safelink::remove_rule::Output,
        crate::tools::ozone::safelink::remove_rule::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::safelink::remove_rule::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Update an existing URL safety rule
    pub async fn update_rule(
        &self,
        input: crate::tools::ozone::safelink::update_rule::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::safelink::update_rule::Output,
        crate::tools::ozone::safelink::update_rule::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::safelink::update_rule::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
#[cfg(feature = "namespace-toolsozone")]
impl<T> tools::ozone::server::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Get details about ozone's server configuration.
    pub async fn get_config(
        &self,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::server::get_config::Output,
        crate::tools::ozone::server::get_config::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::server::get_config::NSID.into(),
                    parameters: None,
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
#[cfg(feature = "namespace-toolsozone")]
impl<T> tools::ozone::set::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Add values to a specific set. Attempting to add values to a set that does not exist will result in an error.
    pub async fn add_values(
        &self,
        input: crate::tools::ozone::set::add_values::Input,
    ) -> atrium_xrpc::Result<(), crate::tools::ozone::set::add_values::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::set::add_values::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Delete an entire set. Attempting to delete a set that does not exist will result in an error.
    pub async fn delete_set(
        &self,
        input: crate::tools::ozone::set::delete_set::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::set::delete_set::Output,
        crate::tools::ozone::set::delete_set::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::set::delete_set::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Delete values from a specific set. Attempting to delete values that are not in the set will not result in an error
    pub async fn delete_values(
        &self,
        input: crate::tools::ozone::set::delete_values::Input,
    ) -> atrium_xrpc::Result<(), crate::tools::ozone::set::delete_values::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::set::delete_values::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get a specific set and its values
    pub async fn get_values(
        &self,
        params: crate::tools::ozone::set::get_values::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::set::get_values::Output,
        crate::tools::ozone::set::get_values::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::set::get_values::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Query available sets
    pub async fn query_sets(
        &self,
        params: crate::tools::ozone::set::query_sets::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::set::query_sets::Output,
        crate::tools::ozone::set::query_sets::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::set::query_sets::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Create or update set metadata
    pub async fn upsert_set(
        &self,
        input: crate::tools::ozone::set::upsert_set::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::set::upsert_set::Output,
        crate::tools::ozone::set::upsert_set::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::set::upsert_set::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
#[cfg(feature = "namespace-toolsozone")]
impl<T> tools::ozone::setting::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///List settings with optional filtering
    pub async fn list_options(
        &self,
        params: crate::tools::ozone::setting::list_options::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::setting::list_options::Output,
        crate::tools::ozone::setting::list_options::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::setting::list_options::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Delete settings by key
    pub async fn remove_options(
        &self,
        input: crate::tools::ozone::setting::remove_options::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::setting::remove_options::Output,
        crate::tools::ozone::setting::remove_options::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::setting::remove_options::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Create or update setting option
    pub async fn upsert_option(
        &self,
        input: crate::tools::ozone::setting::upsert_option::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::setting::upsert_option::Output,
        crate::tools::ozone::setting::upsert_option::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::setting::upsert_option::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
#[cfg(feature = "namespace-toolsozone")]
impl<T> tools::ozone::signature::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Find all correlated threat signatures between 2 or more accounts.
    pub async fn find_correlation(
        &self,
        params: crate::tools::ozone::signature::find_correlation::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::signature::find_correlation::Output,
        crate::tools::ozone::signature::find_correlation::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::signature::find_correlation::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Get accounts that share some matching threat signatures with the root account.
    pub async fn find_related_accounts(
        &self,
        params: crate::tools::ozone::signature::find_related_accounts::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::signature::find_related_accounts::Output,
        crate::tools::ozone::signature::find_related_accounts::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::signature::find_related_accounts::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Search for accounts that match one or more threat signature values.
    pub async fn search_accounts(
        &self,
        params: crate::tools::ozone::signature::search_accounts::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::signature::search_accounts::Output,
        crate::tools::ozone::signature::search_accounts::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::signature::search_accounts::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
#[cfg(feature = "namespace-toolsozone")]
impl<T> tools::ozone::team::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Add a member to the ozone team. Requires admin role.
    pub async fn add_member(
        &self,
        input: crate::tools::ozone::team::add_member::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::team::add_member::Output,
        crate::tools::ozone::team::add_member::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::team::add_member::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Delete a member from ozone team. Requires admin role.
    pub async fn delete_member(
        &self,
        input: crate::tools::ozone::team::delete_member::Input,
    ) -> atrium_xrpc::Result<(), crate::tools::ozone::team::delete_member::Error> {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                (),
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::team::delete_member::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///List all members with access to the ozone service.
    pub async fn list_members(
        &self,
        params: crate::tools::ozone::team::list_members::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::team::list_members::Output,
        crate::tools::ozone::team::list_members::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::team::list_members::NSID.into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Update a member in the ozone service. Requires admin role.
    pub async fn update_member(
        &self,
        input: crate::tools::ozone::team::update_member::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::team::update_member::Output,
        crate::tools::ozone::team::update_member::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::team::update_member::NSID.into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}
#[cfg(feature = "namespace-toolsozone")]
impl<T> tools::ozone::verification::Service<T>
where
    T: atrium_xrpc::XrpcClient + Send + Sync,
{
    #[allow(unused_variables)]
    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
        Self {
            xrpc,
            _phantom: core::marker::PhantomData,
        }
    }
    ///Grant verifications to multiple subjects. Allows batch processing of up to 100 verifications at once.
    pub async fn grant_verifications(
        &self,
        input: crate::tools::ozone::verification::grant_verifications::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::verification::grant_verifications::Output,
        crate::tools::ozone::verification::grant_verifications::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::verification::grant_verifications::NSID
                        .into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///List verifications
    pub async fn list_verifications(
        &self,
        params: crate::tools::ozone::verification::list_verifications::Parameters,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::verification::list_verifications::Output,
        crate::tools::ozone::verification::list_verifications::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                _,
                (),
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::GET,
                    nsid: crate::tools::ozone::verification::list_verifications::NSID
                        .into(),
                    parameters: Some(params),
                    input: None,
                    encoding: None,
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
    ///Revoke previously granted verifications in batches of up to 100.
    pub async fn revoke_verifications(
        &self,
        input: crate::tools::ozone::verification::revoke_verifications::Input,
    ) -> atrium_xrpc::Result<
        crate::tools::ozone::verification::revoke_verifications::Output,
        crate::tools::ozone::verification::revoke_verifications::Error,
    > {
        let response = self
            .xrpc
            .send_xrpc::<
                (),
                _,
                _,
                _,
            >(
                &atrium_xrpc::XrpcRequest {
                    method: http::Method::POST,
                    nsid: crate::tools::ozone::verification::revoke_verifications::NSID
                        .into(),
                    parameters: None,
                    input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
                    encoding: Some(String::from("application/json")),
                },
            )
            .await?;
        match response {
            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
        }
    }
}