yandex-cloud 2025.4.14

#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AppTokenValidateRequest {
    /// App token to validate.
    #[prost(string, tag = "1")]
    pub token: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod app_token_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// A set of methods for managing app tokens.
    #[derive(Debug, Clone)]
    pub struct AppTokenServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl AppTokenServiceClient<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> AppTokenServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + 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,
        ) -> AppTokenServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            AppTokenServiceClient::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
        }
        /// Validates app token.
        pub async fn validate(
            &mut self,
            request: impl tonic::IntoRequest<super::AppTokenValidateRequest>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.datasphere.v1.AppTokenService/Validate",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.datasphere.v1.AppTokenService",
                        "Validate",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetFolderBudgetRequest {
    /// ID of the folder to get a budget for.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetFolderBudgetResponse {
    /// The number of units available in the folder.
    #[prost(message, optional, tag = "1")]
    pub unit_balance: ::core::option::Option<i64>,
    /// The number of units that can be spent per hour.
    #[prost(message, optional, tag = "2")]
    pub max_units_per_hour: ::core::option::Option<i64>,
    /// The number of units that can be spent on one execution.
    #[prost(message, optional, tag = "3")]
    pub max_units_per_execution: ::core::option::Option<i64>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SetFolderBudgetRequest {
    /// ID of the folder to set a budget for.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// Field mask that specifies which fields of the budget are going to be set.
    #[prost(message, optional, tag = "2")]
    pub set_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// The number of units available in the folder.
    #[prost(message, optional, tag = "3")]
    pub unit_balance: ::core::option::Option<i64>,
    /// The number of units that can be spent per hour.
    #[prost(message, optional, tag = "4")]
    pub max_units_per_hour: ::core::option::Option<i64>,
    /// The number of units that can be spent on one execution.
    #[prost(message, optional, tag = "5")]
    pub max_units_per_execution: ::core::option::Option<i64>,
}
/// Generated client implementations.
pub mod folder_budget_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// A set of methods for managing Datasphere folder budgets.
    #[derive(Debug, Clone)]
    pub struct FolderBudgetServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl FolderBudgetServiceClient<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> FolderBudgetServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + 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,
        ) -> FolderBudgetServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            FolderBudgetServiceClient::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
        }
        /// Returns the specified folder budget.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetFolderBudgetRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetFolderBudgetResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.datasphere.v1.FolderBudgetService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.datasphere.v1.FolderBudgetService",
                        "Get",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Sets the unit balance and the limits of the specified folder budget.
        pub async fn set(
            &mut self,
            request: impl tonic::IntoRequest<super::SetFolderBudgetRequest>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.datasphere.v1.FolderBudgetService/Set",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.datasphere.v1.FolderBudgetService",
                        "Set",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// User code python execution's error details
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NodeExecutionErrorDetails {
    /// Error name
    #[prost(string, tag = "1")]
    pub error_name: ::prost::alloc::string::String,
    /// Error message
    #[prost(string, tag = "2")]
    pub error_message: ::prost::alloc::string::String,
    /// Error traceback
    #[prost(string, repeated, tag = "3")]
    pub traceback: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NodeExecutionRequest {
    /// ID of the folder that will be matched with Node ACL.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// ID of the Node to perform request on.
    #[prost(string, tag = "2")]
    pub node_id: ::prost::alloc::string::String,
    /// Input data for the execution.
    #[prost(message, optional, tag = "3")]
    pub input: ::core::option::Option<::prost_types::Struct>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NodeExecutionResponse {
    /// Result of the execution.
    #[prost(message, optional, tag = "1")]
    pub output: ::core::option::Option<::prost_types::Struct>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AliasExecutionRequest {
    /// ID of the folder that will be matched with Alias ACL
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// Name of the Alias to perform request on
    #[prost(string, tag = "2")]
    pub alias_name: ::prost::alloc::string::String,
    /// Input data for the execution
    #[prost(message, optional, tag = "3")]
    pub input: ::core::option::Option<::prost_types::Struct>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AliasExecutionResponse {
    /// Result of the execution
    #[prost(message, optional, tag = "1")]
    pub output: ::core::option::Option<::prost_types::Struct>,
}
/// Generated client implementations.
pub mod node_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// A set of methods for managing Node resources.
    #[derive(Debug, Clone)]
    pub struct NodeServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl NodeServiceClient<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> NodeServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + 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,
        ) -> NodeServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            NodeServiceClient::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
        }
        /// Executes deployed Node.
        pub async fn execute(
            &mut self,
            request: impl tonic::IntoRequest<super::NodeExecutionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::NodeExecutionResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.datasphere.v1.NodeService/Execute",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.datasphere.v1.NodeService", "Execute"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Executes NodeAlias requests.
        pub async fn execute_alias(
            &mut self,
            request: impl tonic::IntoRequest<super::AliasExecutionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::AliasExecutionResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.datasphere.v1.NodeService/ExecuteAlias",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.datasphere.v1.NodeService",
                        "ExecuteAlias",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// A Project resource.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Project {
    /// ID of the project.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the folder that the project belongs to.
    #[prost(string, tag = "2")]
    pub folder_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Name of the project. 1-63 characters long.
    #[prost(string, tag = "4")]
    pub name: ::prost::alloc::string::String,
    /// Description of the project. 0-256 characters long.
    #[prost(string, tag = "5")]
    pub description: ::prost::alloc::string::String,
    /// Settings of the project.
    #[prost(message, optional, tag = "6")]
    pub settings: ::core::option::Option<project::Settings>,
    /// Limits of the project.
    #[prost(message, optional, tag = "7")]
    pub limits: ::core::option::Option<project::Limits>,
}
/// Nested message and enum types in `Project`.
pub mod project {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Settings {
        /// ID of the service account, on whose behalf all operations with clusters will be performed.
        #[prost(string, tag = "1")]
        pub service_account_id: ::prost::alloc::string::String,
        /// ID of the subnet where the DataProc cluster resides.
        /// Currently only subnets created in the availability zone ru-central1-a are supported.
        #[prost(string, tag = "2")]
        pub subnet_id: ::prost::alloc::string::String,
        /// ID of the DataProc cluster.
        #[prost(string, tag = "3")]
        pub data_proc_cluster_id: ::prost::alloc::string::String,
        /// Network interfaces security groups.
        #[prost(string, repeated, tag = "5")]
        pub security_group_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Limits {
        /// The number of units that can be spent per hour.
        #[prost(message, optional, tag = "2")]
        pub max_units_per_hour: ::core::option::Option<i64>,
        /// The number of units that can be spent on the one execution.
        #[prost(message, optional, tag = "3")]
        pub max_units_per_execution: ::core::option::Option<i64>,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FileMetadata {
    /// ID of the Project resource associated with the file.
    #[prost(string, tag = "1")]
    pub project_id: ::prost::alloc::string::String,
    /// File path.
    #[prost(string, tag = "2")]
    pub path: ::prost::alloc::string::String,
    /// File size in bytes.
    #[prost(int64, tag = "3")]
    pub size_bytes: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UploadFileRequest {
    #[prost(oneof = "upload_file_request::Message", tags = "1, 2")]
    pub message: ::core::option::Option<upload_file_request::Message>,
}
/// Nested message and enum types in `UploadFileRequest`.
pub mod upload_file_request {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Message {
        /// Metadata of the file to upload.
        #[prost(message, tag = "1")]
        Metadata(super::FileMetadata),
        /// Byte chunk of the file to upload.
        #[prost(bytes, tag = "2")]
        Chunk(::prost::alloc::vec::Vec<u8>),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UploadFileResponse {
    /// Metadata of the uploaded file.
    #[prost(message, optional, tag = "1")]
    pub metadata: ::core::option::Option<FileMetadata>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DownloadFileRequest {
    /// ID of the Project resource to download the file from.
    #[prost(string, tag = "1")]
    pub project_id: ::prost::alloc::string::String,
    /// Path of the file to download.
    #[prost(string, tag = "2")]
    pub file_path: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DownloadFileResponse {
    #[prost(oneof = "download_file_response::Message", tags = "1, 2")]
    pub message: ::core::option::Option<download_file_response::Message>,
}
/// Nested message and enum types in `DownloadFileResponse`.
pub mod download_file_response {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Message {
        /// Metadata of the downloaded file.
        #[prost(message, tag = "1")]
        Metadata(super::FileMetadata),
        /// Byte chunk of the downloaded file.
        #[prost(bytes, tag = "2")]
        Chunk(::prost::alloc::vec::Vec<u8>),
    }
}
/// Generated client implementations.
pub mod project_data_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// A set of methods for managing data of the Project resource.
    #[derive(Debug, Clone)]
    pub struct ProjectDataServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ProjectDataServiceClient<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> ProjectDataServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + 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,
        ) -> ProjectDataServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            ProjectDataServiceClient::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
        }
        /// Uploads a file to the specified project.
        pub async fn upload_file(
            &mut self,
            request: impl tonic::IntoStreamingRequest<Message = super::UploadFileRequest>,
        ) -> std::result::Result<
            tonic::Response<super::UploadFileResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.datasphere.v1.ProjectDataService/UploadFile",
            );
            let mut req = request.into_streaming_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.datasphere.v1.ProjectDataService",
                        "UploadFile",
                    ),
                );
            self.inner.client_streaming(req, path, codec).await
        }
        /// Downloads the specified file from the specified project.
        pub async fn download_file(
            &mut self,
            request: impl tonic::IntoRequest<super::DownloadFileRequest>,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::DownloadFileResponse>>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.datasphere.v1.ProjectDataService/DownloadFile",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.datasphere.v1.ProjectDataService",
                        "DownloadFile",
                    ),
                );
            self.inner.server_streaming(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateProjectRequest {
    /// ID of the folder to create a project in.
    /// To get the folder ID use a \[yandex.cloud.resourcemanager.v1.FolderService.List\] request.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// Name of the project.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Description of the project.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Settings of the project.
    #[prost(message, optional, tag = "4")]
    pub settings: ::core::option::Option<project::Settings>,
    /// Limits of the project.
    #[prost(message, optional, tag = "5")]
    pub limits: ::core::option::Option<project::Limits>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateProjectMetadata {
    /// ID of the project that is being created.
    #[prost(string, tag = "1")]
    pub project_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateProjectRequest {
    /// ID of the Project resource to update.
    /// To get the project ID use a \[ProjectService.List\] request.
    #[prost(string, tag = "1")]
    pub project_id: ::prost::alloc::string::String,
    /// Field mask that specifies which fields of the Project resource are going to be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Name of the project.
    #[prost(string, tag = "3")]
    pub name: ::prost::alloc::string::String,
    /// Description of the project.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// Settings of the project.
    #[prost(message, optional, tag = "5")]
    pub settings: ::core::option::Option<project::Settings>,
    /// Limits of the project.
    #[prost(message, optional, tag = "6")]
    pub limits: ::core::option::Option<project::Limits>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateProjectMetadata {
    /// ID of the project that is being updated.
    #[prost(string, tag = "1")]
    pub project_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteProjectRequest {
    /// ID of the Project resource to delete.
    /// To get the project ID use a \[ProjectService.List\] request.
    #[prost(string, tag = "1")]
    pub project_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteProjectMetadata {
    /// ID of the project that is being deleted.
    #[prost(string, tag = "1")]
    pub project_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OpenProjectRequest {
    /// ID of the Project resource to open.
    /// To get the project ID use a \[ProjectService.List\] request.
    #[prost(string, tag = "1")]
    pub project_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OpenProjectMetadata {
    /// ID of the project that is being opened.
    #[prost(string, tag = "1")]
    pub project_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OpenProjectResponse {
    /// URL of the project that is being opened.
    /// Make GET request to \[project_url\] with sessionToken query parameter equals to \[session_token\]
    /// or POST request to \[project_url\] with sessionToken body parameter equals to \[session_token\]
    /// to fetch Datasphere web interface.
    #[prost(string, tag = "1")]
    pub project_url: ::prost::alloc::string::String,
    /// Session token of the project that is being opened.
    #[prost(string, tag = "2")]
    pub session_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetProjectRequest {
    /// ID of the Project resource to return.
    /// To get the project ID use a \[ProjectService.List\] request.
    #[prost(string, tag = "1")]
    pub project_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListProjectsRequest {
    /// ID of the folder to list projects in.
    /// To get the folder ID use a \[yandex.cloud.resourcemanager.v1.FolderService.List\] request.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\],
    /// the service returns a \[ListProjectsResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set \[page_token\] to the
    /// \[ListProjectsResponse.next_page_token\] returned by a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListProjectsResponse {
    /// List of Project resources.
    #[prost(message, repeated, tag = "1")]
    pub projects: ::prost::alloc::vec::Vec<Project>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListProjectsRequest.page_size\], use
    /// the \[next_page_token\] as the value
    /// for the \[ListProjectsRequest.page_token\] query parameter
    /// in the next list request. Each subsequent list request will have its own
    /// \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetUnitBalanceRequest {
    /// ID of the project to return the unit balance for.
    #[prost(string, tag = "1")]
    pub project_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetUnitBalanceResponse {
    /// The number of units available to the project.
    #[prost(message, optional, tag = "1")]
    pub unit_balance: ::core::option::Option<i64>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SetUnitBalanceRequest {
    /// ID of the project to set the unit balance for.
    #[prost(string, tag = "1")]
    pub project_id: ::prost::alloc::string::String,
    /// The number of units available to the project.
    #[prost(message, optional, tag = "2")]
    pub unit_balance: ::core::option::Option<i64>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProjectExecutionRequest {
    /// ID of the project to execute notebook/cell in.
    #[prost(string, tag = "1")]
    pub project_id: ::prost::alloc::string::String,
    /// Values of input variables.
    #[prost(message, optional, tag = "4")]
    pub input_variables: ::core::option::Option<::prost_types::Struct>,
    /// Names of output variables.
    #[prost(string, repeated, tag = "5")]
    pub output_variable_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(oneof = "project_execution_request::Target", tags = "2, 3")]
    pub target: ::core::option::Option<project_execution_request::Target>,
}
/// Nested message and enum types in `ProjectExecutionRequest`.
pub mod project_execution_request {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Target {
        /// ID of the notebook to execute.
        #[prost(string, tag = "2")]
        NotebookId(::prost::alloc::string::String),
        /// ID of the cell to execute.
        #[prost(string, tag = "3")]
        CellId(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProjectExecutionMetadata {
    /// ID of the project in which notebook is being executed.
    #[prost(string, tag = "1")]
    pub project_id: ::prost::alloc::string::String,
    #[prost(oneof = "project_execution_metadata::Target", tags = "2, 3")]
    pub target: ::core::option::Option<project_execution_metadata::Target>,
}
/// Nested message and enum types in `ProjectExecutionMetadata`.
pub mod project_execution_metadata {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Target {
        /// ID of the notebook that is being executed
        #[prost(string, tag = "2")]
        NotebookId(::prost::alloc::string::String),
        /// ID of the cell that is being executed
        #[prost(string, tag = "3")]
        CellId(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProjectExecutionResponse {}
/// Generated client implementations.
pub mod project_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// A set of methods for managing Project resources.
    #[derive(Debug, Clone)]
    pub struct ProjectServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ProjectServiceClient<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> ProjectServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + 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,
        ) -> ProjectServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            ProjectServiceClient::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
        }
        /// Creates a project in the specified folder.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateProjectRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.datasphere.v1.ProjectService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.datasphere.v1.ProjectService",
                        "Create",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified project.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateProjectRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.datasphere.v1.ProjectService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.datasphere.v1.ProjectService",
                        "Update",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified project.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteProjectRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.datasphere.v1.ProjectService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.datasphere.v1.ProjectService",
                        "Delete",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Opens the specified project.
        pub async fn open(
            &mut self,
            request: impl tonic::IntoRequest<super::OpenProjectRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.datasphere.v1.ProjectService/Open",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.datasphere.v1.ProjectService", "Open"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns the specified project.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetProjectRequest>,
        ) -> std::result::Result<tonic::Response<super::Project>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.datasphere.v1.ProjectService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.datasphere.v1.ProjectService", "Get"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists projects for the specified folder.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListProjectsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListProjectsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.datasphere.v1.ProjectService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.datasphere.v1.ProjectService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns the unit balance of the specified project.
        pub async fn get_unit_balance(
            &mut self,
            request: impl tonic::IntoRequest<super::GetUnitBalanceRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetUnitBalanceResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.datasphere.v1.ProjectService/GetUnitBalance",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.datasphere.v1.ProjectService",
                        "GetUnitBalance",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Sets the unit balance of the specified project.
        pub async fn set_unit_balance(
            &mut self,
            request: impl tonic::IntoRequest<super::SetUnitBalanceRequest>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.datasphere.v1.ProjectService/SetUnitBalance",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.datasphere.v1.ProjectService",
                        "SetUnitBalance",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Executes code in the specified cell or notebook.
        pub async fn execute(
            &mut self,
            request: impl tonic::IntoRequest<super::ProjectExecutionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.datasphere.v1.ProjectService/Execute",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.datasphere.v1.ProjectService",
                        "Execute",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}