xmtp_proto/gen/

xmtp.mls.api.v1.rs

// This file is @generated by prost-build.
/// Full representation of a welcome message
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WelcomeMessage {
    #[prost(oneof = "welcome_message::Version", tags = "1, 2")]
    pub version: ::core::option::Option<welcome_message::Version>,
}
/// Nested message and enum types in `WelcomeMessage`.
pub mod welcome_message {
    /// Version 1 of the WelcomeMessage format
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct V1 {
        #[prost(uint64, tag = "1")]
        pub id: u64,
        #[prost(uint64, tag = "2")]
        pub created_ns: u64,
        #[prost(bytes = "vec", tag = "3")]
        pub installation_key: ::prost::alloc::vec::Vec<u8>,
        #[prost(bytes = "vec", tag = "4")]
        pub data: ::prost::alloc::vec::Vec<u8>,
        #[prost(bytes = "vec", tag = "5")]
        pub hpke_public_key: ::prost::alloc::vec::Vec<u8>,
        #[prost(
            enumeration = "super::super::super::message_contents::WelcomeWrapperAlgorithm",
            tag = "6"
        )]
        pub wrapper_algorithm: i32,
        #[prost(bytes = "vec", tag = "7")]
        pub welcome_metadata: ::prost::alloc::vec::Vec<u8>,
    }
    impl ::prost::Name for V1 {
        const NAME: &'static str = "V1";
        const PACKAGE: &'static str = "xmtp.mls.api.v1";
        fn full_name() -> ::prost::alloc::string::String {
            "xmtp.mls.api.v1.WelcomeMessage.V1".into()
        }
        fn type_url() -> ::prost::alloc::string::String {
            "/xmtp.mls.api.v1.WelcomeMessage.V1".into()
        }
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct WelcomePointer {
        #[prost(uint64, tag = "1")]
        pub id: u64,
        #[prost(uint64, tag = "2")]
        pub created_ns: u64,
        /// The topic of the welcome message (generally the installation id)
        #[prost(bytes = "vec", tag = "3")]
        pub installation_key: ::prost::alloc::vec::Vec<u8>,
        /// A WelcomePointer encrypted using the algorithm specified by
        /// wrapper_algorithm
        #[prost(bytes = "vec", tag = "4")]
        pub welcome_pointer: ::prost::alloc::vec::Vec<u8>,
        /// The public key used to encrypt the welcome pointer
        #[prost(bytes = "vec", tag = "5")]
        pub hpke_public_key: ::prost::alloc::vec::Vec<u8>,
        /// The algorithm used to encrypt the welcome pointer
        #[prost(
            enumeration = "super::super::super::message_contents::WelcomePointerWrapperAlgorithm",
            tag = "6"
        )]
        pub wrapper_algorithm: i32,
    }
    impl ::prost::Name for WelcomePointer {
        const NAME: &'static str = "WelcomePointer";
        const PACKAGE: &'static str = "xmtp.mls.api.v1";
        fn full_name() -> ::prost::alloc::string::String {
            "xmtp.mls.api.v1.WelcomeMessage.WelcomePointer".into()
        }
        fn type_url() -> ::prost::alloc::string::String {
            "/xmtp.mls.api.v1.WelcomeMessage.WelcomePointer".into()
        }
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Version {
        #[prost(message, tag = "1")]
        V1(V1),
        #[prost(message, tag = "2")]
        WelcomePointer(WelcomePointer),
    }
}
impl ::prost::Name for WelcomeMessage {
    const NAME: &'static str = "WelcomeMessage";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.WelcomeMessage".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.WelcomeMessage".into()
    }
}
/// Input type for a welcome message
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WelcomeMessageInput {
    #[prost(oneof = "welcome_message_input::Version", tags = "1, 2")]
    pub version: ::core::option::Option<welcome_message_input::Version>,
}
/// Nested message and enum types in `WelcomeMessageInput`.
pub mod welcome_message_input {
    /// Version 1 of the WelcomeMessageInput format, if used as the pointee of a
    /// WelcomePointer then the hpke_public_key will be unset, and the
    /// wrapper_algorithm will be WELCOME_WRAPPER_ALGORITHM_SYMMETRIC_KEY
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct V1 {
        /// The topic of the welcome message (generally the installation id)
        #[prost(bytes = "vec", tag = "1")]
        pub installation_key: ::prost::alloc::vec::Vec<u8>,
        /// An encrypted mls `Welcome` struct
        #[prost(bytes = "vec", tag = "2")]
        pub data: ::prost::alloc::vec::Vec<u8>,
        /// The public key of the welcome message
        #[prost(bytes = "vec", tag = "3")]
        pub hpke_public_key: ::prost::alloc::vec::Vec<u8>,
        /// The algorithm used to encrypt the welcome message
        #[prost(
            enumeration = "super::super::super::message_contents::WelcomeWrapperAlgorithm",
            tag = "4"
        )]
        pub wrapper_algorithm: i32,
        /// The metadata of the welcome message
        #[prost(bytes = "vec", tag = "7")]
        pub welcome_metadata: ::prost::alloc::vec::Vec<u8>,
    }
    impl ::prost::Name for V1 {
        const NAME: &'static str = "V1";
        const PACKAGE: &'static str = "xmtp.mls.api.v1";
        fn full_name() -> ::prost::alloc::string::String {
            "xmtp.mls.api.v1.WelcomeMessageInput.V1".into()
        }
        fn type_url() -> ::prost::alloc::string::String {
            "/xmtp.mls.api.v1.WelcomeMessageInput.V1".into()
        }
    }
    /// Version 2 of the WelcomeMessageInput format which uses a WelcomePointer
    /// to point to the welcome message for several installations at once
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct WelcomePointer {
        /// The topic of the welcome message (generally the installation id)
        #[prost(bytes = "vec", tag = "1")]
        pub installation_key: ::prost::alloc::vec::Vec<u8>,
        /// A WelcomePointer encrypted using the wrapper_algorithm
        #[prost(bytes = "vec", tag = "2")]
        pub welcome_pointer: ::prost::alloc::vec::Vec<u8>,
        /// The public key used to encrypt the welcome pointer
        #[prost(bytes = "vec", tag = "3")]
        pub hpke_public_key: ::prost::alloc::vec::Vec<u8>,
        /// The algorithm used to encrypt the welcome pointer
        #[prost(
            enumeration = "super::super::super::message_contents::WelcomePointerWrapperAlgorithm",
            tag = "4"
        )]
        pub wrapper_algorithm: i32,
    }
    impl ::prost::Name for WelcomePointer {
        const NAME: &'static str = "WelcomePointer";
        const PACKAGE: &'static str = "xmtp.mls.api.v1";
        fn full_name() -> ::prost::alloc::string::String {
            "xmtp.mls.api.v1.WelcomeMessageInput.WelcomePointer".into()
        }
        fn type_url() -> ::prost::alloc::string::String {
            "/xmtp.mls.api.v1.WelcomeMessageInput.WelcomePointer".into()
        }
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Version {
        #[prost(message, tag = "1")]
        V1(V1),
        #[prost(message, tag = "2")]
        WelcomePointer(WelcomePointer),
    }
}
impl ::prost::Name for WelcomeMessageInput {
    const NAME: &'static str = "WelcomeMessageInput";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.WelcomeMessageInput".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.WelcomeMessageInput".into()
    }
}
/// This field is encrypted along with the `data` field on the welcome message.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WelcomeMetadata {
    #[prost(uint64, tag = "1")]
    pub message_cursor: u64,
}
impl ::prost::Name for WelcomeMetadata {
    const NAME: &'static str = "WelcomeMetadata";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.WelcomeMetadata".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.WelcomeMetadata".into()
    }
}
/// Full representation of a group message
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GroupMessage {
    #[prost(oneof = "group_message::Version", tags = "1")]
    pub version: ::core::option::Option<group_message::Version>,
}
/// Nested message and enum types in `GroupMessage`.
pub mod group_message {
    /// Version 1 of the GroupMessage format
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct V1 {
        #[prost(uint64, tag = "1")]
        pub id: u64,
        #[prost(uint64, tag = "2")]
        pub created_ns: u64,
        #[prost(bytes = "vec", tag = "3")]
        pub group_id: ::prost::alloc::vec::Vec<u8>,
        #[prost(bytes = "vec", tag = "4")]
        pub data: ::prost::alloc::vec::Vec<u8>,
        #[prost(bytes = "vec", tag = "5")]
        pub sender_hmac: ::prost::alloc::vec::Vec<u8>,
        #[prost(bool, tag = "6")]
        pub should_push: bool,
        #[prost(bool, tag = "7")]
        pub is_commit: bool,
    }
    impl ::prost::Name for V1 {
        const NAME: &'static str = "V1";
        const PACKAGE: &'static str = "xmtp.mls.api.v1";
        fn full_name() -> ::prost::alloc::string::String {
            "xmtp.mls.api.v1.GroupMessage.V1".into()
        }
        fn type_url() -> ::prost::alloc::string::String {
            "/xmtp.mls.api.v1.GroupMessage.V1".into()
        }
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Version {
        #[prost(message, tag = "1")]
        V1(V1),
    }
}
impl ::prost::Name for GroupMessage {
    const NAME: &'static str = "GroupMessage";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.GroupMessage".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.GroupMessage".into()
    }
}
/// Input type for a group message
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GroupMessageInput {
    #[prost(oneof = "group_message_input::Version", tags = "1")]
    pub version: ::core::option::Option<group_message_input::Version>,
}
/// Nested message and enum types in `GroupMessageInput`.
pub mod group_message_input {
    /// Version 1 of the GroupMessageInput payload format
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct V1 {
        /// Serialized MlsProtocolMessage
        #[prost(bytes = "vec", tag = "1")]
        pub data: ::prost::alloc::vec::Vec<u8>,
        #[prost(bytes = "vec", tag = "2")]
        pub sender_hmac: ::prost::alloc::vec::Vec<u8>,
        #[prost(bool, tag = "3")]
        pub should_push: bool,
    }
    impl ::prost::Name for V1 {
        const NAME: &'static str = "V1";
        const PACKAGE: &'static str = "xmtp.mls.api.v1";
        fn full_name() -> ::prost::alloc::string::String {
            "xmtp.mls.api.v1.GroupMessageInput.V1".into()
        }
        fn type_url() -> ::prost::alloc::string::String {
            "/xmtp.mls.api.v1.GroupMessageInput.V1".into()
        }
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Version {
        #[prost(message, tag = "1")]
        V1(V1),
    }
}
impl ::prost::Name for GroupMessageInput {
    const NAME: &'static str = "GroupMessageInput";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.GroupMessageInput".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.GroupMessageInput".into()
    }
}
/// Send a batch of MLS messages
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SendGroupMessagesRequest {
    #[prost(message, repeated, tag = "1")]
    pub messages: ::prost::alloc::vec::Vec<GroupMessageInput>,
}
impl ::prost::Name for SendGroupMessagesRequest {
    const NAME: &'static str = "SendGroupMessagesRequest";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.SendGroupMessagesRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.SendGroupMessagesRequest".into()
    }
}
/// Send a batch of welcome messages
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SendWelcomeMessagesRequest {
    #[prost(message, repeated, tag = "1")]
    pub messages: ::prost::alloc::vec::Vec<WelcomeMessageInput>,
}
impl ::prost::Name for SendWelcomeMessagesRequest {
    const NAME: &'static str = "SendWelcomeMessagesRequest";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.SendWelcomeMessagesRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.SendWelcomeMessagesRequest".into()
    }
}
/// A wrapper around the Key Package bytes
///
/// This would be a serialized MLS key package that the node would
/// parse, validate, and then store.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct KeyPackageUpload {
    /// The owner's wallet address would be extracted from the identity
    /// credential in the key package, and all signatures would be validated.
    #[prost(bytes = "vec", tag = "1")]
    pub key_package_tls_serialized: ::prost::alloc::vec::Vec<u8>,
}
impl ::prost::Name for KeyPackageUpload {
    const NAME: &'static str = "KeyPackageUpload";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.KeyPackageUpload".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.KeyPackageUpload".into()
    }
}
/// Register a new installation
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RegisterInstallationRequest {
    /// The Key Package contains all information needed to register an installation
    #[prost(message, optional, tag = "1")]
    pub key_package: ::core::option::Option<KeyPackageUpload>,
    #[prost(bool, tag = "2")]
    pub is_inbox_id_credential: bool,
}
impl ::prost::Name for RegisterInstallationRequest {
    const NAME: &'static str = "RegisterInstallationRequest";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.RegisterInstallationRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.RegisterInstallationRequest".into()
    }
}
/// The response to a RegisterInstallationRequest
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RegisterInstallationResponse {
    #[prost(bytes = "vec", tag = "1")]
    pub installation_key: ::prost::alloc::vec::Vec<u8>,
}
impl ::prost::Name for RegisterInstallationResponse {
    const NAME: &'static str = "RegisterInstallationResponse";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.RegisterInstallationResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.RegisterInstallationResponse".into()
    }
}
/// Upload a new key packages
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UploadKeyPackageRequest {
    /// An individual key package upload request
    #[prost(message, optional, tag = "1")]
    pub key_package: ::core::option::Option<KeyPackageUpload>,
    #[prost(bool, tag = "2")]
    pub is_inbox_id_credential: bool,
}
impl ::prost::Name for UploadKeyPackageRequest {
    const NAME: &'static str = "UploadKeyPackageRequest";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.UploadKeyPackageRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.UploadKeyPackageRequest".into()
    }
}
/// Fetch one or more key packages
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FetchKeyPackagesRequest {
    /// The caller can provide an array of installation keys, and the API
    /// will return one key package for each installation associated with each
    /// installation key
    #[prost(bytes = "vec", repeated, tag = "1")]
    pub installation_keys: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
}
impl ::prost::Name for FetchKeyPackagesRequest {
    const NAME: &'static str = "FetchKeyPackagesRequest";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.FetchKeyPackagesRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.FetchKeyPackagesRequest".into()
    }
}
/// The response to a FetchKeyPackagesRequest
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FetchKeyPackagesResponse {
    /// Returns one key package per installation in the original order of the
    /// request. If any installations are missing key packages, an empty entry is
    /// left in their respective spots in the array.
    #[prost(message, repeated, tag = "1")]
    pub key_packages: ::prost::alloc::vec::Vec<fetch_key_packages_response::KeyPackage>,
}
/// Nested message and enum types in `FetchKeyPackagesResponse`.
pub mod fetch_key_packages_response {
    /// An individual key package
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct KeyPackage {
        #[prost(bytes = "vec", tag = "1")]
        pub key_package_tls_serialized: ::prost::alloc::vec::Vec<u8>,
    }
    impl ::prost::Name for KeyPackage {
        const NAME: &'static str = "KeyPackage";
        const PACKAGE: &'static str = "xmtp.mls.api.v1";
        fn full_name() -> ::prost::alloc::string::String {
            "xmtp.mls.api.v1.FetchKeyPackagesResponse.KeyPackage".into()
        }
        fn type_url() -> ::prost::alloc::string::String {
            "/xmtp.mls.api.v1.FetchKeyPackagesResponse.KeyPackage".into()
        }
    }
}
impl ::prost::Name for FetchKeyPackagesResponse {
    const NAME: &'static str = "FetchKeyPackagesResponse";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.FetchKeyPackagesResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.FetchKeyPackagesResponse".into()
    }
}
/// Revoke an installation
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RevokeInstallationRequest {
    #[prost(bytes = "vec", tag = "1")]
    pub installation_key: ::prost::alloc::vec::Vec<u8>,
    /// All revocations must be validated with a wallet signature over the
    /// installation_id being revoked (and some sort of standard prologue)
    #[prost(message, optional, tag = "2")]
    pub wallet_signature: ::core::option::Option<
        super::super::super::message_contents::Signature,
    >,
}
impl ::prost::Name for RevokeInstallationRequest {
    const NAME: &'static str = "RevokeInstallationRequest";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.RevokeInstallationRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.RevokeInstallationRequest".into()
    }
}
/// Get all updates for an identity since the specified time
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetIdentityUpdatesRequest {
    #[prost(string, repeated, tag = "1")]
    pub account_addresses: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(uint64, tag = "2")]
    pub start_time_ns: u64,
}
impl ::prost::Name for GetIdentityUpdatesRequest {
    const NAME: &'static str = "GetIdentityUpdatesRequest";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.GetIdentityUpdatesRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.GetIdentityUpdatesRequest".into()
    }
}
/// Used to get any new or revoked installations for a list of wallet addresses
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetIdentityUpdatesResponse {
    /// A list of updates (or empty objects if no changes) in the original order
    /// of the request
    #[prost(message, repeated, tag = "1")]
    pub updates: ::prost::alloc::vec::Vec<get_identity_updates_response::WalletUpdates>,
}
/// Nested message and enum types in `GetIdentityUpdatesResponse`.
pub mod get_identity_updates_response {
    /// A new installation key was seen for the first time by the nodes
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct NewInstallationUpdate {
        #[prost(bytes = "vec", tag = "1")]
        pub installation_key: ::prost::alloc::vec::Vec<u8>,
        #[prost(bytes = "vec", tag = "2")]
        pub credential_identity: ::prost::alloc::vec::Vec<u8>,
    }
    impl ::prost::Name for NewInstallationUpdate {
        const NAME: &'static str = "NewInstallationUpdate";
        const PACKAGE: &'static str = "xmtp.mls.api.v1";
        fn full_name() -> ::prost::alloc::string::String {
            "xmtp.mls.api.v1.GetIdentityUpdatesResponse.NewInstallationUpdate".into()
        }
        fn type_url() -> ::prost::alloc::string::String {
            "/xmtp.mls.api.v1.GetIdentityUpdatesResponse.NewInstallationUpdate".into()
        }
    }
    /// An installation was revoked
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct RevokedInstallationUpdate {
        #[prost(bytes = "vec", tag = "1")]
        pub installation_key: ::prost::alloc::vec::Vec<u8>,
    }
    impl ::prost::Name for RevokedInstallationUpdate {
        const NAME: &'static str = "RevokedInstallationUpdate";
        const PACKAGE: &'static str = "xmtp.mls.api.v1";
        fn full_name() -> ::prost::alloc::string::String {
            "xmtp.mls.api.v1.GetIdentityUpdatesResponse.RevokedInstallationUpdate".into()
        }
        fn type_url() -> ::prost::alloc::string::String {
            "/xmtp.mls.api.v1.GetIdentityUpdatesResponse.RevokedInstallationUpdate"
                .into()
        }
    }
    /// A wrapper for any update to the wallet
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Update {
        #[prost(uint64, tag = "1")]
        pub timestamp_ns: u64,
        #[prost(oneof = "update::Kind", tags = "2, 3")]
        pub kind: ::core::option::Option<update::Kind>,
    }
    /// Nested message and enum types in `Update`.
    pub mod update {
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
        pub enum Kind {
            #[prost(message, tag = "2")]
            NewInstallation(super::NewInstallationUpdate),
            #[prost(message, tag = "3")]
            RevokedInstallation(super::RevokedInstallationUpdate),
        }
    }
    impl ::prost::Name for Update {
        const NAME: &'static str = "Update";
        const PACKAGE: &'static str = "xmtp.mls.api.v1";
        fn full_name() -> ::prost::alloc::string::String {
            "xmtp.mls.api.v1.GetIdentityUpdatesResponse.Update".into()
        }
        fn type_url() -> ::prost::alloc::string::String {
            "/xmtp.mls.api.v1.GetIdentityUpdatesResponse.Update".into()
        }
    }
    /// A wrapper for the updates for a single wallet
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct WalletUpdates {
        #[prost(message, repeated, tag = "1")]
        pub updates: ::prost::alloc::vec::Vec<Update>,
    }
    impl ::prost::Name for WalletUpdates {
        const NAME: &'static str = "WalletUpdates";
        const PACKAGE: &'static str = "xmtp.mls.api.v1";
        fn full_name() -> ::prost::alloc::string::String {
            "xmtp.mls.api.v1.GetIdentityUpdatesResponse.WalletUpdates".into()
        }
        fn type_url() -> ::prost::alloc::string::String {
            "/xmtp.mls.api.v1.GetIdentityUpdatesResponse.WalletUpdates".into()
        }
    }
}
impl ::prost::Name for GetIdentityUpdatesResponse {
    const NAME: &'static str = "GetIdentityUpdatesResponse";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.GetIdentityUpdatesResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.GetIdentityUpdatesResponse".into()
    }
}
/// Pagination config for queries
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PagingInfo {
    #[prost(enumeration = "SortDirection", tag = "1")]
    pub direction: i32,
    #[prost(uint32, tag = "2")]
    pub limit: u32,
    #[prost(uint64, tag = "3")]
    pub id_cursor: u64,
}
impl ::prost::Name for PagingInfo {
    const NAME: &'static str = "PagingInfo";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.PagingInfo".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.PagingInfo".into()
    }
}
/// Request for group message queries
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct QueryGroupMessagesRequest {
    #[prost(bytes = "vec", tag = "1")]
    pub group_id: ::prost::alloc::vec::Vec<u8>,
    #[prost(message, optional, tag = "2")]
    pub paging_info: ::core::option::Option<PagingInfo>,
}
impl ::prost::Name for QueryGroupMessagesRequest {
    const NAME: &'static str = "QueryGroupMessagesRequest";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.QueryGroupMessagesRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.QueryGroupMessagesRequest".into()
    }
}
/// Response for group message queries
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryGroupMessagesResponse {
    #[prost(message, repeated, tag = "1")]
    pub messages: ::prost::alloc::vec::Vec<GroupMessage>,
    #[prost(message, optional, tag = "2")]
    pub paging_info: ::core::option::Option<PagingInfo>,
}
impl ::prost::Name for QueryGroupMessagesResponse {
    const NAME: &'static str = "QueryGroupMessagesResponse";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.QueryGroupMessagesResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.QueryGroupMessagesResponse".into()
    }
}
/// Request for welcome message queries
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct QueryWelcomeMessagesRequest {
    #[prost(bytes = "vec", tag = "1")]
    pub installation_key: ::prost::alloc::vec::Vec<u8>,
    #[prost(message, optional, tag = "2")]
    pub paging_info: ::core::option::Option<PagingInfo>,
}
impl ::prost::Name for QueryWelcomeMessagesRequest {
    const NAME: &'static str = "QueryWelcomeMessagesRequest";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.QueryWelcomeMessagesRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.QueryWelcomeMessagesRequest".into()
    }
}
/// Response for welcome message queries
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryWelcomeMessagesResponse {
    #[prost(message, repeated, tag = "1")]
    pub messages: ::prost::alloc::vec::Vec<WelcomeMessage>,
    #[prost(message, optional, tag = "2")]
    pub paging_info: ::core::option::Option<PagingInfo>,
}
impl ::prost::Name for QueryWelcomeMessagesResponse {
    const NAME: &'static str = "QueryWelcomeMessagesResponse";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.QueryWelcomeMessagesResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.QueryWelcomeMessagesResponse".into()
    }
}
/// Request for subscribing to group messages
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SubscribeGroupMessagesRequest {
    #[prost(message, repeated, tag = "1")]
    pub filters: ::prost::alloc::vec::Vec<subscribe_group_messages_request::Filter>,
}
/// Nested message and enum types in `SubscribeGroupMessagesRequest`.
pub mod subscribe_group_messages_request {
    /// Subscription filter
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Filter {
        #[prost(bytes = "vec", tag = "1")]
        pub group_id: ::prost::alloc::vec::Vec<u8>,
        #[prost(uint64, tag = "2")]
        pub id_cursor: u64,
    }
    impl ::prost::Name for Filter {
        const NAME: &'static str = "Filter";
        const PACKAGE: &'static str = "xmtp.mls.api.v1";
        fn full_name() -> ::prost::alloc::string::String {
            "xmtp.mls.api.v1.SubscribeGroupMessagesRequest.Filter".into()
        }
        fn type_url() -> ::prost::alloc::string::String {
            "/xmtp.mls.api.v1.SubscribeGroupMessagesRequest.Filter".into()
        }
    }
}
impl ::prost::Name for SubscribeGroupMessagesRequest {
    const NAME: &'static str = "SubscribeGroupMessagesRequest";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.SubscribeGroupMessagesRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.SubscribeGroupMessagesRequest".into()
    }
}
/// Request for subscribing to welcome messages
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SubscribeWelcomeMessagesRequest {
    #[prost(message, repeated, tag = "1")]
    pub filters: ::prost::alloc::vec::Vec<subscribe_welcome_messages_request::Filter>,
}
/// Nested message and enum types in `SubscribeWelcomeMessagesRequest`.
pub mod subscribe_welcome_messages_request {
    /// Subscription filter
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Filter {
        #[prost(bytes = "vec", tag = "1")]
        pub installation_key: ::prost::alloc::vec::Vec<u8>,
        #[prost(uint64, tag = "2")]
        pub id_cursor: u64,
    }
    impl ::prost::Name for Filter {
        const NAME: &'static str = "Filter";
        const PACKAGE: &'static str = "xmtp.mls.api.v1";
        fn full_name() -> ::prost::alloc::string::String {
            "xmtp.mls.api.v1.SubscribeWelcomeMessagesRequest.Filter".into()
        }
        fn type_url() -> ::prost::alloc::string::String {
            "/xmtp.mls.api.v1.SubscribeWelcomeMessagesRequest.Filter".into()
        }
    }
}
impl ::prost::Name for SubscribeWelcomeMessagesRequest {
    const NAME: &'static str = "SubscribeWelcomeMessagesRequest";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.SubscribeWelcomeMessagesRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.SubscribeWelcomeMessagesRequest".into()
    }
}
/// Client -> server. Sent one or more times over the life of the stream.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SubscribeRequest {
    #[prost(oneof = "subscribe_request::Version", tags = "1")]
    pub version: ::core::option::Option<subscribe_request::Version>,
}
/// Nested message and enum types in `SubscribeRequest`.
pub mod subscribe_request {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct V1 {
        /// Each frame is exactly one of: a mutation, a Ping, or a Pong.
        #[prost(oneof = "v1::Request", tags = "1, 2, 3")]
        pub request: ::core::option::Option<v1::Request>,
    }
    /// Nested message and enum types in `V1`.
    pub mod v1 {
        /// Add and/or remove subscriptions in place (applied atomically per frame).
        /// Topics use the kind-prefixed binary representation shared with the
        /// decentralized backend (XIP-49 §3.3.2): the first byte is the topic kind,
        /// the remainder is the identifier. This RPC initially serves
        /// TOPIC_KIND_GROUP_MESSAGES_V1 (0x00, identifier = group_id) and
        /// TOPIC_KIND_WELCOME_MESSAGES_V1 (0x01, identifier = installation_key);
        /// a topic whose kind the node does not serve fails the stream with
        /// INVALID_ARGUMENT. Future kinds (key packages, identity updates) are
        /// adopted via the capabilities advertised on Started.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct Mutate {
            /// begin delivering these topics
            #[prost(message, repeated, tag = "1")]
            pub adds: ::prost::alloc::vec::Vec<mutate::Subscription>,
            /// topics to stop delivering
            #[prost(bytes = "vec", repeated, tag = "2")]
            pub removes: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
            /// Catch this Mutate's adds up to the live edge — history, TopicsLive
            /// markers, and the wave's CatchupComplete — but do NOT register them
            /// for live delivery. The markers then mean "you have everything as of
            /// now". Combined with half-closing the request stream, this is the
            /// bounded catch-up ("sync") mode: the server finishes the wave and then
            /// closes the stream itself. Removals in the Mutate are unaffected.
            #[prost(bool, tag = "3")]
            pub history_only: bool,
            /// Client-chosen correlation id, echoed on this wave's CatchupComplete
            /// so completions are attributable when waves overlap. SHOULD be unique
            /// per stream; 0 = no correlation requested (still echoed as 0).
            #[prost(uint64, tag = "4")]
            pub mutate_id: u64,
        }
        /// Nested message and enum types in `Mutate`.
        pub mod mutate {
            /// A topic to subscribe, with the cursor to resume from.
            #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
            pub struct Subscription {
                #[prost(bytes = "vec", tag = "1")]
                pub topic: ::prost::alloc::vec::Vec<u8>,
                /// Deliver ids greater than this; 0 = from the beginning. For a newly
                /// joined group, a client SHOULD seed this from the welcome's encrypted
                /// WelcomeMetadata.message_cursor so a new membership does not refetch
                /// pre-join history it cannot decrypt; for a new installation's welcome
                /// topic, 0 is how pending welcomes are collected.
                #[prost(uint64, tag = "2")]
                pub id_cursor: u64,
            }
            impl ::prost::Name for Subscription {
                const NAME: &'static str = "Subscription";
                const PACKAGE: &'static str = "xmtp.mls.api.v1";
                fn full_name() -> ::prost::alloc::string::String {
                    "xmtp.mls.api.v1.SubscribeRequest.V1.Mutate.Subscription".into()
                }
                fn type_url() -> ::prost::alloc::string::String {
                    "/xmtp.mls.api.v1.SubscribeRequest.V1.Mutate.Subscription".into()
                }
            }
        }
        impl ::prost::Name for Mutate {
            const NAME: &'static str = "Mutate";
            const PACKAGE: &'static str = "xmtp.mls.api.v1";
            fn full_name() -> ::prost::alloc::string::String {
                "xmtp.mls.api.v1.SubscribeRequest.V1.Mutate".into()
            }
            fn type_url() -> ::prost::alloc::string::String {
                "/xmtp.mls.api.v1.SubscribeRequest.V1.Mutate".into()
            }
        }
        /// Each frame is exactly one of: a mutation, a Ping, or a Pong.
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Request {
            #[prost(message, tag = "1")]
            Mutate(Mutate),
            /// liveness challenge (e.g. probe the link after resuming)
            #[prost(message, tag = "2")]
            Ping(super::super::Ping),
            /// answer to a server Ping
            #[prost(message, tag = "3")]
            Pong(super::super::Pong),
        }
    }
    impl ::prost::Name for V1 {
        const NAME: &'static str = "V1";
        const PACKAGE: &'static str = "xmtp.mls.api.v1";
        fn full_name() -> ::prost::alloc::string::String {
            "xmtp.mls.api.v1.SubscribeRequest.V1".into()
        }
        fn type_url() -> ::prost::alloc::string::String {
            "/xmtp.mls.api.v1.SubscribeRequest.V1".into()
        }
    }
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Version {
        #[prost(message, tag = "1")]
        V1(V1),
    }
}
impl ::prost::Name for SubscribeRequest {
    const NAME: &'static str = "SubscribeRequest";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.SubscribeRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.SubscribeRequest".into()
    }
}
/// Server -> client.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SubscribeResponse {
    #[prost(oneof = "subscribe_response::Version", tags = "1")]
    pub version: ::core::option::Option<subscribe_response::Version>,
}
/// Nested message and enum types in `SubscribeResponse`.
pub mod subscribe_response {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct V1 {
        #[prost(oneof = "v1::Response", tags = "1, 2, 3, 4, 5, 6")]
        pub response: ::core::option::Option<v1::Response>,
    }
    /// Nested message and enum types in `V1`.
    pub mod v1 {
        /// A batch of new messages; group and welcome messages share the stream,
        /// depending on which subscriptions are active.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct Messages {
            #[prost(message, repeated, tag = "1")]
            pub group_messages: ::prost::alloc::vec::Vec<super::super::GroupMessage>,
            #[prost(message, repeated, tag = "2")]
            pub welcome_messages: ::prost::alloc::vec::Vec<super::super::WelcomeMessage>,
        }
        impl ::prost::Name for Messages {
            const NAME: &'static str = "Messages";
            const PACKAGE: &'static str = "xmtp.mls.api.v1";
            fn full_name() -> ::prost::alloc::string::String {
                "xmtp.mls.api.v1.SubscribeResponse.V1.Messages".into()
            }
            fn type_url() -> ::prost::alloc::string::String {
                "/xmtp.mls.api.v1.SubscribeResponse.V1.Messages".into()
            }
        }
        /// The first frame on every stream.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct Started {
            /// The server's ping cadence (ms): the basis for the client's staleness
            /// threshold and the server's reap deadline.
            #[prost(uint32, tag = "1")]
            pub keepalive_interval_ms: u32,
            /// Optional protocol features the node supports on this stream. The node
            /// silently ignores request types it does not understand, so a client
            /// MUST NOT send an optional request type whose capability the node did
            /// not advertise (it would hang waiting on a response that never comes).
            #[prost(enumeration = "Capability", repeated, tag = "2")]
            pub capabilities: ::prost::alloc::vec::Vec<i32>,
        }
        impl ::prost::Name for Started {
            const NAME: &'static str = "Started";
            const PACKAGE: &'static str = "xmtp.mls.api.v1";
            fn full_name() -> ::prost::alloc::string::String {
                "xmtp.mls.api.v1.SubscribeResponse.V1.Started".into()
            }
            fn type_url() -> ::prost::alloc::string::String {
                "/xmtp.mls.api.v1.SubscribeResponse.V1.Started".into()
            }
        }
        /// Sent once per Mutate that adds subscriptions (a catch-up "wave"), after
        /// the wave's last TopicsLive: everything the Mutate asked for is delivered.
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct CatchupComplete {
            /// echoes the Mutate that started this wave (0 if none given)
            #[prost(uint64, tag = "1")]
            pub mutate_id: u64,
        }
        impl ::prost::Name for CatchupComplete {
            const NAME: &'static str = "CatchupComplete";
            const PACKAGE: &'static str = "xmtp.mls.api.v1";
            fn full_name() -> ::prost::alloc::string::String {
                "xmtp.mls.api.v1.SubscribeResponse.V1.CatchupComplete".into()
            }
            fn type_url() -> ::prost::alloc::string::String {
                "/xmtp.mls.api.v1.SubscribeResponse.V1.CatchupComplete".into()
            }
        }
        /// Emitted when topics finish catch-up, AFTER the last history frame for
        /// them — including any live messages that queued up behind the catch-up,
        /// which were equally historical from the client's perspective — so every
        /// later frame for a listed topic is live tail. Informational only: delivery
        /// correctness (no duplicates, no gaps) never depends on it. Re-adding a
        /// topic re-runs catch-up and re-emits it; receivers treat it idempotently.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct TopicsLive {
            /// kind-prefixed topics now tailing live
            #[prost(bytes = "vec", repeated, tag = "1")]
            pub topics: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
        }
        impl ::prost::Name for TopicsLive {
            const NAME: &'static str = "TopicsLive";
            const PACKAGE: &'static str = "xmtp.mls.api.v1";
            fn full_name() -> ::prost::alloc::string::String {
                "xmtp.mls.api.v1.SubscribeResponse.V1.TopicsLive".into()
            }
            fn type_url() -> ::prost::alloc::string::String {
                "/xmtp.mls.api.v1.SubscribeResponse.V1.TopicsLive".into()
            }
        }
        /// Optional per-stream protocol features (none defined yet; future
        /// revisions add values, e.g. fetch-over-stream lookups answered with the
        /// same read view that feeds the stream, or new streamable topic kinds).
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum Capability {
            Unspecified = 0,
        }
        impl Capability {
            /// String value of the enum field names used in the ProtoBuf definition.
            ///
            /// The values are not transformed in any way and thus are considered stable
            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
            pub fn as_str_name(&self) -> &'static str {
                match self {
                    Self::Unspecified => "CAPABILITY_UNSPECIFIED",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "CAPABILITY_UNSPECIFIED" => Some(Self::Unspecified),
                    _ => None,
                }
            }
        }
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Response {
            #[prost(message, tag = "1")]
            Messages(Messages),
            /// sent once, immediately on open, before any catch-up
            #[prost(message, tag = "2")]
            Started(Started),
            /// idle liveness challenge; receiver MUST answer with Pong
            #[prost(message, tag = "3")]
            Ping(super::super::Ping),
            /// answer to a client Ping
            #[prost(message, tag = "4")]
            Pong(super::super::Pong),
            /// these topics just crossed from catch-up to live
            #[prost(message, tag = "5")]
            TopicsLive(TopicsLive),
            /// a Mutate's adds are fully delivered
            #[prost(message, tag = "6")]
            CatchupComplete(CatchupComplete),
        }
    }
    impl ::prost::Name for V1 {
        const NAME: &'static str = "V1";
        const PACKAGE: &'static str = "xmtp.mls.api.v1";
        fn full_name() -> ::prost::alloc::string::String {
            "xmtp.mls.api.v1.SubscribeResponse.V1".into()
        }
        fn type_url() -> ::prost::alloc::string::String {
            "/xmtp.mls.api.v1.SubscribeResponse.V1".into()
        }
    }
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Version {
        #[prost(message, tag = "1")]
        V1(V1),
    }
}
impl ::prost::Name for SubscribeResponse {
    const NAME: &'static str = "SubscribeResponse";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.SubscribeResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.SubscribeResponse".into()
    }
}
/// Liveness challenge/response, shared across versions. Either peer MAY send a
/// Ping; the receiver MUST reply with a Pong echoing the nonce. The sender closes
/// the stream if no Pong arrives within its deadline — how a node reaps a vanished
/// peer (e.g. a mobile client the OS suspended behind a proxy that still ACKs the
/// transport).
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Ping {
    #[prost(uint64, tag = "1")]
    pub nonce: u64,
}
impl ::prost::Name for Ping {
    const NAME: &'static str = "Ping";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.Ping".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.Ping".into()
    }
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Pong {
    /// echoes the nonce of the Ping it answers
    #[prost(uint64, tag = "1")]
    pub nonce: u64,
}
impl ::prost::Name for Pong {
    const NAME: &'static str = "Pong";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.Pong".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.Pong".into()
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchPublishCommitLogRequest {
    #[prost(message, repeated, tag = "1")]
    pub requests: ::prost::alloc::vec::Vec<PublishCommitLogRequest>,
}
impl ::prost::Name for BatchPublishCommitLogRequest {
    const NAME: &'static str = "BatchPublishCommitLogRequest";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.BatchPublishCommitLogRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.BatchPublishCommitLogRequest".into()
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PublishCommitLogRequest {
    #[prost(bytes = "vec", tag = "1")]
    pub group_id: ::prost::alloc::vec::Vec<u8>,
    #[prost(bytes = "vec", tag = "2")]
    pub serialized_commit_log_entry: ::prost::alloc::vec::Vec<u8>,
    #[prost(message, optional, tag = "3")]
    pub signature: ::core::option::Option<
        super::super::super::identity::associations::RecoverableEd25519Signature,
    >,
}
impl ::prost::Name for PublishCommitLogRequest {
    const NAME: &'static str = "PublishCommitLogRequest";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.PublishCommitLogRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.PublishCommitLogRequest".into()
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct QueryCommitLogRequest {
    #[prost(bytes = "vec", tag = "1")]
    pub group_id: ::prost::alloc::vec::Vec<u8>,
    #[prost(message, optional, tag = "2")]
    pub paging_info: ::core::option::Option<PagingInfo>,
}
impl ::prost::Name for QueryCommitLogRequest {
    const NAME: &'static str = "QueryCommitLogRequest";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.QueryCommitLogRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.QueryCommitLogRequest".into()
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryCommitLogResponse {
    #[prost(bytes = "vec", tag = "1")]
    pub group_id: ::prost::alloc::vec::Vec<u8>,
    #[prost(message, repeated, tag = "2")]
    pub commit_log_entries: ::prost::alloc::vec::Vec<
        super::super::message_contents::CommitLogEntry,
    >,
    #[prost(message, optional, tag = "3")]
    pub paging_info: ::core::option::Option<PagingInfo>,
}
impl ::prost::Name for QueryCommitLogResponse {
    const NAME: &'static str = "QueryCommitLogResponse";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.QueryCommitLogResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.QueryCommitLogResponse".into()
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchQueryCommitLogRequest {
    #[prost(message, repeated, tag = "1")]
    pub requests: ::prost::alloc::vec::Vec<QueryCommitLogRequest>,
}
impl ::prost::Name for BatchQueryCommitLogRequest {
    const NAME: &'static str = "BatchQueryCommitLogRequest";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.BatchQueryCommitLogRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.BatchQueryCommitLogRequest".into()
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchQueryCommitLogResponse {
    #[prost(message, repeated, tag = "1")]
    pub responses: ::prost::alloc::vec::Vec<QueryCommitLogResponse>,
}
impl ::prost::Name for BatchQueryCommitLogResponse {
    const NAME: &'static str = "BatchQueryCommitLogResponse";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.BatchQueryCommitLogResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.BatchQueryCommitLogResponse".into()
    }
}
/// Request to get the newest group message from a range of topics
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetNewestGroupMessageRequest {
    /// Get the newest message from each of these topics
    #[prost(bytes = "vec", repeated, tag = "1")]
    pub group_ids: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
    #[prost(bool, tag = "2")]
    pub include_content: bool,
}
impl ::prost::Name for GetNewestGroupMessageRequest {
    const NAME: &'static str = "GetNewestGroupMessageRequest";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.GetNewestGroupMessageRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.GetNewestGroupMessageRequest".into()
    }
}
/// Returns a list of responses that will always be the same length as the
/// request
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetNewestGroupMessageResponse {
    #[prost(message, repeated, tag = "1")]
    pub responses: ::prost::alloc::vec::Vec<get_newest_group_message_response::Response>,
}
/// Nested message and enum types in `GetNewestGroupMessageResponse`.
pub mod get_newest_group_message_response {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Response {
        /// If no message is found on the topic, will be nil
        #[prost(message, optional, tag = "1")]
        pub group_message: ::core::option::Option<super::GroupMessage>,
    }
    impl ::prost::Name for Response {
        const NAME: &'static str = "Response";
        const PACKAGE: &'static str = "xmtp.mls.api.v1";
        fn full_name() -> ::prost::alloc::string::String {
            "xmtp.mls.api.v1.GetNewestGroupMessageResponse.Response".into()
        }
        fn type_url() -> ::prost::alloc::string::String {
            "/xmtp.mls.api.v1.GetNewestGroupMessageResponse.Response".into()
        }
    }
}
impl ::prost::Name for GetNewestGroupMessageResponse {
    const NAME: &'static str = "GetNewestGroupMessageResponse";
    const PACKAGE: &'static str = "xmtp.mls.api.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.mls.api.v1.GetNewestGroupMessageResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.mls.api.v1.GetNewestGroupMessageResponse".into()
    }
}
/// Sort direction for queries
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SortDirection {
    Unspecified = 0,
    Ascending = 1,
    Descending = 2,
}
impl SortDirection {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "SORT_DIRECTION_UNSPECIFIED",
            Self::Ascending => "SORT_DIRECTION_ASCENDING",
            Self::Descending => "SORT_DIRECTION_DESCENDING",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SORT_DIRECTION_UNSPECIFIED" => Some(Self::Unspecified),
            "SORT_DIRECTION_ASCENDING" => Some(Self::Ascending),
            "SORT_DIRECTION_DESCENDING" => Some(Self::Descending),
            _ => None,
        }
    }
}
/// Generated server implementations.
#[cfg(any(not(target_arch = "wasm32"), feature = "grpc_server_impls"))]
pub mod mls_api_server {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    /// Generated trait containing gRPC methods that should be implemented for use with MlsApiServer.
    #[async_trait]
    pub trait MlsApi: std::marker::Send + std::marker::Sync + 'static {
        /// Send a MLS payload, that would be validated before being stored to the
        /// network
        async fn send_group_messages(
            &self,
            request: tonic::Request<super::SendGroupMessagesRequest>,
        ) -> std::result::Result<tonic::Response<::pbjson_types::Empty>, tonic::Status>;
        /// Send a batch of welcome messages
        async fn send_welcome_messages(
            &self,
            request: tonic::Request<super::SendWelcomeMessagesRequest>,
        ) -> std::result::Result<tonic::Response<::pbjson_types::Empty>, tonic::Status>;
        /// Register a new installation, which would be validated before storage
        async fn register_installation(
            &self,
            request: tonic::Request<super::RegisterInstallationRequest>,
        ) -> std::result::Result<
            tonic::Response<super::RegisterInstallationResponse>,
            tonic::Status,
        >;
        /// Upload a new KeyPackage, which would be validated before storage
        async fn upload_key_package(
            &self,
            request: tonic::Request<super::UploadKeyPackageRequest>,
        ) -> std::result::Result<tonic::Response<::pbjson_types::Empty>, tonic::Status>;
        /// Get one or more Key Packages by installation_id
        async fn fetch_key_packages(
            &self,
            request: tonic::Request<super::FetchKeyPackagesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::FetchKeyPackagesResponse>,
            tonic::Status,
        >;
        /// Would delete all key packages associated with the installation and mark
        /// the installation as having been revoked
        async fn revoke_installation(
            &self,
            request: tonic::Request<super::RevokeInstallationRequest>,
        ) -> std::result::Result<tonic::Response<::pbjson_types::Empty>, tonic::Status>;
        /// Used to check for changes related to members of a group.
        /// Would return an array of any new installations associated with the wallet
        /// address, and any revocations that have happened.
        async fn get_identity_updates(
            &self,
            request: tonic::Request<super::GetIdentityUpdatesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetIdentityUpdatesResponse>,
            tonic::Status,
        >;
        /// Query stored group messages
        async fn query_group_messages(
            &self,
            request: tonic::Request<super::QueryGroupMessagesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::QueryGroupMessagesResponse>,
            tonic::Status,
        >;
        /// Query stored group messages
        async fn query_welcome_messages(
            &self,
            request: tonic::Request<super::QueryWelcomeMessagesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::QueryWelcomeMessagesResponse>,
            tonic::Status,
        >;
        /// Server streaming response type for the SubscribeGroupMessages method.
        type SubscribeGroupMessagesStream: tonic::codegen::tokio_stream::Stream<
                Item = std::result::Result<super::GroupMessage, tonic::Status>,
            >
            + std::marker::Send
            + 'static;
        /// Subscribe stream of new group messages
        async fn subscribe_group_messages(
            &self,
            request: tonic::Request<super::SubscribeGroupMessagesRequest>,
        ) -> std::result::Result<
            tonic::Response<Self::SubscribeGroupMessagesStream>,
            tonic::Status,
        >;
        /// Server streaming response type for the SubscribeWelcomeMessages method.
        type SubscribeWelcomeMessagesStream: tonic::codegen::tokio_stream::Stream<
                Item = std::result::Result<super::WelcomeMessage, tonic::Status>,
            >
            + std::marker::Send
            + 'static;
        /// Subscribe stream of new welcome messages
        async fn subscribe_welcome_messages(
            &self,
            request: tonic::Request<super::SubscribeWelcomeMessagesRequest>,
        ) -> std::result::Result<
            tonic::Response<Self::SubscribeWelcomeMessagesStream>,
            tonic::Status,
        >;
        /// Server streaming response type for the Subscribe method.
        type SubscribeStream: tonic::codegen::tokio_stream::Stream<
                Item = std::result::Result<super::SubscribeResponse, tonic::Status>,
            >
            + std::marker::Send
            + 'static;
        /// Bidirectional subscription (XIP-83). One long-lived stream the client mutates
        /// in place via add/remove topic deltas, with WebSocket-style liveness ping/pong.
        /// A single stream MAY carry both group-message and welcome topics.
        /// gRPC-only: bidirectional streaming has no HTTP/grpc-gateway mapping.
        async fn subscribe(
            &self,
            request: tonic::Request<tonic::Streaming<super::SubscribeRequest>>,
        ) -> std::result::Result<tonic::Response<Self::SubscribeStream>, tonic::Status>;
        async fn batch_publish_commit_log(
            &self,
            request: tonic::Request<super::BatchPublishCommitLogRequest>,
        ) -> std::result::Result<tonic::Response<::pbjson_types::Empty>, tonic::Status>;
        async fn batch_query_commit_log(
            &self,
            request: tonic::Request<super::BatchQueryCommitLogRequest>,
        ) -> std::result::Result<
            tonic::Response<super::BatchQueryCommitLogResponse>,
            tonic::Status,
        >;
        async fn get_newest_group_message(
            &self,
            request: tonic::Request<super::GetNewestGroupMessageRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetNewestGroupMessageResponse>,
            tonic::Status,
        >;
    }
    /// RPCs for the new MLS API
    #[derive(Debug)]
    pub struct MlsApiServer<T> {
        inner: Arc<T>,
        accept_compression_encodings: EnabledCompressionEncodings,
        send_compression_encodings: EnabledCompressionEncodings,
        max_decoding_message_size: Option<usize>,
        max_encoding_message_size: Option<usize>,
    }
    impl<T> MlsApiServer<T> {
        pub fn new(inner: T) -> Self {
            Self::from_arc(Arc::new(inner))
        }
        pub fn from_arc(inner: Arc<T>) -> Self {
            Self {
                inner,
                accept_compression_encodings: Default::default(),
                send_compression_encodings: Default::default(),
                max_decoding_message_size: None,
                max_encoding_message_size: None,
            }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> InterceptedService<Self, F>
        where
            F: tonic::service::Interceptor,
        {
            InterceptedService::new(Self::new(inner), interceptor)
        }
        /// Enable decompressing requests with the given encoding.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.accept_compression_encodings.enable(encoding);
            self
        }
        /// Compress responses with the given encoding, if the client supports it.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.send_compression_encodings.enable(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.max_decoding_message_size = Some(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.max_encoding_message_size = Some(limit);
            self
        }
    }
    impl<T, B> tonic::codegen::Service<http::Request<B>> for MlsApiServer<T>
    where
        T: MlsApi,
        B: Body + std::marker::Send + 'static,
        B::Error: Into<StdError> + std::marker::Send + 'static,
    {
        type Response = http::Response<tonic::body::Body>;
        type Error = std::convert::Infallible;
        type Future = BoxFuture<Self::Response, Self::Error>;
        fn poll_ready(
            &mut self,
            _cx: &mut Context<'_>,
        ) -> Poll<std::result::Result<(), Self::Error>> {
            Poll::Ready(Ok(()))
        }
        fn call(&mut self, req: http::Request<B>) -> Self::Future {
            match req.uri().path() {
                "/xmtp.mls.api.v1.MlsApi/SendGroupMessages" => {
                    #[allow(non_camel_case_types)]
                    struct SendGroupMessagesSvc<T: MlsApi>(pub Arc<T>);
                    impl<
                        T: MlsApi,
                    > tonic::server::UnaryService<super::SendGroupMessagesRequest>
                    for SendGroupMessagesSvc<T> {
                        type Response = ::pbjson_types::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::SendGroupMessagesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as MlsApi>::send_group_messages(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SendGroupMessagesSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/xmtp.mls.api.v1.MlsApi/SendWelcomeMessages" => {
                    #[allow(non_camel_case_types)]
                    struct SendWelcomeMessagesSvc<T: MlsApi>(pub Arc<T>);
                    impl<
                        T: MlsApi,
                    > tonic::server::UnaryService<super::SendWelcomeMessagesRequest>
                    for SendWelcomeMessagesSvc<T> {
                        type Response = ::pbjson_types::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::SendWelcomeMessagesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as MlsApi>::send_welcome_messages(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SendWelcomeMessagesSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/xmtp.mls.api.v1.MlsApi/RegisterInstallation" => {
                    #[allow(non_camel_case_types)]
                    struct RegisterInstallationSvc<T: MlsApi>(pub Arc<T>);
                    impl<
                        T: MlsApi,
                    > tonic::server::UnaryService<super::RegisterInstallationRequest>
                    for RegisterInstallationSvc<T> {
                        type Response = super::RegisterInstallationResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::RegisterInstallationRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as MlsApi>::register_installation(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = RegisterInstallationSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/xmtp.mls.api.v1.MlsApi/UploadKeyPackage" => {
                    #[allow(non_camel_case_types)]
                    struct UploadKeyPackageSvc<T: MlsApi>(pub Arc<T>);
                    impl<
                        T: MlsApi,
                    > tonic::server::UnaryService<super::UploadKeyPackageRequest>
                    for UploadKeyPackageSvc<T> {
                        type Response = ::pbjson_types::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::UploadKeyPackageRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as MlsApi>::upload_key_package(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = UploadKeyPackageSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/xmtp.mls.api.v1.MlsApi/FetchKeyPackages" => {
                    #[allow(non_camel_case_types)]
                    struct FetchKeyPackagesSvc<T: MlsApi>(pub Arc<T>);
                    impl<
                        T: MlsApi,
                    > tonic::server::UnaryService<super::FetchKeyPackagesRequest>
                    for FetchKeyPackagesSvc<T> {
                        type Response = super::FetchKeyPackagesResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::FetchKeyPackagesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as MlsApi>::fetch_key_packages(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = FetchKeyPackagesSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/xmtp.mls.api.v1.MlsApi/RevokeInstallation" => {
                    #[allow(non_camel_case_types)]
                    struct RevokeInstallationSvc<T: MlsApi>(pub Arc<T>);
                    impl<
                        T: MlsApi,
                    > tonic::server::UnaryService<super::RevokeInstallationRequest>
                    for RevokeInstallationSvc<T> {
                        type Response = ::pbjson_types::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::RevokeInstallationRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as MlsApi>::revoke_installation(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = RevokeInstallationSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/xmtp.mls.api.v1.MlsApi/GetIdentityUpdates" => {
                    #[allow(non_camel_case_types)]
                    struct GetIdentityUpdatesSvc<T: MlsApi>(pub Arc<T>);
                    impl<
                        T: MlsApi,
                    > tonic::server::UnaryService<super::GetIdentityUpdatesRequest>
                    for GetIdentityUpdatesSvc<T> {
                        type Response = super::GetIdentityUpdatesResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetIdentityUpdatesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as MlsApi>::get_identity_updates(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetIdentityUpdatesSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/xmtp.mls.api.v1.MlsApi/QueryGroupMessages" => {
                    #[allow(non_camel_case_types)]
                    struct QueryGroupMessagesSvc<T: MlsApi>(pub Arc<T>);
                    impl<
                        T: MlsApi,
                    > tonic::server::UnaryService<super::QueryGroupMessagesRequest>
                    for QueryGroupMessagesSvc<T> {
                        type Response = super::QueryGroupMessagesResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::QueryGroupMessagesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as MlsApi>::query_group_messages(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = QueryGroupMessagesSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/xmtp.mls.api.v1.MlsApi/QueryWelcomeMessages" => {
                    #[allow(non_camel_case_types)]
                    struct QueryWelcomeMessagesSvc<T: MlsApi>(pub Arc<T>);
                    impl<
                        T: MlsApi,
                    > tonic::server::UnaryService<super::QueryWelcomeMessagesRequest>
                    for QueryWelcomeMessagesSvc<T> {
                        type Response = super::QueryWelcomeMessagesResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::QueryWelcomeMessagesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as MlsApi>::query_welcome_messages(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = QueryWelcomeMessagesSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/xmtp.mls.api.v1.MlsApi/SubscribeGroupMessages" => {
                    #[allow(non_camel_case_types)]
                    struct SubscribeGroupMessagesSvc<T: MlsApi>(pub Arc<T>);
                    impl<
                        T: MlsApi,
                    > tonic::server::ServerStreamingService<
                        super::SubscribeGroupMessagesRequest,
                    > for SubscribeGroupMessagesSvc<T> {
                        type Response = super::GroupMessage;
                        type ResponseStream = T::SubscribeGroupMessagesStream;
                        type Future = BoxFuture<
                            tonic::Response<Self::ResponseStream>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::SubscribeGroupMessagesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as MlsApi>::subscribe_group_messages(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SubscribeGroupMessagesSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.server_streaming(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/xmtp.mls.api.v1.MlsApi/SubscribeWelcomeMessages" => {
                    #[allow(non_camel_case_types)]
                    struct SubscribeWelcomeMessagesSvc<T: MlsApi>(pub Arc<T>);
                    impl<
                        T: MlsApi,
                    > tonic::server::ServerStreamingService<
                        super::SubscribeWelcomeMessagesRequest,
                    > for SubscribeWelcomeMessagesSvc<T> {
                        type Response = super::WelcomeMessage;
                        type ResponseStream = T::SubscribeWelcomeMessagesStream;
                        type Future = BoxFuture<
                            tonic::Response<Self::ResponseStream>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<
                                super::SubscribeWelcomeMessagesRequest,
                            >,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as MlsApi>::subscribe_welcome_messages(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SubscribeWelcomeMessagesSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.server_streaming(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/xmtp.mls.api.v1.MlsApi/Subscribe" => {
                    #[allow(non_camel_case_types)]
                    struct SubscribeSvc<T: MlsApi>(pub Arc<T>);
                    impl<
                        T: MlsApi,
                    > tonic::server::StreamingService<super::SubscribeRequest>
                    for SubscribeSvc<T> {
                        type Response = super::SubscribeResponse;
                        type ResponseStream = T::SubscribeStream;
                        type Future = BoxFuture<
                            tonic::Response<Self::ResponseStream>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<
                                tonic::Streaming<super::SubscribeRequest>,
                            >,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as MlsApi>::subscribe(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SubscribeSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.streaming(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/xmtp.mls.api.v1.MlsApi/BatchPublishCommitLog" => {
                    #[allow(non_camel_case_types)]
                    struct BatchPublishCommitLogSvc<T: MlsApi>(pub Arc<T>);
                    impl<
                        T: MlsApi,
                    > tonic::server::UnaryService<super::BatchPublishCommitLogRequest>
                    for BatchPublishCommitLogSvc<T> {
                        type Response = ::pbjson_types::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::BatchPublishCommitLogRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as MlsApi>::batch_publish_commit_log(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = BatchPublishCommitLogSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/xmtp.mls.api.v1.MlsApi/BatchQueryCommitLog" => {
                    #[allow(non_camel_case_types)]
                    struct BatchQueryCommitLogSvc<T: MlsApi>(pub Arc<T>);
                    impl<
                        T: MlsApi,
                    > tonic::server::UnaryService<super::BatchQueryCommitLogRequest>
                    for BatchQueryCommitLogSvc<T> {
                        type Response = super::BatchQueryCommitLogResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::BatchQueryCommitLogRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as MlsApi>::batch_query_commit_log(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = BatchQueryCommitLogSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/xmtp.mls.api.v1.MlsApi/GetNewestGroupMessage" => {
                    #[allow(non_camel_case_types)]
                    struct GetNewestGroupMessageSvc<T: MlsApi>(pub Arc<T>);
                    impl<
                        T: MlsApi,
                    > tonic::server::UnaryService<super::GetNewestGroupMessageRequest>
                    for GetNewestGroupMessageSvc<T> {
                        type Response = super::GetNewestGroupMessageResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetNewestGroupMessageRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as MlsApi>::get_newest_group_message(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetNewestGroupMessageSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                _ => {
                    Box::pin(async move {
                        let mut response = http::Response::new(
                            tonic::body::Body::default(),
                        );
                        let headers = response.headers_mut();
                        headers
                            .insert(
                                tonic::Status::GRPC_STATUS,
                                (tonic::Code::Unimplemented as i32).into(),
                            );
                        headers
                            .insert(
                                http::header::CONTENT_TYPE,
                                tonic::metadata::GRPC_CONTENT_TYPE,
                            );
                        Ok(response)
                    })
                }
            }
        }
    }
    impl<T> Clone for MlsApiServer<T> {
        fn clone(&self) -> Self {
            let inner = self.inner.clone();
            Self {
                inner,
                accept_compression_encodings: self.accept_compression_encodings,
                send_compression_encodings: self.send_compression_encodings,
                max_decoding_message_size: self.max_decoding_message_size,
                max_encoding_message_size: self.max_encoding_message_size,
            }
        }
    }
    /// Generated gRPC service name
    pub const SERVICE_NAME: &str = "xmtp.mls.api.v1.MlsApi";
    impl<T> tonic::server::NamedService for MlsApiServer<T> {
        const NAME: &'static str = SERVICE_NAME;
    }
}