run-dsrpc 0.0.21-alpha2

// This file is @generated by prost-build.
/// Dataset represents a dataset. What exactly is in a dataset is up to the service.
/// An example of a dataset could be a file that's served, or multiple files
/// that are considered a set.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Dataset {
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub title: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub access_methods: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "4")]
    pub description: ::prost::alloc::vec::Vec<Multilingual>,
    #[prost(string, repeated, tag = "5")]
    pub keywords: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "6")]
    pub creator: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "7")]
    pub issued: ::core::option::Option<::prost_types::Timestamp>,
    #[prost(message, optional, tag = "8")]
    pub modified: ::core::option::Option<::prost_types::Timestamp>,
    #[prost(map = "string, string", tag = "9")]
    pub metadata: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    #[prost(string, optional, tag = "10")]
    pub license: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "11")]
    pub access_rights: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "12")]
    pub rights: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(int64, tag = "13")]
    pub byte_size: i64,
    #[prost(string, tag = "14")]
    pub media_type: ::prost::alloc::string::String,
    #[prost(string, optional, tag = "15")]
    pub format: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "16")]
    pub compress_format: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "17")]
    pub package_format: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "18")]
    pub checksum: ::core::option::Option<Checksum>,
}
/// PublishInfo represents a published file, where to get it and its authentication details.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PublishInfo {
    #[prost(string, tag = "1")]
    pub url: ::prost::alloc::string::String,
    #[prost(enumeration = "AuthenticationType", tag = "2")]
    pub authentication_type: i32,
    #[prost(string, tag = "3")]
    pub username: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub password: ::prost::alloc::string::String,
}
/// Multilingual represents a message with language metadata attached.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Multilingual {
    #[prost(string, tag = "1")]
    pub value: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub language: ::prost::alloc::string::String,
}
/// Checksum represents the checksum of a dataset.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Checksum {
    #[prost(string, tag = "1")]
    pub algorithm: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub value: ::prost::alloc::string::String,
}
/// AuthenticationType represents the way to authenticate to get a published information.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum AuthenticationType {
    Unspecified = 0,
    Bearer = 1,
    Basic = 2,
}
impl AuthenticationType {
    /// 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 => "AUTHENTICATION_TYPE_UNSPECIFIED",
            Self::Bearer => "AUTHENTICATION_TYPE_BEARER",
            Self::Basic => "AUTHENTICATION_TYPE_BASIC",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "AUTHENTICATION_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "AUTHENTICATION_TYPE_BEARER" => Some(Self::Bearer),
            "AUTHENTICATION_TYPE_BASIC" => Some(Self::Basic),
            _ => None,
        }
    }
}
/// PingRequest is an empty message, used instead of the Empty type in case we want
/// to add parameters.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct PingRequest {}
/// PingResponse contains infomational data about the provider.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PingResponse {
    #[prost(string, tag = "1")]
    pub provider_name: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub provider_description: ::prost::alloc::string::String,
    #[prost(bool, tag = "3")]
    pub authenticated: bool,
    /// An ID for the data service, can be any uuid as long as it's consistent.
    #[prost(string, tag = "4")]
    pub dataservice_id: ::prost::alloc::string::String,
    /// dataservice URL where data is downloaded from.
    #[prost(string, tag = "5")]
    pub dataservice_url: ::prost::alloc::string::String,
}
/// GetCatalogRequest represents the parameters for the GetCatalog call.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetCatalogueRequest {
    /// query_parameters is just a key/value map. These are not specified in the dataspace standard.
    /// RUN-DSP also does not define them yet, so for now this is a placeholder.
    #[prost(map = "string, string", tag = "1")]
    pub query_parameters: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// GetCatalogueResponse returns all the datasets matched by GetCatalogue.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetCatalogueResponse {
    #[prost(message, repeated, tag = "1")]
    pub datasets: ::prost::alloc::vec::Vec<Dataset>,
}
/// GetDatasetRequest contains the dataset ID.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetDatasetRequest {
    #[prost(string, tag = "1")]
    pub dataset_id: ::prost::alloc::string::String,
}
/// GetDatasetResponse contains the requested dataset.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetDatasetResponse {
    #[prost(message, optional, tag = "1")]
    pub dataset: ::core::option::Option<Dataset>,
}
/// PublishDatasetRequest contains the ID for the dataset, and a publish ID that's specific to
/// this publish instance. A dataset can be published many concurrent times with different credentials.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PublishDatasetRequest {
    #[prost(string, tag = "1")]
    pub dataset_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub publish_id: ::prost::alloc::string::String,
}
/// PublishDatasetResponse contains the publish information.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PublishDatasetResponse {
    #[prost(message, optional, tag = "1")]
    pub publish_info: ::core::option::Option<PublishInfo>,
}
/// ShutdownTransferRequest contains the publish ID of the published dataset.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ShutdownTransferRequest {
    #[prost(string, tag = "1")]
    pub publish_id: ::prost::alloc::string::String,
}
/// ShutdownTransferResponse contains a boolean indicating success.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ShutdownTransferResponse {
    #[prost(bool, tag = "1")]
    pub success: bool,
}
/// SuspendPublishedDatasetRequest contains the publish ID of the published dataset.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SuspendPublishedDatasetRequest {
    #[prost(string, tag = "1")]
    pub publish_id: ::prost::alloc::string::String,
}
/// SuspendPublshedDatasetResponse indicates success
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct SuspendPublishedDatasetResponse {}
/// UnsuspendPublishedDataset contains the publish ID of the published dataset.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UnsuspendPublishedDatasetRequest {
    #[prost(string, tag = "1")]
    pub publish_id: ::prost::alloc::string::String,
}
/// UnsuspendPublishedDatasetResponse indicates success
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct UnsuspendPublishedDatasetResponse {}
/// Generated client implementations.
pub mod provider_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// The ProviderService is the expected grpc service that RUN-DSP will interface with.
    /// Outside of the defined calls, RUN-DSP will also forward the `authorization` header.
    /// The reason for this is that authorization will vary between dataspaces. Also, the provider
    /// will want to show different data dependent on the credentials.
    #[derive(Debug, Clone)]
    pub struct ProviderServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ProviderServiceClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> ProviderServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> ProviderServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            ProviderServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(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.inner = self.inner.max_decoding_message_size(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.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Ping is a request to test if the provider is working, and to test the auth information.
        pub async fn ping(
            &mut self,
            request: impl tonic::IntoRequest<super::PingRequest>,
        ) -> std::result::Result<tonic::Response<super::PingResponse>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ProviderService/Ping",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("dsp.v1alpha2.ProviderService", "Ping"));
            self.inner.unary(req, path, codec).await
        }
        /// Gets the catalogue based on the query parameters and the authorization header.
        pub async fn get_catalogue(
            &mut self,
            request: impl tonic::IntoRequest<super::GetCatalogueRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetCatalogueResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ProviderService/GetCatalogue",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("dsp.v1alpha2.ProviderService", "GetCatalogue"));
            self.inner.unary(req, path, codec).await
        }
        /// Gets information about a single dataset.
        pub async fn get_dataset(
            &mut self,
            request: impl tonic::IntoRequest<super::GetDatasetRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetDatasetResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ProviderService/GetDataset",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("dsp.v1alpha2.ProviderService", "GetDataset"));
            self.inner.unary(req, path, codec).await
        }
        /// Publishes a dataset,
        pub async fn publish_dataset(
            &mut self,
            request: impl tonic::IntoRequest<super::PublishDatasetRequest>,
        ) -> std::result::Result<
            tonic::Response<super::PublishDatasetResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ProviderService/PublishDataset",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("dsp.v1alpha2.ProviderService", "PublishDataset"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Unpublishes a dataset.
        pub async fn unpublish_dataset(
            &mut self,
            request: impl tonic::IntoRequest<super::ShutdownTransferRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ShutdownTransferResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ProviderService/ShutdownTransfer",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("dsp.v1alpha2.ProviderService", "ShutdownTransfer"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Asks provider to suspend a transfer
        pub async fn suspend_published_dataset(
            &mut self,
            request: impl tonic::IntoRequest<super::SuspendPublishedDatasetRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SuspendPublishedDatasetResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ProviderService/SuspendPublishedDataset",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "dsp.v1alpha2.ProviderService",
                        "SuspendPublishedDataset",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Asks provider to unsuspend (re-publish?) a transfer
        pub async fn unsuspend_published_dataset(
            &mut self,
            request: impl tonic::IntoRequest<super::UnsuspendPublishedDatasetRequest>,
        ) -> std::result::Result<
            tonic::Response<super::UnsuspendPublishedDatasetResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ProviderService/UnsuspendPublishedDataset",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "dsp.v1alpha2.ProviderService",
                        "UnsuspendPublishedDataset",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Generated server implementations.
pub mod provider_service_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 ProviderServiceServer.
    #[async_trait]
    pub trait ProviderService: std::marker::Send + std::marker::Sync + 'static {
        /// Ping is a request to test if the provider is working, and to test the auth information.
        async fn ping(
            &self,
            request: tonic::Request<super::PingRequest>,
        ) -> std::result::Result<tonic::Response<super::PingResponse>, tonic::Status>;
        /// Gets the catalogue based on the query parameters and the authorization header.
        async fn get_catalogue(
            &self,
            request: tonic::Request<super::GetCatalogueRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetCatalogueResponse>,
            tonic::Status,
        >;
        /// Gets information about a single dataset.
        async fn get_dataset(
            &self,
            request: tonic::Request<super::GetDatasetRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetDatasetResponse>,
            tonic::Status,
        >;
        /// Publishes a dataset,
        async fn publish_dataset(
            &self,
            request: tonic::Request<super::PublishDatasetRequest>,
        ) -> std::result::Result<
            tonic::Response<super::PublishDatasetResponse>,
            tonic::Status,
        >;
        /// Unpublishes a dataset.
        async fn unpublish_dataset(
            &self,
            request: tonic::Request<super::ShutdownTransferRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ShutdownTransferResponse>,
            tonic::Status,
        >;
        /// Asks provider to suspend a transfer
        async fn suspend_published_dataset(
            &self,
            request: tonic::Request<super::SuspendPublishedDatasetRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SuspendPublishedDatasetResponse>,
            tonic::Status,
        >;
        /// Asks provider to unsuspend (re-publish?) a transfer
        async fn unsuspend_published_dataset(
            &self,
            request: tonic::Request<super::UnsuspendPublishedDatasetRequest>,
        ) -> std::result::Result<
            tonic::Response<super::UnsuspendPublishedDatasetResponse>,
            tonic::Status,
        >;
    }
    /// The ProviderService is the expected grpc service that RUN-DSP will interface with.
    /// Outside of the defined calls, RUN-DSP will also forward the `authorization` header.
    /// The reason for this is that authorization will vary between dataspaces. Also, the provider
    /// will want to show different data dependent on the credentials.
    #[derive(Debug)]
    pub struct ProviderServiceServer<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> ProviderServiceServer<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 ProviderServiceServer<T>
    where
        T: ProviderService,
        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() {
                "/dsp.v1alpha2.ProviderService/Ping" => {
                    #[allow(non_camel_case_types)]
                    struct PingSvc<T: ProviderService>(pub Arc<T>);
                    impl<
                        T: ProviderService,
                    > tonic::server::UnaryService<super::PingRequest> for PingSvc<T> {
                        type Response = super::PingResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::PingRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ProviderService>::ping(&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 = PingSvc(inner);
                        let codec = tonic::codec::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)
                }
                "/dsp.v1alpha2.ProviderService/GetCatalogue" => {
                    #[allow(non_camel_case_types)]
                    struct GetCatalogueSvc<T: ProviderService>(pub Arc<T>);
                    impl<
                        T: ProviderService,
                    > tonic::server::UnaryService<super::GetCatalogueRequest>
                    for GetCatalogueSvc<T> {
                        type Response = super::GetCatalogueResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetCatalogueRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ProviderService>::get_catalogue(&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 = GetCatalogueSvc(inner);
                        let codec = tonic::codec::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)
                }
                "/dsp.v1alpha2.ProviderService/GetDataset" => {
                    #[allow(non_camel_case_types)]
                    struct GetDatasetSvc<T: ProviderService>(pub Arc<T>);
                    impl<
                        T: ProviderService,
                    > tonic::server::UnaryService<super::GetDatasetRequest>
                    for GetDatasetSvc<T> {
                        type Response = super::GetDatasetResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetDatasetRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ProviderService>::get_dataset(&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 = GetDatasetSvc(inner);
                        let codec = tonic::codec::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)
                }
                "/dsp.v1alpha2.ProviderService/PublishDataset" => {
                    #[allow(non_camel_case_types)]
                    struct PublishDatasetSvc<T: ProviderService>(pub Arc<T>);
                    impl<
                        T: ProviderService,
                    > tonic::server::UnaryService<super::PublishDatasetRequest>
                    for PublishDatasetSvc<T> {
                        type Response = super::PublishDatasetResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::PublishDatasetRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ProviderService>::publish_dataset(&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 = PublishDatasetSvc(inner);
                        let codec = tonic::codec::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)
                }
                "/dsp.v1alpha2.ProviderService/ShutdownTransfer" => {
                    #[allow(non_camel_case_types)]
                    struct ShutdownTransferSvc<T: ProviderService>(pub Arc<T>);
                    impl<
                        T: ProviderService,
                    > tonic::server::UnaryService<super::ShutdownTransferRequest>
                    for ShutdownTransferSvc<T> {
                        type Response = super::ShutdownTransferResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ShutdownTransferRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ProviderService>::unpublish_dataset(&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 = ShutdownTransferSvc(inner);
                        let codec = tonic::codec::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)
                }
                "/dsp.v1alpha2.ProviderService/SuspendPublishedDataset" => {
                    #[allow(non_camel_case_types)]
                    struct SuspendPublishedDatasetSvc<T: ProviderService>(pub Arc<T>);
                    impl<
                        T: ProviderService,
                    > tonic::server::UnaryService<super::SuspendPublishedDatasetRequest>
                    for SuspendPublishedDatasetSvc<T> {
                        type Response = super::SuspendPublishedDatasetResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<
                                super::SuspendPublishedDatasetRequest,
                            >,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ProviderService>::suspend_published_dataset(
                                        &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 = SuspendPublishedDatasetSvc(inner);
                        let codec = tonic::codec::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)
                }
                "/dsp.v1alpha2.ProviderService/UnsuspendPublishedDataset" => {
                    #[allow(non_camel_case_types)]
                    struct UnsuspendPublishedDatasetSvc<T: ProviderService>(pub Arc<T>);
                    impl<
                        T: ProviderService,
                    > tonic::server::UnaryService<
                        super::UnsuspendPublishedDatasetRequest,
                    > for UnsuspendPublishedDatasetSvc<T> {
                        type Response = super::UnsuspendPublishedDatasetResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<
                                super::UnsuspendPublishedDatasetRequest,
                            >,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ProviderService>::unsuspend_published_dataset(
                                        &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 = UnsuspendPublishedDatasetSvc(inner);
                        let codec = tonic::codec::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 ProviderServiceServer<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 = "dsp.v1alpha2.ProviderService";
    impl<T> tonic::server::NamedService for ProviderServiceServer<T> {
        const NAME: &'static str = SERVICE_NAME;
    }
}
/// ContractServiceConfigureRequest represents the configuration request RUN-DSP does to the contract service.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ContractServiceConfigureRequest {
    /// The gRPC address RUN-DSP will listen to for control directives.
    #[prost(string, tag = "1")]
    pub connector_address: ::prost::alloc::string::String,
    /// The verification token generated by RUN-DSP to use when we are verifying the above address.
    #[prost(string, tag = "2")]
    pub verification_token: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ContractServiceConfigureResponse {}
/// ContractServiceRequestReceivedRequest contains the pid RUN-DSP uses to refer to the negotiation and offer contains
/// the raw JSON of the offer ODRL.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ContractServiceRequestReceivedRequest {
    #[prost(string, tag = "1")]
    pub pid: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub offer: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ContractServiceRequestReceivedResponse {}
/// ContractServiceOfferReceivedRequest contains the pid RUN-DSP uses to refer to the negotiation and the raw ODRL offer JSON.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ContractServiceOfferReceivedRequest {
    #[prost(string, tag = "1")]
    pub pid: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub offer: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ContractServiceOfferReceivedResponse {}
/// ContractServiceAcceptedReceivedRequest contains the pid RUN-DSP uses to refer to the negotiation that just got accepted.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ContractServiceAcceptedReceivedRequest {
    #[prost(string, tag = "1")]
    pub pid: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ContractServiceAcceptedReceivedResponse {}
/// ContractServiceAgreementReceivedRequest contains the pid RUN-DSP uses to refer to the negotiation that just got agreed to.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ContractServiceAgreementReceivedRequest {
    #[prost(string, tag = "1")]
    pub pid: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ContractServiceAgreementReceivedResponse {}
/// ContractServiceVerificationReceivedRequest contains the pid RUN-DSP uses to refer to the negotiation that just verified to.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ContractServiceVerificationReceivedRequest {
    #[prost(string, tag = "1")]
    pub pid: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ContractServiceVerificationReceivedResponse {}
/// ContractServiceFinalizationReceivedRequest contains the pid RUN-DSP uses to refer to the negotiation that just got finalized.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ContractServiceFinalizationReceivedRequest {
    #[prost(string, tag = "1")]
    pub pid: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ContractServiceFinalizationReceivedResponse {}
/// ContractServiceTerminationReceivedRequest contains the pid RUN-DSP uses to refer to the negotiation got terminated.
/// It also contains the reason for said termination.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ContractServiceTerminationReceivedRequest {
    #[prost(string, tag = "1")]
    pub pid: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub code: ::prost::alloc::string::String,
    #[prost(string, repeated, tag = "3")]
    pub reason: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ContractServiceTerminationReceivedResponse {}
/// Generated client implementations.
pub mod contract_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// The ContractService allows RUN-DSP to call an external service to approve/terminate contract
    /// negotiation steps.
    /// Outside of the defined calls, RUN-DSP will also forward the `authorization` header so that
    /// the caller can be verified by the service.
    #[derive(Debug, Clone)]
    pub struct ContractServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ContractServiceClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> ContractServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> ContractServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            ContractServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(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.inner = self.inner.max_decoding_message_size(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.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Configure sets some callback configuration parameters.
        pub async fn configure(
            &mut self,
            request: impl tonic::IntoRequest<super::ContractServiceConfigureRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ContractServiceConfigureResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ContractService/Configure",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("dsp.v1alpha2.ContractService", "Configure"));
            self.inner.unary(req, path, codec).await
        }
        /// RequestReceived is called when RUN-DSP receives a ContractRequestMessage.
        pub async fn request_received(
            &mut self,
            request: impl tonic::IntoRequest<
                super::ContractServiceRequestReceivedRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::ContractServiceRequestReceivedResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ContractService/RequestReceived",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("dsp.v1alpha2.ContractService", "RequestReceived"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// OfferReceived is called when RUN-DSP receives a ContractOfferMessage.
        pub async fn offer_received(
            &mut self,
            request: impl tonic::IntoRequest<super::ContractServiceOfferReceivedRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ContractServiceOfferReceivedResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ContractService/OfferReceived",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("dsp.v1alpha2.ContractService", "OfferReceived"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// AcceptedReceived is called when RUN-DSP receives an Accepted event message.
        pub async fn accepted_received(
            &mut self,
            request: impl tonic::IntoRequest<
                super::ContractServiceAcceptedReceivedRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::ContractServiceAcceptedReceivedResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ContractService/AcceptedReceived",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("dsp.v1alpha2.ContractService", "AcceptedReceived"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// AgreementReceived is called when RUN-DSP receives a ContractAgreementMessage.
        pub async fn agreement_received(
            &mut self,
            request: impl tonic::IntoRequest<
                super::ContractServiceAgreementReceivedRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::ContractServiceAgreementReceivedResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ContractService/AgreementReceived",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("dsp.v1alpha2.ContractService", "AgreementReceived"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// VerificationReceived is called when RUN-DSP receives a ContractVerificationMessage.
        pub async fn verification_received(
            &mut self,
            request: impl tonic::IntoRequest<
                super::ContractServiceVerificationReceivedRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::ContractServiceVerificationReceivedResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ContractService/VerificationReceived",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "dsp.v1alpha2.ContractService",
                        "VerificationReceived",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// FinalizationReceived is called when RUN-DSP receives a Finalized event message.
        pub async fn finalization_received(
            &mut self,
            request: impl tonic::IntoRequest<
                super::ContractServiceFinalizationReceivedRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::ContractServiceFinalizationReceivedResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ContractService/FinalizationReceived",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "dsp.v1alpha2.ContractService",
                        "FinalizationReceived",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// TerminationReceived is called when RUN-DSP receives a ContractTerminationMessage
        pub async fn termination_received(
            &mut self,
            request: impl tonic::IntoRequest<
                super::ContractServiceTerminationReceivedRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::ContractServiceTerminationReceivedResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ContractService/TerminationReceived",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "dsp.v1alpha2.ContractService",
                        "TerminationReceived",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Generated server implementations.
pub mod contract_service_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 ContractServiceServer.
    #[async_trait]
    pub trait ContractService: std::marker::Send + std::marker::Sync + 'static {
        /// Configure sets some callback configuration parameters.
        async fn configure(
            &self,
            request: tonic::Request<super::ContractServiceConfigureRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ContractServiceConfigureResponse>,
            tonic::Status,
        >;
        /// RequestReceived is called when RUN-DSP receives a ContractRequestMessage.
        async fn request_received(
            &self,
            request: tonic::Request<super::ContractServiceRequestReceivedRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ContractServiceRequestReceivedResponse>,
            tonic::Status,
        >;
        /// OfferReceived is called when RUN-DSP receives a ContractOfferMessage.
        async fn offer_received(
            &self,
            request: tonic::Request<super::ContractServiceOfferReceivedRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ContractServiceOfferReceivedResponse>,
            tonic::Status,
        >;
        /// AcceptedReceived is called when RUN-DSP receives an Accepted event message.
        async fn accepted_received(
            &self,
            request: tonic::Request<super::ContractServiceAcceptedReceivedRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ContractServiceAcceptedReceivedResponse>,
            tonic::Status,
        >;
        /// AgreementReceived is called when RUN-DSP receives a ContractAgreementMessage.
        async fn agreement_received(
            &self,
            request: tonic::Request<super::ContractServiceAgreementReceivedRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ContractServiceAgreementReceivedResponse>,
            tonic::Status,
        >;
        /// VerificationReceived is called when RUN-DSP receives a ContractVerificationMessage.
        async fn verification_received(
            &self,
            request: tonic::Request<super::ContractServiceVerificationReceivedRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ContractServiceVerificationReceivedResponse>,
            tonic::Status,
        >;
        /// FinalizationReceived is called when RUN-DSP receives a Finalized event message.
        async fn finalization_received(
            &self,
            request: tonic::Request<super::ContractServiceFinalizationReceivedRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ContractServiceFinalizationReceivedResponse>,
            tonic::Status,
        >;
        /// TerminationReceived is called when RUN-DSP receives a ContractTerminationMessage
        async fn termination_received(
            &self,
            request: tonic::Request<super::ContractServiceTerminationReceivedRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ContractServiceTerminationReceivedResponse>,
            tonic::Status,
        >;
    }
    /// The ContractService allows RUN-DSP to call an external service to approve/terminate contract
    /// negotiation steps.
    /// Outside of the defined calls, RUN-DSP will also forward the `authorization` header so that
    /// the caller can be verified by the service.
    #[derive(Debug)]
    pub struct ContractServiceServer<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> ContractServiceServer<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 ContractServiceServer<T>
    where
        T: ContractService,
        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() {
                "/dsp.v1alpha2.ContractService/Configure" => {
                    #[allow(non_camel_case_types)]
                    struct ConfigureSvc<T: ContractService>(pub Arc<T>);
                    impl<
                        T: ContractService,
                    > tonic::server::UnaryService<super::ContractServiceConfigureRequest>
                    for ConfigureSvc<T> {
                        type Response = super::ContractServiceConfigureResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<
                                super::ContractServiceConfigureRequest,
                            >,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ContractService>::configure(&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 = ConfigureSvc(inner);
                        let codec = tonic::codec::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)
                }
                "/dsp.v1alpha2.ContractService/RequestReceived" => {
                    #[allow(non_camel_case_types)]
                    struct RequestReceivedSvc<T: ContractService>(pub Arc<T>);
                    impl<
                        T: ContractService,
                    > tonic::server::UnaryService<
                        super::ContractServiceRequestReceivedRequest,
                    > for RequestReceivedSvc<T> {
                        type Response = super::ContractServiceRequestReceivedResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<
                                super::ContractServiceRequestReceivedRequest,
                            >,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ContractService>::request_received(&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 = RequestReceivedSvc(inner);
                        let codec = tonic::codec::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)
                }
                "/dsp.v1alpha2.ContractService/OfferReceived" => {
                    #[allow(non_camel_case_types)]
                    struct OfferReceivedSvc<T: ContractService>(pub Arc<T>);
                    impl<
                        T: ContractService,
                    > tonic::server::UnaryService<
                        super::ContractServiceOfferReceivedRequest,
                    > for OfferReceivedSvc<T> {
                        type Response = super::ContractServiceOfferReceivedResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<
                                super::ContractServiceOfferReceivedRequest,
                            >,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ContractService>::offer_received(&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 = OfferReceivedSvc(inner);
                        let codec = tonic::codec::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)
                }
                "/dsp.v1alpha2.ContractService/AcceptedReceived" => {
                    #[allow(non_camel_case_types)]
                    struct AcceptedReceivedSvc<T: ContractService>(pub Arc<T>);
                    impl<
                        T: ContractService,
                    > tonic::server::UnaryService<
                        super::ContractServiceAcceptedReceivedRequest,
                    > for AcceptedReceivedSvc<T> {
                        type Response = super::ContractServiceAcceptedReceivedResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<
                                super::ContractServiceAcceptedReceivedRequest,
                            >,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ContractService>::accepted_received(&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 = AcceptedReceivedSvc(inner);
                        let codec = tonic::codec::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)
                }
                "/dsp.v1alpha2.ContractService/AgreementReceived" => {
                    #[allow(non_camel_case_types)]
                    struct AgreementReceivedSvc<T: ContractService>(pub Arc<T>);
                    impl<
                        T: ContractService,
                    > tonic::server::UnaryService<
                        super::ContractServiceAgreementReceivedRequest,
                    > for AgreementReceivedSvc<T> {
                        type Response = super::ContractServiceAgreementReceivedResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<
                                super::ContractServiceAgreementReceivedRequest,
                            >,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ContractService>::agreement_received(&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 = AgreementReceivedSvc(inner);
                        let codec = tonic::codec::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)
                }
                "/dsp.v1alpha2.ContractService/VerificationReceived" => {
                    #[allow(non_camel_case_types)]
                    struct VerificationReceivedSvc<T: ContractService>(pub Arc<T>);
                    impl<
                        T: ContractService,
                    > tonic::server::UnaryService<
                        super::ContractServiceVerificationReceivedRequest,
                    > for VerificationReceivedSvc<T> {
                        type Response = super::ContractServiceVerificationReceivedResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<
                                super::ContractServiceVerificationReceivedRequest,
                            >,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ContractService>::verification_received(
                                        &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 = VerificationReceivedSvc(inner);
                        let codec = tonic::codec::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)
                }
                "/dsp.v1alpha2.ContractService/FinalizationReceived" => {
                    #[allow(non_camel_case_types)]
                    struct FinalizationReceivedSvc<T: ContractService>(pub Arc<T>);
                    impl<
                        T: ContractService,
                    > tonic::server::UnaryService<
                        super::ContractServiceFinalizationReceivedRequest,
                    > for FinalizationReceivedSvc<T> {
                        type Response = super::ContractServiceFinalizationReceivedResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<
                                super::ContractServiceFinalizationReceivedRequest,
                            >,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ContractService>::finalization_received(
                                        &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 = FinalizationReceivedSvc(inner);
                        let codec = tonic::codec::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)
                }
                "/dsp.v1alpha2.ContractService/TerminationReceived" => {
                    #[allow(non_camel_case_types)]
                    struct TerminationReceivedSvc<T: ContractService>(pub Arc<T>);
                    impl<
                        T: ContractService,
                    > tonic::server::UnaryService<
                        super::ContractServiceTerminationReceivedRequest,
                    > for TerminationReceivedSvc<T> {
                        type Response = super::ContractServiceTerminationReceivedResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<
                                super::ContractServiceTerminationReceivedRequest,
                            >,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ContractService>::termination_received(
                                        &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 = TerminationReceivedSvc(inner);
                        let codec = tonic::codec::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 ContractServiceServer<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 = "dsp.v1alpha2.ContractService";
    impl<T> tonic::server::NamedService for ContractServiceServer<T> {
        const NAME: &'static str = SERVICE_NAME;
    }
}
/// VerifyConnectionRequest contains a verification token that can be compared to the one locally generated.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VerifyConnectionRequest {
    #[prost(string, tag = "1")]
    pub verification_token: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct VerifyConnectionResponse {}
/// GetProviderCatalogueRequest represents the parameters for the GetProviderCatalogue request
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetProviderCatalogueRequest {
    /// query_parameters is just a key/value map. These are not specified in the dataspace standard.
    /// RUN-DSP also does not define them yet, so for now this is a placeholder.
    #[prost(string, tag = "1")]
    pub provider_uri: ::prost::alloc::string::String,
    #[prost(map = "string, string", tag = "2")]
    pub query_parameters: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// GetProviderCatalogueResponse returns all the datasets matched by GetProviderCatalogue.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetProviderCatalogueResponse {
    #[prost(message, repeated, tag = "1")]
    pub datasets: ::prost::alloc::vec::Vec<Dataset>,
}
/// GetProviderDatasetRequest contains the dataset ID.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetProviderDatasetRequest {
    #[prost(string, tag = "1")]
    pub provider_url: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub dataset_id: ::prost::alloc::string::String,
}
/// GetProviderDatasetResponse contains the requested dataset.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetProviderDatasetResponse {
    #[prost(string, tag = "1")]
    pub provider_url: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub dataset: ::core::option::Option<Dataset>,
}
/// GetProviderDatasetDownloadInformationRequest contains the ID for the dataset
/// we want to be able to download.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetProviderDatasetDownloadInformationRequest {
    #[prost(string, tag = "1")]
    pub provider_url: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub dataset_id: ::prost::alloc::string::String,
}
/// GetProviderDatasetDownloadInformationResponse contains the information needed
/// to download a file, including authentication etc.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetProviderDatasetDownloadInformationResponse {
    #[prost(message, optional, tag = "1")]
    pub publish_info: ::core::option::Option<PublishInfo>,
    #[prost(string, tag = "2")]
    pub transfer_id: ::prost::alloc::string::String,
}
/// ContractRequestRequest contains the offer, and a pid if this is needs to send a request for an already
/// existing offer, or a participant_address if this is a request for a new offer.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ContractRequestRequest {
    #[prost(string, tag = "1")]
    pub offer: ::prost::alloc::string::String,
    #[prost(string, optional, tag = "2")]
    pub pid: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "3")]
    pub participant_address: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(bool, tag = "4")]
    pub auto_accept: bool,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ContractRequestResponse {}
/// ContractOfferRequest contains the offer, and a pid if this is needs to send an offer for an already
/// existing offer, or a participant_address if this is a a new offer.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ContractOfferRequest {
    #[prost(string, tag = "1")]
    pub offer: ::prost::alloc::string::String,
    #[prost(string, optional, tag = "2")]
    pub pid: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "3")]
    pub participant_address: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(bool, tag = "4")]
    pub auto_accept: bool,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ContractOfferResponse {}
/// ContractAcceptRequest contains the pid of the contract negotiation to be accepted.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ContractAcceptRequest {
    #[prost(string, tag = "1")]
    pub pid: ::prost::alloc::string::String,
    #[prost(bool, tag = "2")]
    pub auto_accept: bool,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ContractAcceptResponse {}
/// ContractAgreeRequest contains the agreement and pid of the contract negotiation to agree to.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ContractAgreeRequest {
    #[prost(string, tag = "1")]
    pub agreement: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub pid: ::prost::alloc::string::String,
    #[prost(bool, tag = "3")]
    pub auto_accept: bool,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ContractAgreeResponse {}
/// ContractVerifyRequest contains the pid of the contract negotiation to verify.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ContractVerifyRequest {
    #[prost(string, tag = "1")]
    pub pid: ::prost::alloc::string::String,
    /// signals to RUN-DSP that it should auto accept the negotiation and not wait for any requests of the contract service.
    #[prost(bool, tag = "2")]
    pub auto_accept: bool,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ContractVerifyResponse {}
/// ContractFinalizeRequest contains the pid of the contract negotiation to finalize.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ContractFinalizeRequest {
    #[prost(string, tag = "1")]
    pub pid: ::prost::alloc::string::String,
    #[prost(bool, tag = "2")]
    pub auto_accept: bool,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ContractFinalizeResponse {}
/// ContractTerminateRequest contains the pid, code, and reason of the contract negotiation to terminate.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ContractTerminateRequest {
    #[prost(string, tag = "1")]
    pub pid: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub code: ::prost::alloc::string::String,
    #[prost(string, repeated, tag = "3")]
    pub reason: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ContractTerminateResponse {}
/// SignalTransferCompleteRequest is for telling the provider that we are done
/// receiving the dataset.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SignalTransferCompleteRequest {
    #[prost(string, tag = "1")]
    pub transfer_id: ::prost::alloc::string::String,
}
/// SignalTransferCompleteResponse is received when we successfully sent a
/// transfer complete request.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct SignalTransferCompleteResponse {}
/// SignalTransferCancelledRequest is sent when the client wants to cancel a transfer.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SignalTransferCancelledRequest {
    #[prost(string, tag = "1")]
    pub transfer_id: ::prost::alloc::string::String,
}
/// SignalTransferCancelledResponse tells that the cancellation requests was received.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct SignalTransferCancelledResponse {}
/// SignalTransferSuspendRequest is sent when the client wishes to pause the transfer.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SignalTransferSuspendRequest {
    #[prost(string, tag = "1")]
    pub transfer_id: ::prost::alloc::string::String,
}
/// SignalTransferSuspendResponse tells the client that the pause request was received.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct SignalTransferSuspendResponse {}
/// SignalTransferResumeRequest tells the provider that the client wants to resume transfer.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SignalTransferResumeRequest {
    #[prost(string, tag = "1")]
    pub transfer_id: ::prost::alloc::string::String,
}
/// SignalTransferResumeResponse tells the client that the resume request was accepted.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct SignalTransferResumeResponse {}
/// Generated client implementations.
pub mod control_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// ControlService contains methods that are not specific to catalogue, contract, or transfer operations.
    /// Configuration, and convenience methods will be put here.
    #[derive(Debug, Clone)]
    pub struct ControlServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ControlServiceClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> ControlServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> ControlServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            ControlServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(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.inner = self.inner.max_decoding_message_size(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.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Publishes a dataset,
        pub async fn get_provider_dataset_download_information(
            &mut self,
            request: impl tonic::IntoRequest<
                super::GetProviderDatasetDownloadInformationRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::GetProviderDatasetDownloadInformationResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ControlService/GetProviderDatasetDownloadInformation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "dsp.v1alpha2.ControlService",
                        "GetProviderDatasetDownloadInformation",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// VerifyConnection takes a token and verifies it's the same token it passed to the contract service.
        pub async fn verify_connection(
            &mut self,
            request: impl tonic::IntoRequest<super::VerifyConnectionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::VerifyConnectionResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ControlService/VerifyConnection",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("dsp.v1alpha2.ControlService", "VerifyConnection"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets the catalogue based on the query parameters and the authorization header.
        pub async fn get_provider_catalogue(
            &mut self,
            request: impl tonic::IntoRequest<super::GetProviderCatalogueRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetProviderCatalogueResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ControlService/GetProviderCatalogue",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "dsp.v1alpha2.ControlService",
                        "GetProviderCatalogue",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets information about a single dataset.
        pub async fn get_provider_dataset(
            &mut self,
            request: impl tonic::IntoRequest<super::GetProviderDatasetRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetProviderDatasetResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ControlService/GetProviderDataset",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("dsp.v1alpha2.ControlService", "GetProviderDataset"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// ContractRequest sends a ContractRequestMessage.
        pub async fn contract_request(
            &mut self,
            request: impl tonic::IntoRequest<super::ContractRequestRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ContractRequestResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ControlService/ContractRequest",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("dsp.v1alpha2.ControlService", "ContractRequest"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// ContractOffer sends a ContractOfferMessage.
        pub async fn contract_offer(
            &mut self,
            request: impl tonic::IntoRequest<super::ContractOfferRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ContractOfferResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ControlService/ContractOffer",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("dsp.v1alpha2.ControlService", "ContractOffer"));
            self.inner.unary(req, path, codec).await
        }
        /// ContractAccept sends an accepted event message.
        pub async fn contract_accept(
            &mut self,
            request: impl tonic::IntoRequest<super::ContractAcceptRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ContractAcceptResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ControlService/ContractAccept",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("dsp.v1alpha2.ControlService", "ContractAccept"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// ContractAgree sends a ContractAcceptedMessage.
        pub async fn contract_agree(
            &mut self,
            request: impl tonic::IntoRequest<super::ContractAgreeRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ContractAgreeResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ControlService/ContractAgree",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("dsp.v1alpha2.ControlService", "ContractAgree"));
            self.inner.unary(req, path, codec).await
        }
        /// ContractVerify sends a ContractVerificationMessage.
        pub async fn contract_verify(
            &mut self,
            request: impl tonic::IntoRequest<super::ContractVerifyRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ContractVerifyResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ControlService/ContractVerify",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("dsp.v1alpha2.ControlService", "ContractVerify"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// ContractFinalize sends a finalization event.
        pub async fn contract_finalize(
            &mut self,
            request: impl tonic::IntoRequest<super::ContractFinalizeRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ContractFinalizeResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ControlService/ContractFinalize",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("dsp.v1alpha2.ControlService", "ContractFinalize"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// ContractTerminate sends a ContractTerminationMessage.
        pub async fn contract_terminate(
            &mut self,
            request: impl tonic::IntoRequest<super::ContractTerminateRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ContractTerminateResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ControlService/ContractTerminate",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("dsp.v1alpha2.ControlService", "ContractTerminate"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Tells provider that we have finished our transfer.
        pub async fn signal_transfer_complete(
            &mut self,
            request: impl tonic::IntoRequest<super::SignalTransferCompleteRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SignalTransferCompleteResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ControlService/SignalTransferComplete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "dsp.v1alpha2.ControlService",
                        "SignalTransferComplete",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Tells provider to cancel file transfer
        pub async fn signal_transfer_cancelled(
            &mut self,
            request: impl tonic::IntoRequest<super::SignalTransferCancelledRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SignalTransferCancelledResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ControlService/SignalTransferCancelled",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "dsp.v1alpha2.ControlService",
                        "SignalTransferCancelled",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Tells provider to suspend file transfer
        pub async fn signal_transfer_suspend(
            &mut self,
            request: impl tonic::IntoRequest<super::SignalTransferSuspendRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SignalTransferSuspendResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ControlService/SignalTransferSuspend",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "dsp.v1alpha2.ControlService",
                        "SignalTransferSuspend",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Tells provider to resume file transfer
        pub async fn signal_transfer_resume(
            &mut self,
            request: impl tonic::IntoRequest<super::SignalTransferResumeRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SignalTransferResumeResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/dsp.v1alpha2.ControlService/SignalTransferResume",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "dsp.v1alpha2.ControlService",
                        "SignalTransferResume",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Generated server implementations.
pub mod control_service_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 ControlServiceServer.
    #[async_trait]
    pub trait ControlService: std::marker::Send + std::marker::Sync + 'static {
        /// Publishes a dataset,
        async fn get_provider_dataset_download_information(
            &self,
            request: tonic::Request<super::GetProviderDatasetDownloadInformationRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetProviderDatasetDownloadInformationResponse>,
            tonic::Status,
        >;
        /// VerifyConnection takes a token and verifies it's the same token it passed to the contract service.
        async fn verify_connection(
            &self,
            request: tonic::Request<super::VerifyConnectionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::VerifyConnectionResponse>,
            tonic::Status,
        >;
        /// Gets the catalogue based on the query parameters and the authorization header.
        async fn get_provider_catalogue(
            &self,
            request: tonic::Request<super::GetProviderCatalogueRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetProviderCatalogueResponse>,
            tonic::Status,
        >;
        /// Gets information about a single dataset.
        async fn get_provider_dataset(
            &self,
            request: tonic::Request<super::GetProviderDatasetRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetProviderDatasetResponse>,
            tonic::Status,
        >;
        /// ContractRequest sends a ContractRequestMessage.
        async fn contract_request(
            &self,
            request: tonic::Request<super::ContractRequestRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ContractRequestResponse>,
            tonic::Status,
        >;
        /// ContractOffer sends a ContractOfferMessage.
        async fn contract_offer(
            &self,
            request: tonic::Request<super::ContractOfferRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ContractOfferResponse>,
            tonic::Status,
        >;
        /// ContractAccept sends an accepted event message.
        async fn contract_accept(
            &self,
            request: tonic::Request<super::ContractAcceptRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ContractAcceptResponse>,
            tonic::Status,
        >;
        /// ContractAgree sends a ContractAcceptedMessage.
        async fn contract_agree(
            &self,
            request: tonic::Request<super::ContractAgreeRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ContractAgreeResponse>,
            tonic::Status,
        >;
        /// ContractVerify sends a ContractVerificationMessage.
        async fn contract_verify(
            &self,
            request: tonic::Request<super::ContractVerifyRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ContractVerifyResponse>,
            tonic::Status,
        >;
        /// ContractFinalize sends a finalization event.
        async fn contract_finalize(
            &self,
            request: tonic::Request<super::ContractFinalizeRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ContractFinalizeResponse>,
            tonic::Status,
        >;
        /// ContractTerminate sends a ContractTerminationMessage.
        async fn contract_terminate(
            &self,
            request: tonic::Request<super::ContractTerminateRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ContractTerminateResponse>,
            tonic::Status,
        >;
        /// Tells provider that we have finished our transfer.
        async fn signal_transfer_complete(
            &self,
            request: tonic::Request<super::SignalTransferCompleteRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SignalTransferCompleteResponse>,
            tonic::Status,
        >;
        /// Tells provider to cancel file transfer
        async fn signal_transfer_cancelled(
            &self,
            request: tonic::Request<super::SignalTransferCancelledRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SignalTransferCancelledResponse>,
            tonic::Status,
        >;
        /// Tells provider to suspend file transfer
        async fn signal_transfer_suspend(
            &self,
            request: tonic::Request<super::SignalTransferSuspendRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SignalTransferSuspendResponse>,
            tonic::Status,
        >;
        /// Tells provider to resume file transfer
        async fn signal_transfer_resume(
            &self,
            request: tonic::Request<super::SignalTransferResumeRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SignalTransferResumeResponse>,
            tonic::Status,
        >;
    }
    /// ControlService contains methods that are not specific to catalogue, contract, or transfer operations.
    /// Configuration, and convenience methods will be put here.
    #[derive(Debug)]
    pub struct ControlServiceServer<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> ControlServiceServer<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 ControlServiceServer<T>
    where
        T: ControlService,
        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() {
                "/dsp.v1alpha2.ControlService/GetProviderDatasetDownloadInformation" => {
                    #[allow(non_camel_case_types)]
                    struct GetProviderDatasetDownloadInformationSvc<T: ControlService>(
                        pub Arc<T>,
                    );
                    impl<
                        T: ControlService,
                    > tonic::server::UnaryService<
                        super::GetProviderDatasetDownloadInformationRequest,
                    > for GetProviderDatasetDownloadInformationSvc<T> {
                        type Response = super::GetProviderDatasetDownloadInformationResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<
                                super::GetProviderDatasetDownloadInformationRequest,
                            >,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ControlService>::get_provider_dataset_download_information(
                                        &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 = GetProviderDatasetDownloadInformationSvc(inner);
                        let codec = tonic::codec::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)
                }
                "/dsp.v1alpha2.ControlService/VerifyConnection" => {
                    #[allow(non_camel_case_types)]
                    struct VerifyConnectionSvc<T: ControlService>(pub Arc<T>);
                    impl<
                        T: ControlService,
                    > tonic::server::UnaryService<super::VerifyConnectionRequest>
                    for VerifyConnectionSvc<T> {
                        type Response = super::VerifyConnectionResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::VerifyConnectionRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ControlService>::verify_connection(&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 = VerifyConnectionSvc(inner);
                        let codec = tonic::codec::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)
                }
                "/dsp.v1alpha2.ControlService/GetProviderCatalogue" => {
                    #[allow(non_camel_case_types)]
                    struct GetProviderCatalogueSvc<T: ControlService>(pub Arc<T>);
                    impl<
                        T: ControlService,
                    > tonic::server::UnaryService<super::GetProviderCatalogueRequest>
                    for GetProviderCatalogueSvc<T> {
                        type Response = super::GetProviderCatalogueResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetProviderCatalogueRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ControlService>::get_provider_catalogue(
                                        &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 = GetProviderCatalogueSvc(inner);
                        let codec = tonic::codec::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)
                }
                "/dsp.v1alpha2.ControlService/GetProviderDataset" => {
                    #[allow(non_camel_case_types)]
                    struct GetProviderDatasetSvc<T: ControlService>(pub Arc<T>);
                    impl<
                        T: ControlService,
                    > tonic::server::UnaryService<super::GetProviderDatasetRequest>
                    for GetProviderDatasetSvc<T> {
                        type Response = super::GetProviderDatasetResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetProviderDatasetRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ControlService>::get_provider_dataset(&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 = GetProviderDatasetSvc(inner);
                        let codec = tonic::codec::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)
                }
                "/dsp.v1alpha2.ControlService/ContractRequest" => {
                    #[allow(non_camel_case_types)]
                    struct ContractRequestSvc<T: ControlService>(pub Arc<T>);
                    impl<
                        T: ControlService,
                    > tonic::server::UnaryService<super::ContractRequestRequest>
                    for ContractRequestSvc<T> {
                        type Response = super::ContractRequestResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ContractRequestRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ControlService>::contract_request(&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 = ContractRequestSvc(inner);
                        let codec = tonic::codec::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)
                }
                "/dsp.v1alpha2.ControlService/ContractOffer" => {
                    #[allow(non_camel_case_types)]
                    struct ContractOfferSvc<T: ControlService>(pub Arc<T>);
                    impl<
                        T: ControlService,
                    > tonic::server::UnaryService<super::ContractOfferRequest>
                    for ContractOfferSvc<T> {
                        type Response = super::ContractOfferResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ContractOfferRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ControlService>::contract_offer(&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 = ContractOfferSvc(inner);
                        let codec = tonic::codec::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)
                }
                "/dsp.v1alpha2.ControlService/ContractAccept" => {
                    #[allow(non_camel_case_types)]
                    struct ContractAcceptSvc<T: ControlService>(pub Arc<T>);
                    impl<
                        T: ControlService,
                    > tonic::server::UnaryService<super::ContractAcceptRequest>
                    for ContractAcceptSvc<T> {
                        type Response = super::ContractAcceptResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ContractAcceptRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ControlService>::contract_accept(&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 = ContractAcceptSvc(inner);
                        let codec = tonic::codec::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)
                }
                "/dsp.v1alpha2.ControlService/ContractAgree" => {
                    #[allow(non_camel_case_types)]
                    struct ContractAgreeSvc<T: ControlService>(pub Arc<T>);
                    impl<
                        T: ControlService,
                    > tonic::server::UnaryService<super::ContractAgreeRequest>
                    for ContractAgreeSvc<T> {
                        type Response = super::ContractAgreeResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ContractAgreeRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ControlService>::contract_agree(&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 = ContractAgreeSvc(inner);
                        let codec = tonic::codec::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)
                }
                "/dsp.v1alpha2.ControlService/ContractVerify" => {
                    #[allow(non_camel_case_types)]
                    struct ContractVerifySvc<T: ControlService>(pub Arc<T>);
                    impl<
                        T: ControlService,
                    > tonic::server::UnaryService<super::ContractVerifyRequest>
                    for ContractVerifySvc<T> {
                        type Response = super::ContractVerifyResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ContractVerifyRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ControlService>::contract_verify(&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 = ContractVerifySvc(inner);
                        let codec = tonic::codec::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)
                }
                "/dsp.v1alpha2.ControlService/ContractFinalize" => {
                    #[allow(non_camel_case_types)]
                    struct ContractFinalizeSvc<T: ControlService>(pub Arc<T>);
                    impl<
                        T: ControlService,
                    > tonic::server::UnaryService<super::ContractFinalizeRequest>
                    for ContractFinalizeSvc<T> {
                        type Response = super::ContractFinalizeResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ContractFinalizeRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ControlService>::contract_finalize(&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 = ContractFinalizeSvc(inner);
                        let codec = tonic::codec::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)
                }
                "/dsp.v1alpha2.ControlService/ContractTerminate" => {
                    #[allow(non_camel_case_types)]
                    struct ContractTerminateSvc<T: ControlService>(pub Arc<T>);
                    impl<
                        T: ControlService,
                    > tonic::server::UnaryService<super::ContractTerminateRequest>
                    for ContractTerminateSvc<T> {
                        type Response = super::ContractTerminateResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ContractTerminateRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ControlService>::contract_terminate(&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 = ContractTerminateSvc(inner);
                        let codec = tonic::codec::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)
                }
                "/dsp.v1alpha2.ControlService/SignalTransferComplete" => {
                    #[allow(non_camel_case_types)]
                    struct SignalTransferCompleteSvc<T: ControlService>(pub Arc<T>);
                    impl<
                        T: ControlService,
                    > tonic::server::UnaryService<super::SignalTransferCompleteRequest>
                    for SignalTransferCompleteSvc<T> {
                        type Response = super::SignalTransferCompleteResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::SignalTransferCompleteRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ControlService>::signal_transfer_complete(
                                        &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 = SignalTransferCompleteSvc(inner);
                        let codec = tonic::codec::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)
                }
                "/dsp.v1alpha2.ControlService/SignalTransferCancelled" => {
                    #[allow(non_camel_case_types)]
                    struct SignalTransferCancelledSvc<T: ControlService>(pub Arc<T>);
                    impl<
                        T: ControlService,
                    > tonic::server::UnaryService<super::SignalTransferCancelledRequest>
                    for SignalTransferCancelledSvc<T> {
                        type Response = super::SignalTransferCancelledResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<
                                super::SignalTransferCancelledRequest,
                            >,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ControlService>::signal_transfer_cancelled(
                                        &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 = SignalTransferCancelledSvc(inner);
                        let codec = tonic::codec::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)
                }
                "/dsp.v1alpha2.ControlService/SignalTransferSuspend" => {
                    #[allow(non_camel_case_types)]
                    struct SignalTransferSuspendSvc<T: ControlService>(pub Arc<T>);
                    impl<
                        T: ControlService,
                    > tonic::server::UnaryService<super::SignalTransferSuspendRequest>
                    for SignalTransferSuspendSvc<T> {
                        type Response = super::SignalTransferSuspendResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::SignalTransferSuspendRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ControlService>::signal_transfer_suspend(
                                        &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 = SignalTransferSuspendSvc(inner);
                        let codec = tonic::codec::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)
                }
                "/dsp.v1alpha2.ControlService/SignalTransferResume" => {
                    #[allow(non_camel_case_types)]
                    struct SignalTransferResumeSvc<T: ControlService>(pub Arc<T>);
                    impl<
                        T: ControlService,
                    > tonic::server::UnaryService<super::SignalTransferResumeRequest>
                    for SignalTransferResumeSvc<T> {
                        type Response = super::SignalTransferResumeResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::SignalTransferResumeRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ControlService>::signal_transfer_resume(
                                        &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 = SignalTransferResumeSvc(inner);
                        let codec = tonic::codec::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 ControlServiceServer<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 = "dsp.v1alpha2.ControlService";
    impl<T> tonic::server::NamedService for ControlServiceServer<T> {
        const NAME: &'static str = SERVICE_NAME;
    }
}