xmtp_proto/gen/

xmtp.xmtpv4.message_api.rs

// This file is @generated by prost-build.
/// Query for envelopes, shared by query and subscribe endpoints
/// Either topics or originator_node_ids may be set, but not both
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EnvelopesQuery {
    /// Client queries
    #[prost(bytes = "vec", repeated, tag = "1")]
    pub topics: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
    /// Node queries
    #[prost(uint32, repeated, tag = "2")]
    pub originator_node_ids: ::prost::alloc::vec::Vec<u32>,
    #[prost(message, optional, tag = "3")]
    pub last_seen: ::core::option::Option<super::envelopes::Cursor>,
}
impl ::prost::Name for EnvelopesQuery {
    const NAME: &'static str = "EnvelopesQuery";
    const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.xmtpv4.message_api.EnvelopesQuery".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.xmtpv4.message_api.EnvelopesQuery".into()
    }
}
/// Batch subscribe to envelopes
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SubscribeEnvelopesRequest {
    #[prost(message, optional, tag = "1")]
    pub query: ::core::option::Option<EnvelopesQuery>,
}
impl ::prost::Name for SubscribeEnvelopesRequest {
    const NAME: &'static str = "SubscribeEnvelopesRequest";
    const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.xmtpv4.message_api.SubscribeEnvelopesRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.xmtpv4.message_api.SubscribeEnvelopesRequest".into()
    }
}
/// Request to subscribe to a series of topics, with a separate cursor for each topic
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SubscribeTopicsRequest {
    #[prost(message, repeated, tag = "1")]
    pub filters: ::prost::alloc::vec::Vec<subscribe_topics_request::TopicFilter>,
}
/// Nested message and enum types in `SubscribeTopicsRequest`.
pub mod subscribe_topics_request {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct TopicFilter {
        #[prost(bytes = "vec", tag = "1")]
        pub topic: ::prost::alloc::vec::Vec<u8>,
        #[prost(message, optional, tag = "2")]
        pub last_seen: ::core::option::Option<super::super::envelopes::Cursor>,
    }
    impl ::prost::Name for TopicFilter {
        const NAME: &'static str = "TopicFilter";
        const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
        fn full_name() -> ::prost::alloc::string::String {
            "xmtp.xmtpv4.message_api.SubscribeTopicsRequest.TopicFilter".into()
        }
        fn type_url() -> ::prost::alloc::string::String {
            "/xmtp.xmtpv4.message_api.SubscribeTopicsRequest.TopicFilter".into()
        }
    }
}
impl ::prost::Name for SubscribeTopicsRequest {
    const NAME: &'static str = "SubscribeTopicsRequest";
    const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.xmtpv4.message_api.SubscribeTopicsRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.xmtpv4.message_api.SubscribeTopicsRequest".into()
    }
}
/// Response to SubscribeTopics
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SubscribeTopicsResponse {
    #[prost(oneof = "subscribe_topics_response::Response", tags = "1, 2")]
    pub response: ::core::option::Option<subscribe_topics_response::Response>,
}
/// Nested message and enum types in `SubscribeTopicsResponse`.
pub mod subscribe_topics_response {
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct StatusUpdate {
        #[prost(enumeration = "SubscriptionStatus", tag = "1")]
        pub status: i32,
    }
    impl ::prost::Name for StatusUpdate {
        const NAME: &'static str = "StatusUpdate";
        const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
        fn full_name() -> ::prost::alloc::string::String {
            "xmtp.xmtpv4.message_api.SubscribeTopicsResponse.StatusUpdate".into()
        }
        fn type_url() -> ::prost::alloc::string::String {
            "/xmtp.xmtpv4.message_api.SubscribeTopicsResponse.StatusUpdate".into()
        }
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Envelopes {
        #[prost(message, repeated, tag = "1")]
        pub envelopes: ::prost::alloc::vec::Vec<
            super::super::envelopes::OriginatorEnvelope,
        >,
    }
    impl ::prost::Name for Envelopes {
        const NAME: &'static str = "Envelopes";
        const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
        fn full_name() -> ::prost::alloc::string::String {
            "xmtp.xmtpv4.message_api.SubscribeTopicsResponse.Envelopes".into()
        }
        fn type_url() -> ::prost::alloc::string::String {
            "/xmtp.xmtpv4.message_api.SubscribeTopicsResponse.Envelopes".into()
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum SubscriptionStatus {
        Unspecified = 0,
        Started = 1,
        CatchupComplete = 2,
        Waiting = 3,
    }
    impl SubscriptionStatus {
        /// 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 => "SUBSCRIPTION_STATUS_UNSPECIFIED",
                Self::Started => "SUBSCRIPTION_STATUS_STARTED",
                Self::CatchupComplete => "SUBSCRIPTION_STATUS_CATCHUP_COMPLETE",
                Self::Waiting => "SUBSCRIPTION_STATUS_WAITING",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "SUBSCRIPTION_STATUS_UNSPECIFIED" => Some(Self::Unspecified),
                "SUBSCRIPTION_STATUS_STARTED" => Some(Self::Started),
                "SUBSCRIPTION_STATUS_CATCHUP_COMPLETE" => Some(Self::CatchupComplete),
                "SUBSCRIPTION_STATUS_WAITING" => Some(Self::Waiting),
                _ => None,
            }
        }
    }
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Response {
        #[prost(message, tag = "1")]
        Envelopes(Envelopes),
        #[prost(message, tag = "2")]
        StatusUpdate(StatusUpdate),
    }
}
impl ::prost::Name for SubscribeTopicsResponse {
    const NAME: &'static str = "SubscribeTopicsResponse";
    const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.xmtpv4.message_api.SubscribeTopicsResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.xmtpv4.message_api.SubscribeTopicsResponse".into()
    }
}
/// Streamed response for batch subscribe - can be multiple envelopes at once
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SubscribeEnvelopesResponse {
    #[prost(message, repeated, tag = "1")]
    pub envelopes: ::prost::alloc::vec::Vec<super::envelopes::OriginatorEnvelope>,
}
impl ::prost::Name for SubscribeEnvelopesResponse {
    const NAME: &'static str = "SubscribeEnvelopesResponse";
    const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.xmtpv4.message_api.SubscribeEnvelopesResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.xmtpv4.message_api.SubscribeEnvelopesResponse".into()
    }
}
/// Client -> node. 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 (XIP-49 §3.3.2): the
        /// first byte is the topic kind, the remainder is the identifier. A topic
        /// whose kind the node does not serve fails the stream with INVALID_ARGUMENT.
        #[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 node finishes the wave 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 vector cursor to resume from.
            #[derive(Clone, PartialEq, ::prost::Message)]
            pub struct Subscription {
                #[prost(bytes = "vec", tag = "1")]
                pub topic: ::prost::alloc::vec::Vec<u8>,
                /// Resume point: deliver envelopes beyond this per-originator vector
                /// cursor. Omitted/empty = from the beginning. Originators absent from
                /// the cursor map are treated as sequence 0 (the node fills them in),
                /// mirroring SubscribeTopics.TopicFilter.last_seen.
                #[prost(message, optional, tag = "2")]
                pub last_seen: ::core::option::Option<
                    super::super::super::super::envelopes::Cursor,
                >,
            }
            impl ::prost::Name for Subscription {
                const NAME: &'static str = "Subscription";
                const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
                fn full_name() -> ::prost::alloc::string::String {
                    "xmtp.xmtpv4.message_api.SubscribeRequest.V1.Mutate.Subscription"
                        .into()
                }
                fn type_url() -> ::prost::alloc::string::String {
                    "/xmtp.xmtpv4.message_api.SubscribeRequest.V1.Mutate.Subscription"
                        .into()
                }
            }
        }
        impl ::prost::Name for Mutate {
            const NAME: &'static str = "Mutate";
            const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
            fn full_name() -> ::prost::alloc::string::String {
                "xmtp.xmtpv4.message_api.SubscribeRequest.V1.Mutate".into()
            }
            fn type_url() -> ::prost::alloc::string::String {
                "/xmtp.xmtpv4.message_api.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 node Ping
            #[prost(message, tag = "3")]
            Pong(super::super::Pong),
        }
    }
    impl ::prost::Name for V1 {
        const NAME: &'static str = "V1";
        const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
        fn full_name() -> ::prost::alloc::string::String {
            "xmtp.xmtpv4.message_api.SubscribeRequest.V1".into()
        }
        fn type_url() -> ::prost::alloc::string::String {
            "/xmtp.xmtpv4.message_api.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.xmtpv4.message_api";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.xmtpv4.message_api.SubscribeRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.xmtpv4.message_api.SubscribeRequest".into()
    }
}
/// Node -> 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 envelopes across the active subscriptions; the client demuxes
        /// by each envelope's target topic.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct Envelopes {
            #[prost(message, repeated, tag = "1")]
            pub envelopes: ::prost::alloc::vec::Vec<
                super::super::super::envelopes::OriginatorEnvelope,
            >,
        }
        impl ::prost::Name for Envelopes {
            const NAME: &'static str = "Envelopes";
            const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
            fn full_name() -> ::prost::alloc::string::String {
                "xmtp.xmtpv4.message_api.SubscribeResponse.V1.Envelopes".into()
            }
            fn type_url() -> ::prost::alloc::string::String {
                "/xmtp.xmtpv4.message_api.SubscribeResponse.V1.Envelopes".into()
            }
        }
        /// The first frame on every stream.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct Started {
            /// The node's ping cadence (ms): the basis for the client's staleness
            /// threshold and the node'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.xmtpv4.message_api";
            fn full_name() -> ::prost::alloc::string::String {
                "xmtp.xmtpv4.message_api.SubscribeResponse.V1.Started".into()
            }
            fn type_url() -> ::prost::alloc::string::String {
                "/xmtp.xmtpv4.message_api.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.xmtpv4.message_api";
            fn full_name() -> ::prost::alloc::string::String {
                "xmtp.xmtpv4.message_api.SubscribeResponse.V1.CatchupComplete".into()
            }
            fn type_url() -> ::prost::alloc::string::String {
                "/xmtp.xmtpv4.message_api.SubscribeResponse.V1.CatchupComplete".into()
            }
        }
        /// Emitted when topics finish catch-up, AFTER the last history frame for
        /// them — including any live envelopes that queued 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.xmtpv4.message_api";
            fn full_name() -> ::prost::alloc::string::String {
                "xmtp.xmtpv4.message_api.SubscribeResponse.V1.TopicsLive".into()
            }
            fn type_url() -> ::prost::alloc::string::String {
                "/xmtp.xmtpv4.message_api.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")]
            Envelopes(Envelopes),
            /// 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.xmtpv4.message_api";
        fn full_name() -> ::prost::alloc::string::String {
            "xmtp.xmtpv4.message_api.SubscribeResponse.V1".into()
        }
        fn type_url() -> ::prost::alloc::string::String {
            "/xmtp.xmtpv4.message_api.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.xmtpv4.message_api";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.xmtpv4.message_api.SubscribeResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.xmtpv4.message_api.SubscribeResponse".into()
    }
}
/// Liveness challenge/response for Subscribe, 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.xmtpv4.message_api";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.xmtpv4.message_api.Ping".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.xmtpv4.message_api.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.xmtpv4.message_api";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.xmtpv4.message_api.Pong".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.xmtpv4.message_api.Pong".into()
    }
}
/// Batch subscribe to all envelopes
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SubscribeAllEnvelopesRequest {}
impl ::prost::Name for SubscribeAllEnvelopesRequest {
    const NAME: &'static str = "SubscribeAllEnvelopesRequest";
    const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.xmtpv4.message_api.SubscribeAllEnvelopesRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.xmtpv4.message_api.SubscribeAllEnvelopesRequest".into()
    }
}
/// Query envelopes request
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryEnvelopesRequest {
    #[prost(message, optional, tag = "1")]
    pub query: ::core::option::Option<EnvelopesQuery>,
    #[prost(uint32, tag = "2")]
    pub limit: u32,
}
impl ::prost::Name for QueryEnvelopesRequest {
    const NAME: &'static str = "QueryEnvelopesRequest";
    const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.xmtpv4.message_api.QueryEnvelopesRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.xmtpv4.message_api.QueryEnvelopesRequest".into()
    }
}
/// Query envelopes response
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryEnvelopesResponse {
    #[prost(message, repeated, tag = "1")]
    pub envelopes: ::prost::alloc::vec::Vec<super::envelopes::OriginatorEnvelope>,
}
impl ::prost::Name for QueryEnvelopesResponse {
    const NAME: &'static str = "QueryEnvelopesResponse";
    const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.xmtpv4.message_api.QueryEnvelopesResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.xmtpv4.message_api.QueryEnvelopesResponse".into()
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PublishPayerEnvelopesRequest {
    #[prost(message, repeated, tag = "1")]
    pub payer_envelopes: ::prost::alloc::vec::Vec<super::envelopes::PayerEnvelope>,
}
impl ::prost::Name for PublishPayerEnvelopesRequest {
    const NAME: &'static str = "PublishPayerEnvelopesRequest";
    const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.xmtpv4.message_api.PublishPayerEnvelopesRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.xmtpv4.message_api.PublishPayerEnvelopesRequest".into()
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PublishPayerEnvelopesResponse {
    #[prost(message, repeated, tag = "1")]
    pub originator_envelopes: ::prost::alloc::vec::Vec<
        super::envelopes::OriginatorEnvelope,
    >,
}
impl ::prost::Name for PublishPayerEnvelopesResponse {
    const NAME: &'static str = "PublishPayerEnvelopesResponse";
    const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.xmtpv4.message_api.PublishPayerEnvelopesResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.xmtpv4.message_api.PublishPayerEnvelopesResponse".into()
    }
}
/// Request to retrieve the XIDs for the given addresses
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetInboxIdsRequest {
    #[prost(message, repeated, tag = "1")]
    pub requests: ::prost::alloc::vec::Vec<get_inbox_ids_request::Request>,
}
/// Nested message and enum types in `GetInboxIdsRequest`.
pub mod get_inbox_ids_request {
    /// A single request for a given address
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Request {
        #[prost(string, tag = "1")]
        pub identifier: ::prost::alloc::string::String,
        #[prost(
            enumeration = "super::super::super::identity::associations::IdentifierKind",
            tag = "2"
        )]
        pub identifier_kind: i32,
    }
    impl ::prost::Name for Request {
        const NAME: &'static str = "Request";
        const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
        fn full_name() -> ::prost::alloc::string::String {
            "xmtp.xmtpv4.message_api.GetInboxIdsRequest.Request".into()
        }
        fn type_url() -> ::prost::alloc::string::String {
            "/xmtp.xmtpv4.message_api.GetInboxIdsRequest.Request".into()
        }
    }
}
impl ::prost::Name for GetInboxIdsRequest {
    const NAME: &'static str = "GetInboxIdsRequest";
    const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.xmtpv4.message_api.GetInboxIdsRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.xmtpv4.message_api.GetInboxIdsRequest".into()
    }
}
/// Response with the XIDs for the requested addresses
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetInboxIdsResponse {
    #[prost(message, repeated, tag = "1")]
    pub responses: ::prost::alloc::vec::Vec<get_inbox_ids_response::Response>,
}
/// Nested message and enum types in `GetInboxIdsResponse`.
pub mod get_inbox_ids_response {
    /// A single response for a given address
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Response {
        #[prost(string, tag = "1")]
        pub identifier: ::prost::alloc::string::String,
        #[prost(string, optional, tag = "2")]
        pub inbox_id: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(
            enumeration = "super::super::super::identity::associations::IdentifierKind",
            tag = "3"
        )]
        pub identifier_kind: i32,
    }
    impl ::prost::Name for Response {
        const NAME: &'static str = "Response";
        const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
        fn full_name() -> ::prost::alloc::string::String {
            "xmtp.xmtpv4.message_api.GetInboxIdsResponse.Response".into()
        }
        fn type_url() -> ::prost::alloc::string::String {
            "/xmtp.xmtpv4.message_api.GetInboxIdsResponse.Response".into()
        }
    }
}
impl ::prost::Name for GetInboxIdsResponse {
    const NAME: &'static str = "GetInboxIdsResponse";
    const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.xmtpv4.message_api.GetInboxIdsResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.xmtpv4.message_api.GetInboxIdsResponse".into()
    }
}
/// Request to get the newest envelope for a given topic
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetNewestEnvelopeRequest {
    #[prost(bytes = "vec", repeated, tag = "1")]
    pub topics: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
}
impl ::prost::Name for GetNewestEnvelopeRequest {
    const NAME: &'static str = "GetNewestEnvelopeRequest";
    const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.xmtpv4.message_api.GetNewestEnvelopeRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.xmtpv4.message_api.GetNewestEnvelopeRequest".into()
    }
}
/// Response to GetNewestEnvelopeRequest
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetNewestEnvelopeResponse {
    /// The newest envelope for the given topic OR null if there are no envelopes on the topic
    #[prost(message, repeated, tag = "1")]
    pub results: ::prost::alloc::vec::Vec<get_newest_envelope_response::Response>,
}
/// Nested message and enum types in `GetNewestEnvelopeResponse`.
pub mod get_newest_envelope_response {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Response {
        #[prost(message, optional, tag = "1")]
        pub originator_envelope: ::core::option::Option<
            super::super::envelopes::OriginatorEnvelope,
        >,
    }
    impl ::prost::Name for Response {
        const NAME: &'static str = "Response";
        const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
        fn full_name() -> ::prost::alloc::string::String {
            "xmtp.xmtpv4.message_api.GetNewestEnvelopeResponse.Response".into()
        }
        fn type_url() -> ::prost::alloc::string::String {
            "/xmtp.xmtpv4.message_api.GetNewestEnvelopeResponse.Response".into()
        }
    }
}
impl ::prost::Name for GetNewestEnvelopeResponse {
    const NAME: &'static str = "GetNewestEnvelopeResponse";
    const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.xmtpv4.message_api.GetNewestEnvelopeResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.xmtpv4.message_api.GetNewestEnvelopeResponse".into()
    }
}
/// Subscribe to envelopes from specific originator nodes
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SubscribeOriginatorsRequest {
    #[prost(message, optional, tag = "1")]
    pub filter: ::core::option::Option<subscribe_originators_request::OriginatorFilter>,
}
/// Nested message and enum types in `SubscribeOriginatorsRequest`.
pub mod subscribe_originators_request {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct OriginatorFilter {
        #[prost(uint32, repeated, tag = "1")]
        pub originator_node_ids: ::prost::alloc::vec::Vec<u32>,
        #[prost(message, optional, tag = "2")]
        pub last_seen: ::core::option::Option<super::super::envelopes::Cursor>,
    }
    impl ::prost::Name for OriginatorFilter {
        const NAME: &'static str = "OriginatorFilter";
        const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
        fn full_name() -> ::prost::alloc::string::String {
            "xmtp.xmtpv4.message_api.SubscribeOriginatorsRequest.OriginatorFilter".into()
        }
        fn type_url() -> ::prost::alloc::string::String {
            "/xmtp.xmtpv4.message_api.SubscribeOriginatorsRequest.OriginatorFilter"
                .into()
        }
    }
}
impl ::prost::Name for SubscribeOriginatorsRequest {
    const NAME: &'static str = "SubscribeOriginatorsRequest";
    const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.xmtpv4.message_api.SubscribeOriginatorsRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.xmtpv4.message_api.SubscribeOriginatorsRequest".into()
    }
}
/// Response for SubscribeOriginators
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SubscribeOriginatorsResponse {
    #[prost(oneof = "subscribe_originators_response::Response", tags = "1")]
    pub response: ::core::option::Option<subscribe_originators_response::Response>,
}
/// Nested message and enum types in `SubscribeOriginatorsResponse`.
pub mod subscribe_originators_response {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Envelopes {
        #[prost(message, repeated, tag = "1")]
        pub envelopes: ::prost::alloc::vec::Vec<
            super::super::envelopes::OriginatorEnvelope,
        >,
    }
    impl ::prost::Name for Envelopes {
        const NAME: &'static str = "Envelopes";
        const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
        fn full_name() -> ::prost::alloc::string::String {
            "xmtp.xmtpv4.message_api.SubscribeOriginatorsResponse.Envelopes".into()
        }
        fn type_url() -> ::prost::alloc::string::String {
            "/xmtp.xmtpv4.message_api.SubscribeOriginatorsResponse.Envelopes".into()
        }
    }
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Response {
        #[prost(message, tag = "1")]
        Envelopes(Envelopes),
    }
}
impl ::prost::Name for SubscribeOriginatorsResponse {
    const NAME: &'static str = "SubscribeOriginatorsResponse";
    const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.xmtpv4.message_api.SubscribeOriginatorsResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.xmtpv4.message_api.SubscribeOriginatorsResponse".into()
    }
}
/// Generated server implementations.
#[cfg(any(not(target_arch = "wasm32"), feature = "grpc_server_impls"))]
pub mod replication_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 ReplicationApiServer.
    #[async_trait]
    pub trait ReplicationApi: std::marker::Send + std::marker::Sync + 'static {
        /// Server streaming response type for the SubscribeOriginators method.
        type SubscribeOriginatorsStream: tonic::codegen::tokio_stream::Stream<
                Item = std::result::Result<
                    super::SubscribeOriginatorsResponse,
                    tonic::Status,
                >,
            >
            + std::marker::Send
            + 'static;
        /// Node-to-node originator subscription
        async fn subscribe_originators(
            &self,
            request: tonic::Request<super::SubscribeOriginatorsRequest>,
        ) -> std::result::Result<
            tonic::Response<Self::SubscribeOriginatorsStream>,
            tonic::Status,
        >;
        /// Server streaming response type for the SubscribeEnvelopes method.
        type SubscribeEnvelopesStream: tonic::codegen::tokio_stream::Stream<
                Item = std::result::Result<
                    super::SubscribeEnvelopesResponse,
                    tonic::Status,
                >,
            >
            + std::marker::Send
            + 'static;
        /// Deprecated: use SubscribeOriginators for node queries,
        /// QueryApi.SubscribeTopics for client queries
        async fn subscribe_envelopes(
            &self,
            request: tonic::Request<super::SubscribeEnvelopesRequest>,
        ) -> std::result::Result<
            tonic::Response<Self::SubscribeEnvelopesStream>,
            tonic::Status,
        >;
        /// Server streaming response type for the SubscribeTopics method.
        type SubscribeTopicsStream: tonic::codegen::tokio_stream::Stream<
                Item = std::result::Result<super::SubscribeTopicsResponse, tonic::Status>,
            >
            + std::marker::Send
            + 'static;
        /// Deprecated: moved to QueryApi
        async fn subscribe_topics(
            &self,
            request: tonic::Request<super::SubscribeTopicsRequest>,
        ) -> std::result::Result<
            tonic::Response<Self::SubscribeTopicsStream>,
            tonic::Status,
        >;
        /// Deprecated: moved to QueryApi
        async fn query_envelopes(
            &self,
            request: tonic::Request<super::QueryEnvelopesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::QueryEnvelopesResponse>,
            tonic::Status,
        >;
        /// Deprecated: moved to PublishApi
        async fn publish_payer_envelopes(
            &self,
            request: tonic::Request<super::PublishPayerEnvelopesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::PublishPayerEnvelopesResponse>,
            tonic::Status,
        >;
        /// Deprecated: moved to QueryApi
        async fn get_inbox_ids(
            &self,
            request: tonic::Request<super::GetInboxIdsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetInboxIdsResponse>,
            tonic::Status,
        >;
        /// Deprecated: moved to QueryApi
        async fn get_newest_envelope(
            &self,
            request: tonic::Request<super::GetNewestEnvelopeRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetNewestEnvelopeResponse>,
            tonic::Status,
        >;
    }
    #[derive(Debug)]
    pub struct ReplicationApiServer<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> ReplicationApiServer<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 ReplicationApiServer<T>
    where
        T: ReplicationApi,
        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.xmtpv4.message_api.ReplicationApi/SubscribeOriginators" => {
                    #[allow(non_camel_case_types)]
                    struct SubscribeOriginatorsSvc<T: ReplicationApi>(pub Arc<T>);
                    impl<
                        T: ReplicationApi,
                    > tonic::server::ServerStreamingService<
                        super::SubscribeOriginatorsRequest,
                    > for SubscribeOriginatorsSvc<T> {
                        type Response = super::SubscribeOriginatorsResponse;
                        type ResponseStream = T::SubscribeOriginatorsStream;
                        type Future = BoxFuture<
                            tonic::Response<Self::ResponseStream>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::SubscribeOriginatorsRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ReplicationApi>::subscribe_originators(
                                        &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 = SubscribeOriginatorsSvc(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.xmtpv4.message_api.ReplicationApi/SubscribeEnvelopes" => {
                    #[allow(non_camel_case_types)]
                    struct SubscribeEnvelopesSvc<T: ReplicationApi>(pub Arc<T>);
                    impl<
                        T: ReplicationApi,
                    > tonic::server::ServerStreamingService<
                        super::SubscribeEnvelopesRequest,
                    > for SubscribeEnvelopesSvc<T> {
                        type Response = super::SubscribeEnvelopesResponse;
                        type ResponseStream = T::SubscribeEnvelopesStream;
                        type Future = BoxFuture<
                            tonic::Response<Self::ResponseStream>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::SubscribeEnvelopesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ReplicationApi>::subscribe_envelopes(&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 = SubscribeEnvelopesSvc(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.xmtpv4.message_api.ReplicationApi/SubscribeTopics" => {
                    #[allow(non_camel_case_types)]
                    struct SubscribeTopicsSvc<T: ReplicationApi>(pub Arc<T>);
                    impl<
                        T: ReplicationApi,
                    > tonic::server::ServerStreamingService<
                        super::SubscribeTopicsRequest,
                    > for SubscribeTopicsSvc<T> {
                        type Response = super::SubscribeTopicsResponse;
                        type ResponseStream = T::SubscribeTopicsStream;
                        type Future = BoxFuture<
                            tonic::Response<Self::ResponseStream>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::SubscribeTopicsRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ReplicationApi>::subscribe_topics(&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 = SubscribeTopicsSvc(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.xmtpv4.message_api.ReplicationApi/QueryEnvelopes" => {
                    #[allow(non_camel_case_types)]
                    struct QueryEnvelopesSvc<T: ReplicationApi>(pub Arc<T>);
                    impl<
                        T: ReplicationApi,
                    > tonic::server::UnaryService<super::QueryEnvelopesRequest>
                    for QueryEnvelopesSvc<T> {
                        type Response = super::QueryEnvelopesResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::QueryEnvelopesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ReplicationApi>::query_envelopes(&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 = QueryEnvelopesSvc(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.xmtpv4.message_api.ReplicationApi/PublishPayerEnvelopes" => {
                    #[allow(non_camel_case_types)]
                    struct PublishPayerEnvelopesSvc<T: ReplicationApi>(pub Arc<T>);
                    impl<
                        T: ReplicationApi,
                    > tonic::server::UnaryService<super::PublishPayerEnvelopesRequest>
                    for PublishPayerEnvelopesSvc<T> {
                        type Response = super::PublishPayerEnvelopesResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::PublishPayerEnvelopesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ReplicationApi>::publish_payer_envelopes(
                                        &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 = PublishPayerEnvelopesSvc(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.xmtpv4.message_api.ReplicationApi/GetInboxIds" => {
                    #[allow(non_camel_case_types)]
                    struct GetInboxIdsSvc<T: ReplicationApi>(pub Arc<T>);
                    impl<
                        T: ReplicationApi,
                    > tonic::server::UnaryService<super::GetInboxIdsRequest>
                    for GetInboxIdsSvc<T> {
                        type Response = super::GetInboxIdsResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetInboxIdsRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ReplicationApi>::get_inbox_ids(&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 = GetInboxIdsSvc(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.xmtpv4.message_api.ReplicationApi/GetNewestEnvelope" => {
                    #[allow(non_camel_case_types)]
                    struct GetNewestEnvelopeSvc<T: ReplicationApi>(pub Arc<T>);
                    impl<
                        T: ReplicationApi,
                    > tonic::server::UnaryService<super::GetNewestEnvelopeRequest>
                    for GetNewestEnvelopeSvc<T> {
                        type Response = super::GetNewestEnvelopeResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetNewestEnvelopeRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ReplicationApi>::get_newest_envelope(&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 = GetNewestEnvelopeSvc(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 ReplicationApiServer<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.xmtpv4.message_api.ReplicationApi";
    impl<T> tonic::server::NamedService for ReplicationApiServer<T> {
        const NAME: &'static str = SERVICE_NAME;
    }
}
/// Generated server implementations.
#[cfg(any(not(target_arch = "wasm32"), feature = "grpc_server_impls"))]
pub mod notification_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 NotificationApiServer.
    #[async_trait]
    pub trait NotificationApi: std::marker::Send + std::marker::Sync + 'static {
        /// Server streaming response type for the SubscribeAllEnvelopes method.
        type SubscribeAllEnvelopesStream: tonic::codegen::tokio_stream::Stream<
                Item = std::result::Result<
                    super::SubscribeEnvelopesResponse,
                    tonic::Status,
                >,
            >
            + std::marker::Send
            + 'static;
        async fn subscribe_all_envelopes(
            &self,
            request: tonic::Request<super::SubscribeAllEnvelopesRequest>,
        ) -> std::result::Result<
            tonic::Response<Self::SubscribeAllEnvelopesStream>,
            tonic::Status,
        >;
    }
    /// Full envelope stream for notification services.
    #[derive(Debug)]
    pub struct NotificationApiServer<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> NotificationApiServer<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 NotificationApiServer<T>
    where
        T: NotificationApi,
        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.xmtpv4.message_api.NotificationApi/SubscribeAllEnvelopes" => {
                    #[allow(non_camel_case_types)]
                    struct SubscribeAllEnvelopesSvc<T: NotificationApi>(pub Arc<T>);
                    impl<
                        T: NotificationApi,
                    > tonic::server::ServerStreamingService<
                        super::SubscribeAllEnvelopesRequest,
                    > for SubscribeAllEnvelopesSvc<T> {
                        type Response = super::SubscribeEnvelopesResponse;
                        type ResponseStream = T::SubscribeAllEnvelopesStream;
                        type Future = BoxFuture<
                            tonic::Response<Self::ResponseStream>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::SubscribeAllEnvelopesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as NotificationApi>::subscribe_all_envelopes(
                                        &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 = SubscribeAllEnvelopesSvc(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)
                }
                _ => {
                    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 NotificationApiServer<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.xmtpv4.message_api.NotificationApi";
    impl<T> tonic::server::NamedService for NotificationApiServer<T> {
        const NAME: &'static str = SERVICE_NAME;
    }
}
/// Generated server implementations.
#[cfg(any(not(target_arch = "wasm32"), feature = "grpc_server_impls"))]
pub mod publish_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 PublishApiServer.
    #[async_trait]
    pub trait PublishApi: std::marker::Send + std::marker::Sync + 'static {
        async fn publish_payer_envelopes(
            &self,
            request: tonic::Request<super::PublishPayerEnvelopesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::PublishPayerEnvelopesResponse>,
            tonic::Status,
        >;
    }
    /// Gateway -> Node.
    #[derive(Debug)]
    pub struct PublishApiServer<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> PublishApiServer<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 PublishApiServer<T>
    where
        T: PublishApi,
        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.xmtpv4.message_api.PublishApi/PublishPayerEnvelopes" => {
                    #[allow(non_camel_case_types)]
                    struct PublishPayerEnvelopesSvc<T: PublishApi>(pub Arc<T>);
                    impl<
                        T: PublishApi,
                    > tonic::server::UnaryService<super::PublishPayerEnvelopesRequest>
                    for PublishPayerEnvelopesSvc<T> {
                        type Response = super::PublishPayerEnvelopesResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::PublishPayerEnvelopesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as PublishApi>::publish_payer_envelopes(&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 = PublishPayerEnvelopesSvc(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 PublishApiServer<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.xmtpv4.message_api.PublishApi";
    impl<T> tonic::server::NamedService for PublishApiServer<T> {
        const NAME: &'static str = SERVICE_NAME;
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LivenessFailure {
    #[prost(uint32, tag = "1")]
    pub response_time_ns: u32,
    #[prost(oneof = "liveness_failure::Request", tags = "2, 3, 4")]
    pub request: ::core::option::Option<liveness_failure::Request>,
}
/// Nested message and enum types in `LivenessFailure`.
pub mod liveness_failure {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Request {
        #[prost(message, tag = "2")]
        Subscribe(super::SubscribeEnvelopesRequest),
        #[prost(message, tag = "3")]
        Query(super::QueryEnvelopesRequest),
        #[prost(message, tag = "4")]
        Publish(super::PublishPayerEnvelopesRequest),
    }
}
impl ::prost::Name for LivenessFailure {
    const NAME: &'static str = "LivenessFailure";
    const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.xmtpv4.message_api.LivenessFailure".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.xmtpv4.message_api.LivenessFailure".into()
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SafetyFailure {
    #[prost(message, repeated, tag = "1")]
    pub envelopes: ::prost::alloc::vec::Vec<super::envelopes::OriginatorEnvelope>,
}
impl ::prost::Name for SafetyFailure {
    const NAME: &'static str = "SafetyFailure";
    const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.xmtpv4.message_api.SafetyFailure".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.xmtpv4.message_api.SafetyFailure".into()
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UnsignedMisbehaviorReport {
    #[prost(uint64, tag = "1")]
    pub reporter_time_ns: u64,
    #[prost(uint32, tag = "2")]
    pub misbehaving_node_id: u32,
    #[prost(enumeration = "Misbehavior", tag = "3")]
    pub r#type: i32,
    /// Nodes must verify this field is false for client-submitted reports
    #[prost(bool, tag = "6")]
    pub submitted_by_node: bool,
    #[prost(oneof = "unsigned_misbehavior_report::Failure", tags = "4, 5")]
    pub failure: ::core::option::Option<unsigned_misbehavior_report::Failure>,
}
/// Nested message and enum types in `UnsignedMisbehaviorReport`.
pub mod unsigned_misbehavior_report {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Failure {
        #[prost(message, tag = "4")]
        Liveness(super::LivenessFailure),
        #[prost(message, tag = "5")]
        Safety(super::SafetyFailure),
    }
}
impl ::prost::Name for UnsignedMisbehaviorReport {
    const NAME: &'static str = "UnsignedMisbehaviorReport";
    const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.xmtpv4.message_api.UnsignedMisbehaviorReport".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.xmtpv4.message_api.UnsignedMisbehaviorReport".into()
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct MisbehaviorReport {
    /// Server time when the report was stored. Used only for querying reports.
    /// This field is not signed.
    #[prost(uint64, tag = "1")]
    pub server_time_ns: u64,
    #[prost(bytes = "vec", tag = "2")]
    pub unsigned_misbehavior_report: ::prost::alloc::vec::Vec<u8>,
    /// Signed by the node hosting the report
    #[prost(message, optional, tag = "3")]
    pub signature: ::core::option::Option<
        super::super::identity::associations::RecoverableEcdsaSignature,
    >,
}
impl ::prost::Name for MisbehaviorReport {
    const NAME: &'static str = "MisbehaviorReport";
    const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.xmtpv4.message_api.MisbehaviorReport".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.xmtpv4.message_api.MisbehaviorReport".into()
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SubmitMisbehaviorReportRequest {
    #[prost(message, optional, tag = "1")]
    pub report: ::core::option::Option<UnsignedMisbehaviorReport>,
}
impl ::prost::Name for SubmitMisbehaviorReportRequest {
    const NAME: &'static str = "SubmitMisbehaviorReportRequest";
    const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.xmtpv4.message_api.SubmitMisbehaviorReportRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.xmtpv4.message_api.SubmitMisbehaviorReportRequest".into()
    }
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SubmitMisbehaviorReportResponse {}
impl ::prost::Name for SubmitMisbehaviorReportResponse {
    const NAME: &'static str = "SubmitMisbehaviorReportResponse";
    const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.xmtpv4.message_api.SubmitMisbehaviorReportResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.xmtpv4.message_api.SubmitMisbehaviorReportResponse".into()
    }
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct QueryMisbehaviorReportsRequest {
    #[prost(uint64, tag = "1")]
    pub after_ns: u64,
}
impl ::prost::Name for QueryMisbehaviorReportsRequest {
    const NAME: &'static str = "QueryMisbehaviorReportsRequest";
    const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.xmtpv4.message_api.QueryMisbehaviorReportsRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.xmtpv4.message_api.QueryMisbehaviorReportsRequest".into()
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryMisbehaviorReportsResponse {
    #[prost(message, repeated, tag = "1")]
    pub reports: ::prost::alloc::vec::Vec<MisbehaviorReport>,
}
impl ::prost::Name for QueryMisbehaviorReportsResponse {
    const NAME: &'static str = "QueryMisbehaviorReportsResponse";
    const PACKAGE: &'static str = "xmtp.xmtpv4.message_api";
    fn full_name() -> ::prost::alloc::string::String {
        "xmtp.xmtpv4.message_api.QueryMisbehaviorReportsResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/xmtp.xmtpv4.message_api.QueryMisbehaviorReportsResponse".into()
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Misbehavior {
    Unspecified = 0,
    UnresponsiveNode = 1,
    SlowNode = 2,
    FailedRequest = 3,
    OutOfOrder = 4,
    DuplicateSequenceId = 5,
    CausalOrdering = 6,
    InvalidPayload = 7,
    BlockchainInconsistency = 8,
}
impl Misbehavior {
    /// 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 => "MISBEHAVIOR_UNSPECIFIED",
            Self::UnresponsiveNode => "MISBEHAVIOR_UNRESPONSIVE_NODE",
            Self::SlowNode => "MISBEHAVIOR_SLOW_NODE",
            Self::FailedRequest => "MISBEHAVIOR_FAILED_REQUEST",
            Self::OutOfOrder => "MISBEHAVIOR_OUT_OF_ORDER",
            Self::DuplicateSequenceId => "MISBEHAVIOR_DUPLICATE_SEQUENCE_ID",
            Self::CausalOrdering => "MISBEHAVIOR_CAUSAL_ORDERING",
            Self::InvalidPayload => "MISBEHAVIOR_INVALID_PAYLOAD",
            Self::BlockchainInconsistency => "MISBEHAVIOR_BLOCKCHAIN_INCONSISTENCY",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "MISBEHAVIOR_UNSPECIFIED" => Some(Self::Unspecified),
            "MISBEHAVIOR_UNRESPONSIVE_NODE" => Some(Self::UnresponsiveNode),
            "MISBEHAVIOR_SLOW_NODE" => Some(Self::SlowNode),
            "MISBEHAVIOR_FAILED_REQUEST" => Some(Self::FailedRequest),
            "MISBEHAVIOR_OUT_OF_ORDER" => Some(Self::OutOfOrder),
            "MISBEHAVIOR_DUPLICATE_SEQUENCE_ID" => Some(Self::DuplicateSequenceId),
            "MISBEHAVIOR_CAUSAL_ORDERING" => Some(Self::CausalOrdering),
            "MISBEHAVIOR_INVALID_PAYLOAD" => Some(Self::InvalidPayload),
            "MISBEHAVIOR_BLOCKCHAIN_INCONSISTENCY" => Some(Self::BlockchainInconsistency),
            _ => None,
        }
    }
}
/// Generated server implementations.
#[cfg(any(not(target_arch = "wasm32"), feature = "grpc_server_impls"))]
pub mod misbehavior_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 MisbehaviorApiServer.
    #[async_trait]
    pub trait MisbehaviorApi: std::marker::Send + std::marker::Sync + 'static {
        async fn submit_misbehavior_report(
            &self,
            request: tonic::Request<super::SubmitMisbehaviorReportRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SubmitMisbehaviorReportResponse>,
            tonic::Status,
        >;
        async fn query_misbehavior_reports(
            &self,
            request: tonic::Request<super::QueryMisbehaviorReportsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::QueryMisbehaviorReportsResponse>,
            tonic::Status,
        >;
    }
    #[derive(Debug)]
    pub struct MisbehaviorApiServer<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> MisbehaviorApiServer<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 MisbehaviorApiServer<T>
    where
        T: MisbehaviorApi,
        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.xmtpv4.message_api.MisbehaviorApi/SubmitMisbehaviorReport" => {
                    #[allow(non_camel_case_types)]
                    struct SubmitMisbehaviorReportSvc<T: MisbehaviorApi>(pub Arc<T>);
                    impl<
                        T: MisbehaviorApi,
                    > tonic::server::UnaryService<super::SubmitMisbehaviorReportRequest>
                    for SubmitMisbehaviorReportSvc<T> {
                        type Response = super::SubmitMisbehaviorReportResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<
                                super::SubmitMisbehaviorReportRequest,
                            >,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as MisbehaviorApi>::submit_misbehavior_report(
                                        &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 = SubmitMisbehaviorReportSvc(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.xmtpv4.message_api.MisbehaviorApi/QueryMisbehaviorReports" => {
                    #[allow(non_camel_case_types)]
                    struct QueryMisbehaviorReportsSvc<T: MisbehaviorApi>(pub Arc<T>);
                    impl<
                        T: MisbehaviorApi,
                    > tonic::server::UnaryService<super::QueryMisbehaviorReportsRequest>
                    for QueryMisbehaviorReportsSvc<T> {
                        type Response = super::QueryMisbehaviorReportsResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<
                                super::QueryMisbehaviorReportsRequest,
                            >,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as MisbehaviorApi>::query_misbehavior_reports(
                                        &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 = QueryMisbehaviorReportsSvc(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 MisbehaviorApiServer<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.xmtpv4.message_api.MisbehaviorApi";
    impl<T> tonic::server::NamedService for MisbehaviorApiServer<T> {
        const NAME: &'static str = SERVICE_NAME;
    }
}
/// Generated server implementations.
#[cfg(any(not(target_arch = "wasm32"), feature = "grpc_server_impls"))]
pub mod query_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 QueryApiServer.
    #[async_trait]
    pub trait QueryApi: std::marker::Send + std::marker::Sync + 'static {
        async fn query_envelopes(
            &self,
            request: tonic::Request<super::QueryEnvelopesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::QueryEnvelopesResponse>,
            tonic::Status,
        >;
        /// Server streaming response type for the SubscribeTopics method.
        type SubscribeTopicsStream: tonic::codegen::tokio_stream::Stream<
                Item = std::result::Result<super::SubscribeTopicsResponse, tonic::Status>,
            >
            + std::marker::Send
            + 'static;
        async fn subscribe_topics(
            &self,
            request: tonic::Request<super::SubscribeTopicsRequest>,
        ) -> std::result::Result<
            tonic::Response<Self::SubscribeTopicsStream>,
            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;
        /// XIP-83 bidirectional mutable subscription: a single long-lived stream the
        /// client mutates in place (add/remove topics) with ping/pong liveness, in
        /// contrast to SubscribeTopics' fixed, immutable, server-streaming filter set.
        /// Bidi streaming requires HTTP/2 (not grpc-web / connect-web); browser
        /// clients stay on SubscribeTopics.
        async fn subscribe(
            &self,
            request: tonic::Request<tonic::Streaming<super::SubscribeRequest>>,
        ) -> std::result::Result<tonic::Response<Self::SubscribeStream>, tonic::Status>;
        async fn get_inbox_ids(
            &self,
            request: tonic::Request<super::GetInboxIdsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetInboxIdsResponse>,
            tonic::Status,
        >;
        async fn get_newest_envelope(
            &self,
            request: tonic::Request<super::GetNewestEnvelopeRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetNewestEnvelopeResponse>,
            tonic::Status,
        >;
    }
    /// Client -> Node. No auth token required.
    #[derive(Debug)]
    pub struct QueryApiServer<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> QueryApiServer<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 QueryApiServer<T>
    where
        T: QueryApi,
        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.xmtpv4.message_api.QueryApi/QueryEnvelopes" => {
                    #[allow(non_camel_case_types)]
                    struct QueryEnvelopesSvc<T: QueryApi>(pub Arc<T>);
                    impl<
                        T: QueryApi,
                    > tonic::server::UnaryService<super::QueryEnvelopesRequest>
                    for QueryEnvelopesSvc<T> {
                        type Response = super::QueryEnvelopesResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::QueryEnvelopesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as QueryApi>::query_envelopes(&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 = QueryEnvelopesSvc(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.xmtpv4.message_api.QueryApi/SubscribeTopics" => {
                    #[allow(non_camel_case_types)]
                    struct SubscribeTopicsSvc<T: QueryApi>(pub Arc<T>);
                    impl<
                        T: QueryApi,
                    > tonic::server::ServerStreamingService<
                        super::SubscribeTopicsRequest,
                    > for SubscribeTopicsSvc<T> {
                        type Response = super::SubscribeTopicsResponse;
                        type ResponseStream = T::SubscribeTopicsStream;
                        type Future = BoxFuture<
                            tonic::Response<Self::ResponseStream>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::SubscribeTopicsRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as QueryApi>::subscribe_topics(&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 = SubscribeTopicsSvc(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.xmtpv4.message_api.QueryApi/Subscribe" => {
                    #[allow(non_camel_case_types)]
                    struct SubscribeSvc<T: QueryApi>(pub Arc<T>);
                    impl<
                        T: QueryApi,
                    > 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 QueryApi>::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.xmtpv4.message_api.QueryApi/GetInboxIds" => {
                    #[allow(non_camel_case_types)]
                    struct GetInboxIdsSvc<T: QueryApi>(pub Arc<T>);
                    impl<
                        T: QueryApi,
                    > tonic::server::UnaryService<super::GetInboxIdsRequest>
                    for GetInboxIdsSvc<T> {
                        type Response = super::GetInboxIdsResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetInboxIdsRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as QueryApi>::get_inbox_ids(&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 = GetInboxIdsSvc(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.xmtpv4.message_api.QueryApi/GetNewestEnvelope" => {
                    #[allow(non_camel_case_types)]
                    struct GetNewestEnvelopeSvc<T: QueryApi>(pub Arc<T>);
                    impl<
                        T: QueryApi,
                    > tonic::server::UnaryService<super::GetNewestEnvelopeRequest>
                    for GetNewestEnvelopeSvc<T> {
                        type Response = super::GetNewestEnvelopeResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetNewestEnvelopeRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as QueryApi>::get_newest_envelope(&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 = GetNewestEnvelopeSvc(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 QueryApiServer<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.xmtpv4.message_api.QueryApi";
    impl<T> tonic::server::NamedService for QueryApiServer<T> {
        const NAME: &'static str = SERVICE_NAME;
    }
}