yandex-cloud 2025.4.14

/// Job parameters.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct JobParameters {
    /// List of input files.
    #[prost(message, repeated, tag = "1")]
    pub input_files: ::prost::alloc::vec::Vec<File>,
    /// List of output files descriptions.
    #[prost(message, repeated, tag = "2")]
    pub output_files: ::prost::alloc::vec::Vec<FileDesc>,
    /// List of DataSphere S3 mount ids.
    #[prost(string, repeated, tag = "3")]
    pub s3_mount_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// List of DataSphere dataset ids.
    #[prost(string, repeated, tag = "4")]
    pub dataset_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Job run command.
    #[prost(string, tag = "5")]
    pub cmd: ::prost::alloc::string::String,
    /// Job environment description.
    #[prost(message, optional, tag = "6")]
    pub env: ::core::option::Option<Environment>,
    /// Should project disk be attached to VM.
    #[prost(bool, tag = "7")]
    pub attach_project_disk: bool,
    /// VM specification.
    #[prost(message, repeated, tag = "8")]
    pub cloud_instance_types: ::prost::alloc::vec::Vec<CloudInstanceType>,
    /// Extended working storage configuration.
    #[prost(message, optional, tag = "9")]
    pub extended_working_storage: ::core::option::Option<ExtendedWorkingStorage>,
    /// List of literal arguments.
    #[prost(message, repeated, tag = "10")]
    pub arguments: ::prost::alloc::vec::Vec<Argument>,
    /// List of DataSets descriptions to create.
    #[prost(message, repeated, tag = "11")]
    pub output_datasets: ::prost::alloc::vec::Vec<OutputDatasetDesc>,
    /// Graceful shutdown settings.
    #[prost(message, optional, tag = "12")]
    pub graceful_shutdown_parameters: ::core::option::Option<GracefulShutdownParameters>,
    /// Spark connector settings.
    #[prost(message, optional, tag = "13")]
    pub spark_parameters: ::core::option::Option<SparkParameters>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CloudInstanceType {
    /// Name of DataSphere VM configuration.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Extended working storage configuration.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExtendedWorkingStorage {
    #[prost(enumeration = "extended_working_storage::StorageType", tag = "1")]
    pub r#type: i32,
    #[prost(int64, tag = "2")]
    pub size_gb: i64,
}
/// Nested message and enum types in `ExtendedWorkingStorage`.
pub mod extended_working_storage {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum StorageType {
        Unspecified = 0,
        Ssd = 1,
    }
    impl StorageType {
        /// 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 {
                StorageType::Unspecified => "STORAGE_TYPE_UNSPECIFIED",
                StorageType::Ssd => "SSD",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STORAGE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "SSD" => Some(Self::Ssd),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Argument {
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub value: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct File {
    #[prost(message, optional, tag = "1")]
    pub desc: ::core::option::Option<FileDesc>,
    /// SHA256 of the file.
    #[prost(string, tag = "2")]
    pub sha256: ::prost::alloc::string::String,
    /// File size in bytes.
    #[prost(int64, tag = "3")]
    pub size_bytes: i64,
    /// File compression info
    #[prost(enumeration = "FileCompressionType", tag = "4")]
    pub compression_type: i32,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StorageFile {
    #[prost(message, optional, tag = "1")]
    pub file: ::core::option::Option<File>,
    /// File URL.
    #[prost(string, tag = "2")]
    pub url: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FileDesc {
    /// Path of the file on filesystem.
    #[prost(string, tag = "1")]
    pub path: ::prost::alloc::string::String,
    /// Variable to use in cmd substitution.
    #[prost(string, tag = "2")]
    pub var: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FileUploadError {
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    #[prost(enumeration = "file_upload_error::ErrorType", tag = "4")]
    pub r#type: i32,
    #[prost(oneof = "file_upload_error::FileType", tags = "1, 2")]
    pub file_type: ::core::option::Option<file_upload_error::FileType>,
}
/// Nested message and enum types in `FileUploadError`.
pub mod file_upload_error {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ErrorType {
        Unspecified = 0,
        UploadFailed = 1,
        NotFound = 2,
    }
    impl ErrorType {
        /// 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 {
                ErrorType::Unspecified => "ERROR_TYPE_UNSPECIFIED",
                ErrorType::UploadFailed => "UPLOAD_FAILED",
                ErrorType::NotFound => "NOT_FOUND",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ERROR_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "UPLOAD_FAILED" => Some(Self::UploadFailed),
                "NOT_FOUND" => Some(Self::NotFound),
                _ => None,
            }
        }
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum FileType {
        #[prost(message, tag = "1")]
        OutputFileDesc(super::FileDesc),
        #[prost(string, tag = "2")]
        LogFileName(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Environment {
    /// Environment variables.
    #[prost(map = "string, string", tag = "1")]
    pub vars: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    #[prost(message, optional, tag = "4")]
    pub python_env: ::core::option::Option<PythonEnv>,
    #[prost(oneof = "environment::DockerImage", tags = "2, 3")]
    pub docker_image: ::core::option::Option<environment::DockerImage>,
}
/// Nested message and enum types in `Environment`.
pub mod environment {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum DockerImage {
        /// DS docker image id.
        #[prost(string, tag = "2")]
        DockerImageResourceId(::prost::alloc::string::String),
        #[prost(message, tag = "3")]
        DockerImageSpec(super::DockerImageSpec),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DockerImageSpec {
    /// Docker image URL.
    #[prost(string, tag = "1")]
    pub image_url: ::prost::alloc::string::String,
    /// Username for container registry.
    #[prost(string, tag = "2")]
    pub username: ::prost::alloc::string::String,
    /// Password for container registry.
    #[prost(oneof = "docker_image_spec::Password", tags = "3, 4")]
    pub password: ::core::option::Option<docker_image_spec::Password>,
}
/// Nested message and enum types in `DockerImageSpec`.
pub mod docker_image_spec {
    /// Password for container registry.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Password {
        /// Plaintext password.
        #[prost(string, tag = "3")]
        PasswordPlainText(::prost::alloc::string::String),
        /// ID of DataSphere secret containing password.
        #[prost(string, tag = "4")]
        PasswordDsSecretName(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PythonEnv {
    /// Conda YAML.
    #[prost(string, tag = "1")]
    pub conda_yaml: ::prost::alloc::string::String,
    /// List of local modules descriptions.
    #[prost(message, repeated, tag = "2")]
    pub local_modules: ::prost::alloc::vec::Vec<File>,
    /// Python version reduced to major.minor
    #[prost(string, tag = "3")]
    pub python_version: ::prost::alloc::string::String,
    /// List of pip requirements
    #[prost(string, repeated, tag = "4")]
    pub requirements: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Pip install options
    #[prost(message, optional, tag = "5")]
    pub pip_options: ::core::option::Option<PipOptions>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PipOptions {
    /// --index-url option
    #[prost(string, tag = "1")]
    pub index_url: ::prost::alloc::string::String,
    /// --extra-index-urls option
    #[prost(string, repeated, tag = "2")]
    pub extra_index_urls: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// --trusted-hosts option
    #[prost(string, repeated, tag = "3")]
    pub trusted_hosts: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// --no-deps option
    #[prost(bool, tag = "4")]
    pub no_deps: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OutputDatasetDesc {
    /// Name to create dataset with
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Description to show in UI
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    #[prost(map = "string, string", tag = "3")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Size of dataset to create
    #[prost(int64, tag = "4")]
    pub size_gb: i64,
    /// Var name to replace in cmd, like in FileDesc
    #[prost(string, tag = "5")]
    pub var: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OutputDataset {
    /// Dataset description
    #[prost(message, optional, tag = "1")]
    pub desc: ::core::option::Option<OutputDatasetDesc>,
    /// Id of created dataset
    #[prost(string, tag = "2")]
    pub id: ::prost::alloc::string::String,
}
/// Instance of the job.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Job {
    /// ID of the job.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Name of the job.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Description of the job.
    #[prost(string, tag = "3")]
    pub desc: ::prost::alloc::string::String,
    /// Create job timestamp.
    #[prost(message, optional, tag = "4")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Finish job timestamp.
    #[prost(message, optional, tag = "5")]
    pub finished_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Status of the job.
    #[prost(enumeration = "JobStatus", tag = "6")]
    pub status: i32,
    /// Config of the job, copied from configuration file.
    #[prost(string, tag = "7")]
    pub config: ::prost::alloc::string::String,
    /// ID of the user who created the job.
    #[prost(string, tag = "8")]
    pub created_by_id: ::prost::alloc::string::String,
    /// ID of the project.
    #[prost(string, tag = "9")]
    pub project_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "10")]
    pub job_parameters: ::core::option::Option<JobParameters>,
    /// Job data expiration timestamp.
    #[prost(message, optional, tag = "11")]
    pub data_expires_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Marks if the job data has been cleared.
    #[prost(bool, tag = "12")]
    pub data_cleared: bool,
    /// Output files of the job.
    #[prost(message, repeated, tag = "13")]
    pub output_files: ::prost::alloc::vec::Vec<File>,
    /// Job log files.
    #[prost(message, repeated, tag = "14")]
    pub log_files: ::prost::alloc::vec::Vec<File>,
    /// Job diagnostics files.
    #[prost(message, repeated, tag = "15")]
    pub diagnostic_files: ::prost::alloc::vec::Vec<File>,
    /// Job total data size.
    #[prost(int64, tag = "16")]
    pub data_size_bytes: i64,
    /// Start job timestamp.
    #[prost(message, optional, tag = "17")]
    pub started_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Details.
    #[prost(string, tag = "18")]
    pub status_details: ::prost::alloc::string::String,
    /// Actual VM instance type, job is running on.
    #[prost(message, optional, tag = "19")]
    pub actual_cloud_instance_type: ::core::option::Option<CloudInstanceType>,
    /// Reference to the parent job.
    #[prost(string, tag = "20")]
    pub parent_job_id: ::prost::alloc::string::String,
    /// Failed uploads.
    #[prost(message, repeated, tag = "21")]
    pub file_errors: ::prost::alloc::vec::Vec<FileUploadError>,
    /// Created datasets.
    #[prost(message, repeated, tag = "22")]
    pub output_datasets: ::prost::alloc::vec::Vec<OutputDataset>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct JobResult {
    /// Execution return code.
    #[prost(int64, tag = "1")]
    pub return_code: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GracefulShutdownParameters {
    #[prost(message, optional, tag = "1")]
    pub timeout: ::core::option::Option<::prost_types::Duration>,
    /// default 15 (SIGTERM)
    #[prost(int64, tag = "2")]
    pub signal: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct JobMetadata {
    /// ID of the job.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Name of the job.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Description of the job.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Create job timestamp.
    #[prost(message, optional, tag = "4")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Start job timestamp.
    #[prost(message, optional, tag = "5")]
    pub started_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Finish job timestamp.
    #[prost(message, optional, tag = "6")]
    pub finished_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Job data expiration timestamp.
    #[prost(message, optional, tag = "7")]
    pub data_expires_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Status of the job.
    #[prost(enumeration = "JobStatus", tag = "8")]
    pub status: i32,
    /// Details.
    #[prost(string, tag = "9")]
    pub status_details: ::prost::alloc::string::String,
    /// ID of the user who created the job.
    #[prost(string, tag = "10")]
    pub created_by_id: ::prost::alloc::string::String,
    /// ID of the project.
    #[prost(string, tag = "11")]
    pub project_id: ::prost::alloc::string::String,
    /// Reference to the parent job.
    #[prost(string, tag = "12")]
    pub parent_job_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct JobProgress {
    /// Progress message
    #[prost(string, tag = "1")]
    pub message: ::prost::alloc::string::String,
    /// Progress of the job from 0 to 100
    #[prost(int64, tag = "2")]
    pub progress: i64,
    /// Progress create time
    #[prost(message, optional, tag = "3")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SparkParameters {
    /// ID of the Spark connector.
    #[prost(string, tag = "1")]
    pub connector_id: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum FileCompressionType {
    Unspecified = 0,
    None = 1,
    Zip = 2,
}
impl FileCompressionType {
    /// 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 {
            FileCompressionType::Unspecified => "FILE_COMPRESSION_TYPE_UNSPECIFIED",
            FileCompressionType::None => "NONE",
            FileCompressionType::Zip => "ZIP",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "FILE_COMPRESSION_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "NONE" => Some(Self::None),
            "ZIP" => Some(Self::Zip),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum JobStatus {
    Unspecified = 0,
    Creating = 1,
    Executing = 2,
    UploadingOutput = 3,
    Success = 4,
    Error = 5,
    Cancelled = 6,
    Cancelling = 7,
    Preparing = 8,
}
impl JobStatus {
    /// 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 {
            JobStatus::Unspecified => "JOB_STATUS_UNSPECIFIED",
            JobStatus::Creating => "CREATING",
            JobStatus::Executing => "EXECUTING",
            JobStatus::UploadingOutput => "UPLOADING_OUTPUT",
            JobStatus::Success => "SUCCESS",
            JobStatus::Error => "ERROR",
            JobStatus::Cancelled => "CANCELLED",
            JobStatus::Cancelling => "CANCELLING",
            JobStatus::Preparing => "PREPARING",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "JOB_STATUS_UNSPECIFIED" => Some(Self::Unspecified),
            "CREATING" => Some(Self::Creating),
            "EXECUTING" => Some(Self::Executing),
            "UPLOADING_OUTPUT" => Some(Self::UploadingOutput),
            "SUCCESS" => Some(Self::Success),
            "ERROR" => Some(Self::Error),
            "CANCELLED" => Some(Self::Cancelled),
            "CANCELLING" => Some(Self::Cancelling),
            "PREPARING" => Some(Self::Preparing),
            _ => None,
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateProjectJobRequest {
    /// ID of the project.
    #[prost(string, tag = "1")]
    pub project_id: ::prost::alloc::string::String,
    /// Parameters of the job.
    #[prost(message, optional, tag = "2")]
    pub job_parameters: ::core::option::Option<JobParameters>,
    /// Config of the job.
    #[prost(string, tag = "3")]
    pub config: ::prost::alloc::string::String,
    /// Name of the job.
    #[prost(string, tag = "4")]
    pub name: ::prost::alloc::string::String,
    /// Description of the job.
    #[prost(string, tag = "5")]
    pub desc: ::prost::alloc::string::String,
    /// Job data TTL.
    #[prost(message, optional, tag = "6")]
    pub data_ttl: ::core::option::Option<::prost_types::Duration>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateProjectJobMetadata {
    /// ID of the project.
    #[prost(string, tag = "1")]
    pub project_id: ::prost::alloc::string::String,
    /// Job ID.
    #[prost(string, tag = "2")]
    pub job_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateProjectJobResponse {
    /// ID of the job.
    #[prost(string, tag = "1")]
    pub job_id: ::prost::alloc::string::String,
    /// Files to upload with their presigned URLs for upload.
    #[prost(message, repeated, tag = "2")]
    pub upload_files: ::prost::alloc::vec::Vec<StorageFile>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CloneProjectJobRequest {
    /// ID of job to be cloned.
    #[prost(string, tag = "1")]
    pub source_job_id: ::prost::alloc::string::String,
    /// Parameters overrides.
    #[prost(message, optional, tag = "2")]
    pub job_parameters_overrides: ::core::option::Option<JobParameters>,
    /// New job name.
    #[prost(string, tag = "3")]
    pub name: ::prost::alloc::string::String,
    /// New job description
    #[prost(string, tag = "4")]
    pub desc: ::prost::alloc::string::String,
    /// Data ttl.
    #[prost(message, optional, tag = "5")]
    pub data_ttl: ::core::option::Option<::prost_types::Duration>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CloneProjectJobResponse {
    /// Job ID.
    #[prost(string, tag = "1")]
    pub job_id: ::prost::alloc::string::String,
    /// Files with presigned URLs generated by server to upload them to storage. Order is arbitrary.
    ///
    /// Upload files include input files, executable file (python main script or binary executable) and local modules
    /// in case of python.
    ///
    /// If file was already uploaded, there will be no element for it.
    #[prost(message, repeated, tag = "2")]
    pub upload_files: ::prost::alloc::vec::Vec<StorageFile>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CloneProjectJobMetadata {
    #[prost(string, tag = "1")]
    pub project_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub job_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecuteProjectJobRequest {
    /// ID of the job.
    #[prost(string, tag = "1")]
    pub job_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecuteProjectJobResponse {
    /// Uploaded output files with URLs.
    #[prost(message, repeated, tag = "1")]
    pub output_files: ::prost::alloc::vec::Vec<StorageFile>,
    /// Output file errors
    #[prost(message, repeated, tag = "4")]
    pub output_files_errors: ::prost::alloc::vec::Vec<FileUploadError>,
    /// Created datasets
    #[prost(message, repeated, tag = "3")]
    pub output_datasets: ::prost::alloc::vec::Vec<OutputDataset>,
    /// Result of the job.
    #[prost(message, optional, tag = "2")]
    pub result: ::core::option::Option<JobResult>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecuteProjectJobMetadata {
    /// Instance of the job.
    #[deprecated]
    #[prost(message, optional, tag = "1")]
    pub job: ::core::option::Option<Job>,
    /// Job progress info
    #[prost(message, optional, tag = "2")]
    pub progress: ::core::option::Option<JobProgress>,
    /// Job metadata with main job info
    #[prost(message, optional, tag = "3")]
    pub metadata: ::core::option::Option<JobMetadata>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CancelProjectJobRequest {
    /// ID of the job.
    #[prost(string, tag = "1")]
    pub job_id: ::prost::alloc::string::String,
    /// Optional cancellation reason.
    #[prost(string, tag = "2")]
    pub reason: ::prost::alloc::string::String,
    /// If the job is launched with graceful shutdown support, the shutdown will be performed gracefully
    #[prost(bool, tag = "3")]
    pub graceful: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReadProjectJobStdLogsRequest {
    /// ID of the job.
    #[prost(string, tag = "1")]
    pub job_id: ::prost::alloc::string::String,
    /// Log offset.
    #[prost(int64, tag = "2")]
    pub offset: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReadProjectJobStdLogsResponse {
    #[prost(message, repeated, tag = "1")]
    pub logs: ::prost::alloc::vec::Vec<StdLog>,
    /// Log offset.
    #[prost(int64, tag = "2")]
    pub offset: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReadProjectJobLogsRequest {
    /// ID of the job.
    #[prost(string, tag = "1")]
    pub job_id: ::prost::alloc::string::String,
    /// Log offset.
    #[prost(int64, tag = "2")]
    pub offset: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReadProjectJobLogsResponse {
    #[prost(message, repeated, tag = "1")]
    pub logs: ::prost::alloc::vec::Vec<LogMessage>,
    /// Log offset.
    #[prost(int64, tag = "2")]
    pub offset: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DownloadProjectJobFilesRequest {
    #[prost(string, tag = "1")]
    pub job_id: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "2")]
    pub files: ::prost::alloc::vec::Vec<File>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DownloadProjectJobFilesResponse {
    #[prost(message, repeated, tag = "1")]
    pub download_files: ::prost::alloc::vec::Vec<StorageFile>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListProjectJobRequest {
    /// ID of the project.
    #[prost(string, tag = "1")]
    pub project_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 \[ListProjectJobResponse.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
    /// \[ListProjectJobResponse.page_token\] returned by a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// restrictions:
    ///    * only `status` field is supported
    ///    * only `IN` operator is supported
    /// example:
    ///    * only running jobs == "status IN (EXECUTING, UPLOADING_OUTPUT)"
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListProjectJobResponse {
    /// Instances of the jobs.
    #[prost(message, repeated, tag = "1")]
    pub jobs: ::prost::alloc::vec::Vec<Job>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListProjectJobRequest.page_size\], use
    /// the \[next_page_token\] as the value
    /// for the \[ListProjectJobRequest.page_token\] query parameter
    /// in the next list request. Each subsequent list request will have its own
    /// \[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 GetProjectJobRequest {
    /// ID of the job.
    #[prost(string, tag = "1")]
    pub job_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteProjectJobRequest {
    /// ID of the job.
    #[prost(string, tag = "1")]
    pub job_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteProjectJobMetadata {
    /// ID of the job.
    #[prost(string, tag = "1")]
    pub job_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteProjectJobDataRequest {
    /// ID of the job.
    #[prost(string, tag = "1")]
    pub job_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteProjectJobDataMetadata {
    /// ID of the job.
    #[prost(string, tag = "1")]
    pub job_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteProjectJobDataResponse {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteAllProjectJobDataRequest {
    #[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 DeleteAllProjectJobDataMetadata {
    #[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 DeleteAllProjectJobDataResponse {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SetProjectJobDataTtlRequest {
    #[prost(string, tag = "1")]
    pub job_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub ttl: ::core::option::Option<::prost_types::Duration>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SetProjectJobDataTtlResponse {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StdLog {
    /// Log contents.
    #[prost(bytes = "vec", tag = "1")]
    pub content: ::prost::alloc::vec::Vec<u8>,
    /// Log type.
    #[prost(enumeration = "std_log::Type", tag = "2")]
    pub r#type: i32,
}
/// Nested message and enum types in `StdLog`.
pub mod std_log {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Type {
        Unspecified = 0,
        /// stdout.
        Out = 1,
        /// stderr.
        Err = 2,
    }
    impl Type {
        /// 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 {
                Type::Unspecified => "TYPE_UNSPECIFIED",
                Type::Out => "OUT",
                Type::Err => "ERR",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "OUT" => Some(Self::Out),
                "ERR" => Some(Self::Err),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LogMessage {
    /// Log message contents.
    #[prost(bytes = "vec", tag = "1")]
    pub content: ::prost::alloc::vec::Vec<u8>,
    /// Log message creation timestamp.
    #[prost(message, optional, tag = "2")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    #[prost(oneof = "log_message::Source", tags = "3, 4")]
    pub source: ::core::option::Option<log_message::Source>,
}
/// Nested message and enum types in `LogMessage`.
pub mod log_message {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Source {
        /// Program standard streams.
        #[prost(enumeration = "super::StandardStream", tag = "3")]
        StandardStream(i32),
        /// System debug log files.
        #[prost(string, tag = "4")]
        FilePath(::prost::alloc::string::String),
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum StandardStream {
    Unspecified = 0,
    /// Stdout.
    Out = 1,
    /// Stderr.
    Err = 2,
}
impl StandardStream {
    /// 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 {
            StandardStream::Unspecified => "STANDARD_STREAM_UNSPECIFIED",
            StandardStream::Out => "OUT",
            StandardStream::Err => "ERR",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "STANDARD_STREAM_UNSPECIFIED" => Some(Self::Unspecified),
            "OUT" => Some(Self::Out),
            "ERR" => Some(Self::Err),
            _ => None,
        }
    }
}
/// Generated client implementations.
pub mod project_job_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 Jobs. Do not use these methods manually.
    /// For working with DataSphere Jobs, install DataSphere CLI via `pip install datasphere`.
    #[derive(Debug, Clone)]
    pub struct ProjectJobServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ProjectJobServiceClient<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> ProjectJobServiceClient<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,
        ) -> ProjectJobServiceClient<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,
        {
            ProjectJobServiceClient::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 job.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateProjectJobRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.v2.jobs.ProjectJobService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.datasphere.v2.jobs.ProjectJobService",
                        "Create",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Clone job.
        pub async fn clone(
            &mut self,
            request: impl tonic::IntoRequest<super::CloneProjectJobRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.v2.jobs.ProjectJobService/Clone",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.datasphere.v2.jobs.ProjectJobService",
                        "Clone",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Runs job execution.
        pub async fn execute(
            &mut self,
            request: impl tonic::IntoRequest<super::ExecuteProjectJobRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.v2.jobs.ProjectJobService/Execute",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.datasphere.v2.jobs.ProjectJobService",
                        "Execute",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Cancels running job.
        pub async fn cancel(
            &mut self,
            request: impl tonic::IntoRequest<super::CancelProjectJobRequest>,
        ) -> 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.v2.jobs.ProjectJobService/Cancel",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.datasphere.v2.jobs.ProjectJobService",
                        "Cancel",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns stream of job logs.
        pub async fn read_std_logs(
            &mut self,
            request: impl tonic::IntoRequest<super::ReadProjectJobStdLogsRequest>,
        ) -> std::result::Result<
            tonic::Response<
                tonic::codec::Streaming<super::ReadProjectJobStdLogsResponse>,
            >,
            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.v2.jobs.ProjectJobService/ReadStdLogs",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.datasphere.v2.jobs.ProjectJobService",
                        "ReadStdLogs",
                    ),
                );
            self.inner.server_streaming(req, path, codec).await
        }
        /// Returns stream of job logs.
        pub async fn read_logs(
            &mut self,
            request: impl tonic::IntoRequest<super::ReadProjectJobLogsRequest>,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::ReadProjectJobLogsResponse>>,
            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.v2.jobs.ProjectJobService/ReadLogs",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.datasphere.v2.jobs.ProjectJobService",
                        "ReadLogs",
                    ),
                );
            self.inner.server_streaming(req, path, codec).await
        }
        /// Returns download urls for job files.
        pub async fn download_job_files(
            &mut self,
            request: impl tonic::IntoRequest<super::DownloadProjectJobFilesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::DownloadProjectJobFilesResponse>,
            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.v2.jobs.ProjectJobService/DownloadJobFiles",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.datasphere.v2.jobs.ProjectJobService",
                        "DownloadJobFiles",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists jobs.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListProjectJobRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListProjectJobResponse>,
            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.v2.jobs.ProjectJobService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.datasphere.v2.jobs.ProjectJobService",
                        "List",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns job by id.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetProjectJobRequest>,
        ) -> std::result::Result<tonic::Response<super::Job>, 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.v2.jobs.ProjectJobService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.datasphere.v2.jobs.ProjectJobService",
                        "Get",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes specified job.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteProjectJobRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.v2.jobs.ProjectJobService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.datasphere.v2.jobs.ProjectJobService",
                        "Delete",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Delete job data.
        pub async fn delete_data(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteProjectJobDataRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.v2.jobs.ProjectJobService/DeleteData",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.datasphere.v2.jobs.ProjectJobService",
                        "DeleteData",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Delete all jobs data.
        pub async fn delete_all_data(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteAllProjectJobDataRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.v2.jobs.ProjectJobService/DeleteAllData",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.datasphere.v2.jobs.ProjectJobService",
                        "DeleteAllData",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Update job data ttl.
        pub async fn set_data_ttl(
            &mut self,
            request: impl tonic::IntoRequest<super::SetProjectJobDataTtlRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SetProjectJobDataTtlResponse>,
            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.v2.jobs.ProjectJobService/SetDataTtl",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.datasphere.v2.jobs.ProjectJobService",
                        "SetDataTtl",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}