yandex_cloud/

yandex.cloud.serverless.functions.v1.rs

/// A serverless function. For details about the concept, see \[Functions\](/docs/functions/concepts/function).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Function {
    /// ID of the function. Generated at creation time.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the folder that the function belongs to.
    #[prost(string, tag = "2")]
    pub folder_id: ::prost::alloc::string::String,
    /// Creation timestamp for the function.
    #[prost(message, optional, tag = "3")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Name of the function. The name is unique within the folder.
    #[prost(string, tag = "4")]
    pub name: ::prost::alloc::string::String,
    /// Description of the function.
    #[prost(string, tag = "5")]
    pub description: ::prost::alloc::string::String,
    /// Function labels as `key:value` pairs.
    #[prost(map = "string, string", tag = "6")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// URL that needs to be requested to invoke the function.
    #[prost(string, tag = "8")]
    pub http_invoke_url: ::prost::alloc::string::String,
    /// Status of the function.
    #[prost(enumeration = "function::Status", tag = "9")]
    pub status: i32,
}
/// Nested message and enum types in `Function`.
pub mod function {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Status {
        Unspecified = 0,
        /// Function is being created.
        Creating = 1,
        /// Function is ready to be invoked.
        Active = 2,
        /// Function is being deleted.
        Deleting = 3,
        /// Function failed.
        Error = 4,
    }
    impl Status {
        /// 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 {
                Status::Unspecified => "STATUS_UNSPECIFIED",
                Status::Creating => "CREATING",
                Status::Active => "ACTIVE",
                Status::Deleting => "DELETING",
                Status::Error => "ERROR",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATUS_UNSPECIFIED" => Some(Self::Unspecified),
                "CREATING" => Some(Self::Creating),
                "ACTIVE" => Some(Self::Active),
                "DELETING" => Some(Self::Deleting),
                "ERROR" => Some(Self::Error),
                _ => None,
            }
        }
    }
}
/// Version of a function. For details about the concept, see [Function versions](/docs/functions/concepts/function#version).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Version {
    /// ID of the version.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the function that the version belongs to.
    #[prost(string, tag = "2")]
    pub function_id: ::prost::alloc::string::String,
    /// Description of the version.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Creation timestamp for the version.
    #[prost(message, optional, tag = "5")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// ID of the runtime environment for the function.
    ///
    /// Supported environments and their identifiers are listed in the [Runtime environments](/docs/functions/concepts/runtime).
    #[prost(string, tag = "6")]
    pub runtime: ::prost::alloc::string::String,
    /// Entrypoint for the function: the name of the function to be called as the handler.
    ///
    /// Specified in the format `<function file name>.<handler name>`, for example, `index.myFunction`.
    #[prost(string, tag = "7")]
    pub entrypoint: ::prost::alloc::string::String,
    /// Resources allocated to the version.
    #[prost(message, optional, tag = "8")]
    pub resources: ::core::option::Option<Resources>,
    /// Timeout for the execution of the version.
    ///
    /// If the timeout is exceeded, Cloud Functions responds with a 504 HTTP code.
    #[prost(message, optional, tag = "9")]
    pub execution_timeout: ::core::option::Option<::prost_types::Duration>,
    /// ID of the service account associated with the version.
    #[prost(string, tag = "10")]
    pub service_account_id: ::prost::alloc::string::String,
    /// Final size of the deployment package after unpacking.
    #[prost(int64, tag = "12")]
    pub image_size: i64,
    /// Status of the version.
    #[prost(enumeration = "version::Status", tag = "13")]
    pub status: i32,
    /// Version tags. For details, see [Version tag](/docs/functions/concepts/function#tag).
    #[prost(string, repeated, tag = "14")]
    pub tags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Environment settings for the version.
    #[prost(map = "string, string", tag = "16")]
    pub environment: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Network access. If specified the version will be attached to specified network/subnet(s).
    #[prost(message, optional, tag = "17")]
    pub connectivity: ::core::option::Option<Connectivity>,
    /// Additional service accounts to be used by the version.
    #[prost(map = "string, string", tag = "18")]
    pub named_service_accounts: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Yandex Lockbox secrets to be used by the version.
    #[prost(message, repeated, tag = "19")]
    pub secrets: ::prost::alloc::vec::Vec<Secret>,
    /// Options for logging from the function
    #[prost(message, optional, tag = "20")]
    pub log_options: ::core::option::Option<LogOptions>,
    /// S3 mounts to be used by the version.
    #[prost(message, repeated, tag = "21")]
    pub storage_mounts: ::prost::alloc::vec::Vec<StorageMount>,
    /// Config for asynchronous invocations of the version
    #[prost(message, optional, tag = "22")]
    pub async_invocation_config: ::core::option::Option<AsyncInvocationConfig>,
    /// Optional size of in-memory mounted /tmp directory in bytes.
    #[prost(int64, tag = "23")]
    pub tmpfs_size: i64,
    /// The maximum number of requests processed by a function instance at the same time
    #[prost(int64, tag = "24")]
    pub concurrency: i64,
    /// Mounts to be used by the version.
    #[prost(message, repeated, tag = "25")]
    pub mounts: ::prost::alloc::vec::Vec<Mount>,
    /// Metadata options for the version.
    #[prost(message, optional, tag = "26")]
    pub metadata_options: ::core::option::Option<MetadataOptions>,
}
/// Nested message and enum types in `Version`.
pub mod version {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Status {
        Unspecified = 0,
        /// Version is being created.
        Creating = 1,
        /// Version is ready to use.
        Active = 2,
        /// Version will be deleted soon.
        Obsolete = 3,
        /// Version is being deleted.
        Deleting = 4,
    }
    impl Status {
        /// 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 {
                Status::Unspecified => "STATUS_UNSPECIFIED",
                Status::Creating => "CREATING",
                Status::Active => "ACTIVE",
                Status::Obsolete => "OBSOLETE",
                Status::Deleting => "DELETING",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATUS_UNSPECIFIED" => Some(Self::Unspecified),
                "CREATING" => Some(Self::Creating),
                "ACTIVE" => Some(Self::Active),
                "OBSOLETE" => Some(Self::Obsolete),
                "DELETING" => Some(Self::Deleting),
                _ => None,
            }
        }
    }
}
/// Resources allocated to a version.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Resources {
    /// Amount of memory available to the version, specified in bytes, multiple of 128MB.
    #[prost(int64, tag = "1")]
    pub memory: i64,
}
/// Version deployment package.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Package {
    /// Name of the bucket that stores the code for the version.
    #[prost(string, tag = "1")]
    pub bucket_name: ::prost::alloc::string::String,
    /// Name of the object in the bucket that stores the code for the version.
    #[prost(string, tag = "2")]
    pub object_name: ::prost::alloc::string::String,
    /// SHA256 hash of the version deployment package.
    #[prost(string, tag = "3")]
    pub sha256: ::prost::alloc::string::String,
}
/// Version connectivity specification.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Connectivity {
    /// Network the version will have access to.
    /// It's essential to specify network with subnets in all availability zones.
    #[prost(string, tag = "1")]
    pub network_id: ::prost::alloc::string::String,
    /// Complete list of subnets (from the same network) the version can be attached to.
    /// It's essential to specify at least one subnet for each availability zones.
    #[prost(string, repeated, tag = "2")]
    pub subnet_id: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ScalingPolicy {
    /// ID of the function that the scaling policy belongs to.
    #[prost(string, tag = "1")]
    pub function_id: ::prost::alloc::string::String,
    /// Tag of the version that the scaling policy belongs to. For details, see [Version tag](/docs/functions/concepts/function#tag).
    #[prost(string, tag = "2")]
    pub tag: ::prost::alloc::string::String,
    /// Creation timestamp for the scaling policy
    #[prost(message, optional, tag = "3")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Modification timestamp for the scaling policy
    #[prost(message, optional, tag = "4")]
    pub modified_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Minimum guaranteed provisioned instances count for all zones in total.
    /// Billed separately.
    #[prost(int64, tag = "6")]
    pub provisioned_instances_count: i64,
    /// Upper limit for instance count in each zone.
    /// 0 means no limit.
    #[prost(int64, tag = "7")]
    pub zone_instances_limit: i64,
    /// Upper limit of requests count in each zone.
    /// 0 means no limit.
    #[prost(int64, tag = "8")]
    pub zone_requests_limit: i64,
}
/// Secret for serverless function.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Secret {
    /// ID of Yandex Lockbox secret.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of Yandex Lockbox version.
    #[prost(string, tag = "2")]
    pub version_id: ::prost::alloc::string::String,
    /// Key in secret's payload, which value to be delivered into function environment.
    #[prost(string, tag = "3")]
    pub key: ::prost::alloc::string::String,
    #[prost(oneof = "secret::Reference", tags = "4")]
    pub reference: ::core::option::Option<secret::Reference>,
}
/// Nested message and enum types in `Secret`.
pub mod secret {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Reference {
        /// environment variable in which secret's value to be delivered.
        #[prost(string, tag = "4")]
        EnvironmentVariable(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LogOptions {
    /// Is logging from function disabled.
    #[prost(bool, tag = "1")]
    pub disabled: bool,
    /// Minimum log entry level.
    ///
    /// See \[LogLevel.Level\] for details.
    #[prost(
        enumeration = "super::super::super::logging::v1::log_level::Level",
        tag = "4"
    )]
    pub min_level: i32,
    /// Log entries destination.
    #[prost(oneof = "log_options::Destination", tags = "2, 3")]
    pub destination: ::core::option::Option<log_options::Destination>,
}
/// Nested message and enum types in `LogOptions`.
pub mod log_options {
    /// Log entries destination.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Destination {
        /// Entry should be written to log group resolved by ID.
        #[prost(string, tag = "2")]
        LogGroupId(::prost::alloc::string::String),
        /// Entry should be written to default log group for specified folder.
        #[prost(string, tag = "3")]
        FolderId(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StorageMount {
    /// S3 bucket name for mounting.
    #[prost(string, tag = "1")]
    pub bucket_id: ::prost::alloc::string::String,
    /// S3 bucket prefix for mounting.
    #[prost(string, tag = "2")]
    pub prefix: ::prost::alloc::string::String,
    /// Mount point directory name (not path) for mounting.
    #[prost(string, tag = "3")]
    pub mount_point_name: ::prost::alloc::string::String,
    /// Is mount read only.
    #[prost(bool, tag = "4")]
    pub read_only: bool,
}
/// Mount contains an information about version's external storage mount
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Mount {
    /// Unique mount point name. Device will be mounted into /function/storage/<name>
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Mount's mode
    #[prost(enumeration = "mount::Mode", tag = "3")]
    pub mode: i32,
    /// Target mount option
    #[prost(oneof = "mount::Target", tags = "10, 11")]
    pub target: ::core::option::Option<mount::Target>,
}
/// Nested message and enum types in `Mount`.
pub mod mount {
    /// ObjectStorage as a mount
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ObjectStorage {
        /// ObjectStorage bucket name for mounting.
        #[prost(string, tag = "1")]
        pub bucket_id: ::prost::alloc::string::String,
        /// ObjectStorage bucket prefix for mounting.
        #[prost(string, tag = "2")]
        pub prefix: ::prost::alloc::string::String,
    }
    /// Disk as a mount
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct DiskSpec {
        /// The size of disk for mount in bytes
        #[prost(int64, tag = "1")]
        pub size: i64,
        /// Optional block size of disk for mount in bytes
        #[prost(int64, tag = "2")]
        pub block_size: i64,
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Mode {
        Unspecified = 0,
        ReadOnly = 1,
        ReadWrite = 2,
    }
    impl Mode {
        /// 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 {
                Mode::Unspecified => "MODE_UNSPECIFIED",
                Mode::ReadOnly => "READ_ONLY",
                Mode::ReadWrite => "READ_WRITE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "MODE_UNSPECIFIED" => Some(Self::Unspecified),
                "READ_ONLY" => Some(Self::ReadOnly),
                "READ_WRITE" => Some(Self::ReadWrite),
                _ => None,
            }
        }
    }
    /// Target mount option
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Target {
        /// Object storage mounts
        #[prost(message, tag = "10")]
        ObjectStorage(ObjectStorage),
        /// Working disk (worker-local non-shared read-write NBS disk templates)
        #[prost(message, tag = "11")]
        EphemeralDiskSpec(DiskSpec),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AsyncInvocationConfig {
    /// Number of retries of version invocation
    #[prost(int64, tag = "1")]
    pub retries_count: i64,
    /// Target for successful result of the version's invocation
    #[prost(message, optional, tag = "2")]
    pub success_target: ::core::option::Option<async_invocation_config::ResponseTarget>,
    /// Target for unsuccessful result, if all retries failed
    #[prost(message, optional, tag = "3")]
    pub failure_target: ::core::option::Option<async_invocation_config::ResponseTarget>,
    /// Service account which can invoke version
    #[prost(string, tag = "4")]
    pub service_account_id: ::prost::alloc::string::String,
}
/// Nested message and enum types in `AsyncInvocationConfig`.
pub mod async_invocation_config {
    /// Target to which a result of an invocation will be sent
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ResponseTarget {
        #[prost(oneof = "response_target::Target", tags = "1, 2")]
        pub target: ::core::option::Option<response_target::Target>,
    }
    /// Nested message and enum types in `ResponseTarget`.
    pub mod response_target {
        #[allow(clippy::derive_partial_eq_without_eq)]
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Target {
            /// Target to ignore a result
            #[prost(message, tag = "1")]
            EmptyTarget(super::super::EmptyTarget),
            /// Target to send a result to ymq
            #[prost(message, tag = "2")]
            YmqTarget(super::super::YmqTarget),
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct YmqTarget {
    /// Queue ARN
    #[prost(string, tag = "1")]
    pub queue_arn: ::prost::alloc::string::String,
    /// Service account which has write permission on the queue.
    #[prost(string, tag = "2")]
    pub service_account_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EmptyTarget {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MetadataOptions {
    /// Enabled access to GCE flavored metadata
    #[prost(enumeration = "MetadataOption", tag = "1")]
    pub gce_http_endpoint: i32,
    /// Enabled access to AWS flavored metadata (IMDSv1)
    #[prost(enumeration = "MetadataOption", tag = "2")]
    pub aws_v1_http_endpoint: i32,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum MetadataOption {
    /// Option is default
    Unspecified = 0,
    /// Option is enabled
    Enabled = 1,
    /// Option is disabled
    Disabled = 2,
}
impl MetadataOption {
    /// 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 {
            MetadataOption::Unspecified => "METADATA_OPTION_UNSPECIFIED",
            MetadataOption::Enabled => "ENABLED",
            MetadataOption::Disabled => "DISABLED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "METADATA_OPTION_UNSPECIFIED" => Some(Self::Unspecified),
            "ENABLED" => Some(Self::Enabled),
            "DISABLED" => Some(Self::Disabled),
            _ => None,
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetFunctionRequest {
    /// ID of the function to return.
    ///
    /// To get a function ID make a \[FunctionService.List\] request.
    #[prost(string, tag = "1")]
    pub function_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetFunctionVersionRequest {
    /// ID of the version to return.
    ///
    /// To get a version ID make a \[FunctionService.ListVersions\] request.
    #[prost(string, tag = "1")]
    pub function_version_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetFunctionVersionByTagRequest {
    /// ID of the function whose versions should be listed.
    ///
    /// To get a function ID use a \[FunctionService.List\] request.
    #[prost(string, tag = "1")]
    pub function_id: ::prost::alloc::string::String,
    /// Version tag.
    ///
    /// To get the history of version tags make a \[FunctionService.ListTagHistory\] request.
    #[prost(string, tag = "2")]
    pub tag: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListFunctionsRequest {
    /// ID of the folder to list functions in.
    ///
    /// To get a folder ID make 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 `pageSize`, the service returns a \[ListFunctionsResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    ///
    /// Default value: 100.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set `pageToken` to the
    /// \[ListFunctionsResponse.next_page_token\] returned by a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// A filter expression that filters functions listed in the response.
    ///
    /// The expression must specify:
    /// 1. The field name. Currently filtering can only be applied to the \[Function.name\] field.
    /// 2. An `=` operator.
    /// 3. The value in double quotes (`"`). Must be 3-63 characters long and match the regular expression `\[a-z][-a-z0-9]{1,61}[a-z0-9\]`.
    /// Example of a filter: `name="my-function"`.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListFunctionsResponse {
    /// List of functions in the specified folder.
    #[prost(message, repeated, tag = "1")]
    pub functions: ::prost::alloc::vec::Vec<Function>,
    /// Token for getting the next page of the list. If the number of results is greater than
    /// the specified \[ListFunctionsRequest.page_size\], use `nextPageToken` as the value
    /// for the \[ListFunctionsRequest.page_token\] parameter in the next list request.
    ///
    /// Each subsequent page will have its own `nextPageToken` 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 CreateFunctionRequest {
    /// ID of the folder to create a function in.
    ///
    /// To get a folder ID make a \[yandex.cloud.resourcemanager.v1.FolderService.List\] request.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// Name of the function.
    /// The name must be unique within the folder.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Description of the function.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Resource labels as `key:value` pairs.
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateFunctionMetadata {
    /// ID of the function that is being created.
    #[prost(string, tag = "1")]
    pub function_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateFunctionRequest {
    /// ID of the function to update.
    ///
    /// To get a function ID make a \[FunctionService.List\] request.
    #[prost(string, tag = "1")]
    pub function_id: ::prost::alloc::string::String,
    /// Field mask that specifies which attributes of the function should be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// New name for the function.
    /// The name must be unique within the folder.
    #[prost(string, tag = "3")]
    pub name: ::prost::alloc::string::String,
    /// New description for the function.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// Function labels as `key:value` pairs.
    ///
    /// Existing set of labels is completely replaced by the provided set, so if you just want
    /// to add or remove a label, request the current set of labels with a \[FunctionService.Get\] request.
    #[prost(map = "string, string", tag = "5")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateFunctionMetadata {
    /// ID of the function that is being updated.
    #[prost(string, tag = "1")]
    pub function_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteFunctionRequest {
    /// ID of the function to delete.
    /// To get a function ID make a \[FunctionService.List\] request.
    #[prost(string, tag = "1")]
    pub function_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteFunctionMetadata {
    /// ID of the function that is being deleted.
    #[prost(string, tag = "1")]
    pub function_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteFunctionVersionRequest {
    /// ID of the function's version to delete.
    #[prost(string, tag = "2")]
    pub function_version_id: ::prost::alloc::string::String,
    /// Forces deletion of the version tags.
    ///
    /// If the value equals false and the function has tags with the selected version then request returns an error.
    #[prost(bool, tag = "3")]
    pub force: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteFunctionVersionMetadata {
    /// ID of the function's version is being deleted.
    #[prost(string, tag = "2")]
    pub function_version_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListRuntimesRequest {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListRuntimesResponse {
    /// Runtime environments available for the specified function.
    #[prost(string, repeated, tag = "1")]
    pub runtimes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListFunctionsVersionsRequest {
    /// The maximum number of results per page to return. If the number of available results
    /// is larger than `pageSize`, the service returns a \[ListFunctionsVersionsResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    ///
    /// Default value: 100.
    #[prost(int64, tag = "3")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set `pageToken` to the
    /// \[ListFunctionsVersionsResponse.next_page_token\] returned by a previous list request.
    #[prost(string, tag = "4")]
    pub page_token: ::prost::alloc::string::String,
    /// A filter expression that filters resources listed in the response.
    ///
    /// The expression must specify:
    /// 1. The field name. Currently filtering can only be applied to the \[Version.status\] and \[Version.runtime\] fields.
    /// 2. An `=` operator.
    /// 3. The value in double quotes (`"`). Must be 3-63 characters long and match the regular expression `\[a-z][-a-z0-9]{1,61}[a-z0-9\]`.
    /// Example of a filter: `status="ACTIVE"`.
    #[prost(string, tag = "5")]
    pub filter: ::prost::alloc::string::String,
    #[prost(oneof = "list_functions_versions_request::Id", tags = "1, 2")]
    pub id: ::core::option::Option<list_functions_versions_request::Id>,
}
/// Nested message and enum types in `ListFunctionsVersionsRequest`.
pub mod list_functions_versions_request {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Id {
        /// ID of the folder to list function versions for.
        /// To get a folder ID make a \[yandex.cloud.resourcemanager.v1.FolderService.List\] request.
        #[prost(string, tag = "1")]
        FolderId(::prost::alloc::string::String),
        /// ID of the function to list versions for.
        /// To get a function ID use a \[FunctionService.List\] request.
        #[prost(string, tag = "2")]
        FunctionId(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListFunctionsVersionsResponse {
    /// List of versions for the specified folder or function.
    #[prost(message, repeated, tag = "1")]
    pub versions: ::prost::alloc::vec::Vec<Version>,
    /// Token for getting the next page of the list. If the number of results is greater than
    /// the specified \[ListFunctionsVersionsRequest.page_size\], use `nextPageToken` as the value
    /// for the \[ListFunctionsVersionsRequest.page_token\] parameter in the next list request.
    ///
    /// Each subsequent page will have its own `nextPageToken` 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 ListFunctionOperationsRequest {
    /// ID of the function to list operations for.
    #[prost(string, tag = "1")]
    pub function_id: ::prost::alloc::string::String,
    /// The maximum number of results per page that should be returned. If the number of available
    /// results is larger than `pageSize`, the service returns a \[ListFunctionOperationsResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    ///
    /// Default value: 100.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set `pageToken` to the
    /// \[ListFunctionOperationsResponse.next_page_token\] returned by a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// A filter expression that filters resources listed in the response.
    ///
    /// The expression must specify:
    /// 1. The field name. Currently filtering can be applied to the \[operation.Operation.done\], \[operation.Operation.created_by\] field.
    /// 2. An `=` operator.
    /// 3. The value in double quotes (`"`). Must be 3-63 characters long and match the regular expression `\[a-z][-a-z0-9]{1,61}[a-z0-9\]`.
    /// Examples of a filter: `done=false`, `created_by='John.Doe'`.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListFunctionOperationsResponse {
    /// List of operations for the specified function.
    #[prost(message, repeated, tag = "1")]
    pub operations: ::prost::alloc::vec::Vec<super::super::super::operation::Operation>,
    /// Token for getting the next page of the list. If the number of results is greater than
    /// the specified \[ListFunctionOperationsRequest.page_size\], use `nextPageToken` as the value
    /// for the \[ListFunctionOperationsRequest.page_token\] parameter in the next list request.
    ///
    /// Each subsequent page will have its own `nextPageToken` 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 CreateFunctionVersionRequest {
    /// ID of the function to create a version for.
    ///
    /// To get a function ID, make a \[FunctionService.List\] request.
    #[prost(string, tag = "1")]
    pub function_id: ::prost::alloc::string::String,
    /// Runtime environment for the version.
    #[prost(string, tag = "2")]
    pub runtime: ::prost::alloc::string::String,
    /// Description of the version
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Entrypoint of the version.
    #[prost(string, tag = "4")]
    pub entrypoint: ::prost::alloc::string::String,
    /// Resources allocated to the version.
    #[prost(message, optional, tag = "5")]
    pub resources: ::core::option::Option<Resources>,
    /// Timeout for the execution of the version.
    ///
    /// If the timeout is exceeded, Cloud Functions responds with a 504 HTTP code.
    #[prost(message, optional, tag = "6")]
    pub execution_timeout: ::core::option::Option<::prost_types::Duration>,
    /// ID of the service account to associate with the version.
    #[prost(string, tag = "7")]
    pub service_account_id: ::prost::alloc::string::String,
    /// Environment settings for the version.
    #[prost(map = "string, string", tag = "12")]
    pub environment: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Function version tags. For details, see [Version tag](/docs/functions/concepts/function#tag).
    #[prost(string, repeated, tag = "13")]
    pub tag: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Function version connectivity. If specified the version will be attached to specified network/subnet(s).
    #[prost(message, optional, tag = "17")]
    pub connectivity: ::core::option::Option<Connectivity>,
    /// Additional service accounts to be used by the version.
    #[prost(map = "string, string", tag = "15")]
    pub named_service_accounts: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Yandex Lockbox secrets to be used by the version.
    #[prost(message, repeated, tag = "18")]
    pub secrets: ::prost::alloc::vec::Vec<Secret>,
    /// Options for logging from the function
    #[prost(message, optional, tag = "19")]
    pub log_options: ::core::option::Option<LogOptions>,
    /// S3 mounts to be used by the version.
    #[prost(message, repeated, tag = "20")]
    pub storage_mounts: ::prost::alloc::vec::Vec<StorageMount>,
    /// Config for asynchronous invocations of the version
    #[prost(message, optional, tag = "22")]
    pub async_invocation_config: ::core::option::Option<AsyncInvocationConfig>,
    /// Optional size of in-memory mounted /tmp directory in bytes.
    /// Available for versions with resources.memory greater or equal to 1024 MiB.
    ///
    /// 0 or in range from 512 MiB to 3/4 of resources.memory.
    #[prost(int64, tag = "23")]
    pub tmpfs_size: i64,
    /// The maximum number of requests processed by a function instance at the same time
    #[prost(int64, tag = "24")]
    pub concurrency: i64,
    /// Mounts to be used by the version.
    #[prost(message, repeated, tag = "25")]
    pub mounts: ::prost::alloc::vec::Vec<Mount>,
    /// Metadata options for the version.
    #[prost(message, optional, tag = "26")]
    pub metadata_options: ::core::option::Option<MetadataOptions>,
    /// Source of the deployment package for the version.
    #[prost(
        oneof = "create_function_version_request::PackageSource",
        tags = "9, 10, 11"
    )]
    pub package_source: ::core::option::Option<
        create_function_version_request::PackageSource,
    >,
}
/// Nested message and enum types in `CreateFunctionVersionRequest`.
pub mod create_function_version_request {
    /// Source of the deployment package for the version.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum PackageSource {
        /// Functions deployment package.
        #[prost(message, tag = "9")]
        Package(super::Package),
        /// Content of the deployment package.
        #[prost(bytes, tag = "10")]
        Content(::prost::alloc::vec::Vec<u8>),
        /// ID of the version to be copied from. Source version must belong to the same folder as the created version
        /// and the user must have read permissions to the source version.
        #[prost(string, tag = "11")]
        VersionId(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateFunctionVersionMetadata {
    /// ID of the version that is being created.
    #[prost(string, tag = "1")]
    pub function_version_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SetFunctionTagRequest {
    /// ID of the version to set the tag for.
    ///
    /// To get a version ID make a \[FunctionService.ListVersions\] request.
    #[prost(string, tag = "1")]
    pub function_version_id: ::prost::alloc::string::String,
    /// Tag to set for the version.
    #[prost(string, tag = "2")]
    pub tag: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RemoveFunctionTagRequest {
    /// ID of the version to remove a tag from.
    ///
    /// To get the a version ID make a \[FunctionService.ListVersions\] request.
    #[prost(string, tag = "1")]
    pub function_version_id: ::prost::alloc::string::String,
    /// Tag to remove from the specified version.
    #[prost(string, tag = "2")]
    pub tag: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SetFunctionTagMetadata {
    /// ID of the function versions that is being tagged.
    #[prost(string, tag = "1")]
    pub function_version_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RemoveFunctionTagMetadata {
    /// ID of the function versions that is being untagged.
    #[prost(string, tag = "1")]
    pub function_version_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListFunctionTagHistoryRequest {
    /// ID of the function to retrieve tag history for.
    ///
    /// To get a function ID, make a \[FunctionService.List\] request.
    #[prost(string, tag = "1")]
    pub function_id: ::prost::alloc::string::String,
    /// Specific tag that history should be limited to.
    #[prost(string, tag = "2")]
    pub tag: ::prost::alloc::string::String,
    /// The maximum number of results per page that should be returned. If the number of available
    /// results is larger than `pageSize`, the service returns a \[ListFunctionOperationsResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    /// Default value: 100.
    #[prost(int64, tag = "3")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set `pageToken` to the
    /// \[ListFunctionOperationsResponse.next_page_token\] returned by a previous list request.
    #[prost(string, tag = "4")]
    pub page_token: ::prost::alloc::string::String,
    /// A filter expression that filters resources listed in the response.
    ///
    /// The expression must specify:
    /// 1. The field name. Currently filtering can only be applied to the \[FunctionTagHistoryRecord.effective_from\] and \[FunctionTagHistoryRecord.effective_to\] fields.
    /// 2. An `=` or `>` or `<` operator.
    /// 3. The value in double quotes (`"`). Must be 3-63 characters long and match the regular expression `\[a-z][-a-z0-9]{1,61}[a-z0-9\]`.
    /// For example, `effective_to>2021-01-01T12:00:00Z`.
    #[prost(string, tag = "5")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListFunctionTagHistoryResponse {
    /// Set of relevant tag history records.
    #[prost(message, repeated, tag = "1")]
    pub function_tag_history_record: ::prost::alloc::vec::Vec<
        list_function_tag_history_response::FunctionTagHistoryRecord,
    >,
    /// Token for getting the next page of the list. If the number of results is greater than
    /// the specified \[ListFunctionTagHistoryRequest.page_size\], use `nextPageToken` as the value
    /// for the \[ListFunctionTagHistoryRequest.page_token\] parameter in the next list request.
    ///
    /// Each subsequent page will have its own `nextPageToken` to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Nested message and enum types in `ListFunctionTagHistoryResponse`.
pub mod list_function_tag_history_response {
    /// A record in the tag history.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct FunctionTagHistoryRecord {
        /// ID of the function that the record is about.
        #[prost(string, tag = "1")]
        pub function_id: ::prost::alloc::string::String,
        /// ID of the function version that the record is about.
        #[prost(string, tag = "3")]
        pub function_version_id: ::prost::alloc::string::String,
        /// Tag that was set for the version at some point.
        #[prost(string, tag = "2")]
        pub tag: ::prost::alloc::string::String,
        /// Timestamp when the tag started being active for the function.
        #[prost(message, optional, tag = "4")]
        pub effective_from: ::core::option::Option<::prost_types::Timestamp>,
        /// Timestamp when the tag stopped being active for the function.
        #[prost(message, optional, tag = "5")]
        pub effective_to: ::core::option::Option<::prost_types::Timestamp>,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListScalingPoliciesRequest {
    /// ID of the function to retrieve scaling policies for.
    ///
    /// To get a function ID, make a \[FunctionService.List\] request.
    #[prost(string, tag = "1")]
    pub function_id: ::prost::alloc::string::String,
    /// The maximum number of results per page that should be returned. If the number of available
    /// results is larger than `pageSize`, the service returns a \[ListScalingPoliciesResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    ///
    /// Default value: 100.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set `pageToken` to the
    /// \[ListScalingPoliciesResponse.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 ListScalingPoliciesResponse {
    /// Set of relevant scaling policies.
    #[prost(message, repeated, tag = "1")]
    pub scaling_policies: ::prost::alloc::vec::Vec<ScalingPolicy>,
    /// Token for getting the next page of the list. If the number of results is greater than
    /// the specified \[ListScalingPoliciesRequest.page_size\], use `nextPageToken` as the value
    /// for the \[ListScalingPoliciesRequest.page_token\] parameter in the next list request.
    ///
    /// Each subsequent page will have its own `nextPageToken` 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 SetScalingPolicyRequest {
    /// ID of the function to retrieve scaling policies for.
    ///
    /// To get a function ID, make a \[FunctionService.List\] request.
    #[prost(string, tag = "1")]
    pub function_id: ::prost::alloc::string::String,
    /// Version tag.
    ///
    /// To get the history of version tags make a \[FunctionService.ListTagHistory\] request.
    #[prost(string, tag = "2")]
    pub tag: ::prost::alloc::string::String,
    /// Minimum guaranteed provisioned instances count for all zones in total.
    /// Billed separately.
    #[prost(int64, tag = "4")]
    pub provisioned_instances_count: i64,
    /// Upper limit for instance count in each zone.
    /// 0 means no limit.
    #[prost(int64, tag = "5")]
    pub zone_instances_limit: i64,
    /// Upper limit of requests count in each zone.
    /// 0 means no limit.
    #[prost(int64, tag = "6")]
    pub zone_requests_limit: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SetScalingPolicyMetadata {
    /// ID of the function for which scaling policy was set.
    #[prost(string, tag = "1")]
    pub function_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RemoveScalingPolicyRequest {
    /// ID of the function to remove scaling policies for.
    ///
    /// To get a function ID, make a \[FunctionService.List\] request.
    #[prost(string, tag = "1")]
    pub function_id: ::prost::alloc::string::String,
    /// Version tag.
    ///
    /// To get the history of version tags make a \[FunctionService.ListTagHistory\] request.
    #[prost(string, tag = "2")]
    pub tag: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RemoveScalingPolicyMetadata {
    /// ID of the function for which scaling policy was removed.
    #[prost(string, tag = "1")]
    pub function_id: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod function_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 serverless functions.
    #[derive(Debug, Clone)]
    pub struct FunctionServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl FunctionServiceClient<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> FunctionServiceClient<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,
        ) -> FunctionServiceClient<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,
        {
            FunctionServiceClient::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 function.
        ///
        /// To get the list of all available functions, make a [List] request.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetFunctionRequest>,
        ) -> std::result::Result<tonic::Response<super::Function>, 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.serverless.functions.v1.FunctionService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.functions.v1.FunctionService",
                        "Get",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of functions in the specified folder.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListFunctionsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListFunctionsResponse>,
            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.serverless.functions.v1.FunctionService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.functions.v1.FunctionService",
                        "List",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a function in the specified folder.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateFunctionRequest>,
        ) -> 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.serverless.functions.v1.FunctionService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.functions.v1.FunctionService",
                        "Create",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified function.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateFunctionRequest>,
        ) -> 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.serverless.functions.v1.FunctionService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.functions.v1.FunctionService",
                        "Update",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified function.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteFunctionRequest>,
        ) -> 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.serverless.functions.v1.FunctionService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.functions.v1.FunctionService",
                        "Delete",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns the specified version of a function.
        ///
        /// To get the list of available version, make a [ListVersions] request.
        pub async fn get_version(
            &mut self,
            request: impl tonic::IntoRequest<super::GetFunctionVersionRequest>,
        ) -> std::result::Result<tonic::Response<super::Version>, 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.serverless.functions.v1.FunctionService/GetVersion",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.functions.v1.FunctionService",
                        "GetVersion",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns all versions with the specified tag.
        ///
        /// To get the list of all available versions, make a [ListVersions] request.
        pub async fn get_version_by_tag(
            &mut self,
            request: impl tonic::IntoRequest<super::GetFunctionVersionByTagRequest>,
        ) -> std::result::Result<tonic::Response<super::Version>, 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.serverless.functions.v1.FunctionService/GetVersionByTag",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.functions.v1.FunctionService",
                        "GetVersionByTag",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of versions for the specified function, or of all function versions
        /// in the specified folder.
        pub async fn list_versions(
            &mut self,
            request: impl tonic::IntoRequest<super::ListFunctionsVersionsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListFunctionsVersionsResponse>,
            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.serverless.functions.v1.FunctionService/ListVersions",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.functions.v1.FunctionService",
                        "ListVersions",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified version of a function.
        ///
        /// NOTE: old untagged function versions are deleted automatically.
        pub async fn delete_version(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteFunctionVersionRequest>,
        ) -> 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.serverless.functions.v1.FunctionService/DeleteVersion",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.functions.v1.FunctionService",
                        "DeleteVersion",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Set a tag for the specified version of a function.
        pub async fn set_tag(
            &mut self,
            request: impl tonic::IntoRequest<super::SetFunctionTagRequest>,
        ) -> 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.serverless.functions.v1.FunctionService/SetTag",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.functions.v1.FunctionService",
                        "SetTag",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Remove a tag from the specified version of a function.
        pub async fn remove_tag(
            &mut self,
            request: impl tonic::IntoRequest<super::RemoveFunctionTagRequest>,
        ) -> 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.serverless.functions.v1.FunctionService/RemoveTag",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.functions.v1.FunctionService",
                        "RemoveTag",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns the log of tags assigned to versions of the specified function.
        pub async fn list_tag_history(
            &mut self,
            request: impl tonic::IntoRequest<super::ListFunctionTagHistoryRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListFunctionTagHistoryResponse>,
            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.serverless.functions.v1.FunctionService/ListTagHistory",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.functions.v1.FunctionService",
                        "ListTagHistory",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a version for the specified function.
        pub async fn create_version(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateFunctionVersionRequest>,
        ) -> 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.serverless.functions.v1.FunctionService/CreateVersion",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.functions.v1.FunctionService",
                        "CreateVersion",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists available runtime environments for the specified function.
        pub async fn list_runtimes(
            &mut self,
            request: impl tonic::IntoRequest<super::ListRuntimesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListRuntimesResponse>,
            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.serverless.functions.v1.FunctionService/ListRuntimes",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.functions.v1.FunctionService",
                        "ListRuntimes",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists operations for the specified function.
        pub async fn list_operations(
            &mut self,
            request: impl tonic::IntoRequest<super::ListFunctionOperationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListFunctionOperationsResponse>,
            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.serverless.functions.v1.FunctionService/ListOperations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.functions.v1.FunctionService",
                        "ListOperations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists existing access bindings for the specified function.
        pub async fn list_access_bindings(
            &mut self,
            request: impl tonic::IntoRequest<
                super::super::super::super::access::ListAccessBindingsRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<
                super::super::super::super::access::ListAccessBindingsResponse,
            >,
            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.serverless.functions.v1.FunctionService/ListAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.functions.v1.FunctionService",
                        "ListAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Sets access bindings for the function.
        pub async fn set_access_bindings(
            &mut self,
            request: impl tonic::IntoRequest<
                super::super::super::super::access::SetAccessBindingsRequest,
            >,
        ) -> 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.serverless.functions.v1.FunctionService/SetAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.functions.v1.FunctionService",
                        "SetAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates access bindings for the specified function.
        pub async fn update_access_bindings(
            &mut self,
            request: impl tonic::IntoRequest<
                super::super::super::super::access::UpdateAccessBindingsRequest,
            >,
        ) -> 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.serverless.functions.v1.FunctionService/UpdateAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.functions.v1.FunctionService",
                        "UpdateAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists existing scaling policies for specified function
        pub async fn list_scaling_policies(
            &mut self,
            request: impl tonic::IntoRequest<super::ListScalingPoliciesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListScalingPoliciesResponse>,
            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.serverless.functions.v1.FunctionService/ListScalingPolicies",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.functions.v1.FunctionService",
                        "ListScalingPolicies",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Set scaling policy for specified function and tag
        pub async fn set_scaling_policy(
            &mut self,
            request: impl tonic::IntoRequest<super::SetScalingPolicyRequest>,
        ) -> 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.serverless.functions.v1.FunctionService/SetScalingPolicy",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.functions.v1.FunctionService",
                        "SetScalingPolicy",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Remove scaling policy for specified function and tag
        pub async fn remove_scaling_policy(
            &mut self,
            request: impl tonic::IntoRequest<super::RemoveScalingPolicyRequest>,
        ) -> 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.serverless.functions.v1.FunctionService/RemoveScalingPolicy",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.functions.v1.FunctionService",
                        "RemoveScalingPolicy",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// A VPC network used in serverless resources.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UsedNetwork {
    /// ID of the VPC network.
    #[prost(string, tag = "1")]
    pub network_id: ::prost::alloc::string::String,
    /// ID of the cloud that the network belongs to.
    #[prost(string, tag = "2")]
    pub cloud_id: ::prost::alloc::string::String,
    /// ID of the folder that the network belongs to.
    #[prost(string, tag = "3")]
    pub folder_id: ::prost::alloc::string::String,
    /// Status of the network.
    #[prost(enumeration = "used_network::Status", tag = "4")]
    pub status: i32,
    /// Clean-up timestamp of the obsolete network.
    #[prost(message, optional, tag = "5")]
    pub will_be_cleaned_up_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Number of serverless resources connected to the network.
    #[prost(int64, tag = "6")]
    pub connections_count: i64,
}
/// Nested message and enum types in `UsedNetwork`.
pub mod used_network {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Status {
        Unspecified = 0,
        /// Network is connecting to its first serverless resource.
        Creating = 1,
        /// Network is already being used by some serverless resources.
        Active = 2,
        /// Network is no longer used by any serverless resources.
        /// It will be cleaned-up after a while.
        Obsolete = 3,
    }
    impl Status {
        /// 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 {
                Status::Unspecified => "STATUS_UNSPECIFIED",
                Status::Creating => "CREATING",
                Status::Active => "ACTIVE",
                Status::Obsolete => "OBSOLETE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATUS_UNSPECIFIED" => Some(Self::Unspecified),
                "CREATING" => Some(Self::Creating),
                "ACTIVE" => Some(Self::Active),
                "OBSOLETE" => Some(Self::Obsolete),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetUsedNetworkRequest {
    /// ID of the network to return.
    #[prost(string, tag = "1")]
    pub network_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListUsedNetworksRequest {
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than `pageSize`, the service returns a \[ListUsedNetworksResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    ///
    /// Default value: 100.
    #[prost(int64, tag = "1")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set `pageToken` to the
    /// \[ListUsedNetworksResponse.next_page_token\] returned by a previous list request.
    #[prost(string, tag = "2")]
    pub page_token: ::prost::alloc::string::String,
    #[prost(oneof = "list_used_networks_request::Scope", tags = "3, 4")]
    pub scope: ::core::option::Option<list_used_networks_request::Scope>,
}
/// Nested message and enum types in `ListUsedNetworksRequest`.
pub mod list_used_networks_request {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Scope {
        /// ID of the cloud to list used networks in.
        #[prost(string, tag = "3")]
        CloudId(::prost::alloc::string::String),
        /// ID of the folder to list used networks in.
        #[prost(string, tag = "4")]
        FolderId(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListUsedNetworksResponse {
    /// List of used networks in the specified scope.
    #[prost(message, repeated, tag = "1")]
    pub networks: ::prost::alloc::vec::Vec<UsedNetwork>,
    /// Token for getting the next page of the list. If the number of results is greater than
    /// the specified \[ListUsedNetworksRequest.page_size\], use `nextPageToken` as the value
    /// for the \[ListUsedNetworksRequest.page_token\] parameter in the next list request.
    ///
    /// Each subsequent page will have its own `nextPageToken` 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 ListConnectedResourcesRequest {
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than `pageSize`, the service returns a \[ListConnectedResourcesResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    ///
    /// Default value: 100.
    #[prost(int64, tag = "1")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set `pageToken` to the
    /// \[ListConnectedResourcesResponse.next_page_token\] returned by a previous list request.
    #[prost(string, tag = "2")]
    pub page_token: ::prost::alloc::string::String,
    #[prost(oneof = "list_connected_resources_request::NetworkScope", tags = "3, 4, 5")]
    pub network_scope: ::core::option::Option<
        list_connected_resources_request::NetworkScope,
    >,
}
/// Nested message and enum types in `ListConnectedResourcesRequest`.
pub mod list_connected_resources_request {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum NetworkScope {
        /// ID of the network to list serverless resources connected to it.
        #[prost(string, tag = "3")]
        NetworkId(::prost::alloc::string::String),
        /// ID of the cloud to list serverless resources connected to any network from it.
        #[prost(string, tag = "4")]
        CloudId(::prost::alloc::string::String),
        /// ID of the folder to list serverless resources connected to any network from it.
        #[prost(string, tag = "5")]
        FolderId(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListConnectedResourcesResponse {
    /// List of serverless resources connected to any network from the specified scope.
    #[prost(message, repeated, tag = "1")]
    pub resources: ::prost::alloc::vec::Vec<
        list_connected_resources_response::ConnectedResource,
    >,
    /// Token for getting the next page of the list. If the number of results is greater than
    /// the specified \[ListConnectedResourcesRequest.page_size\], use `nextPageToken` as the value
    /// for the \[ListConnectedResourcesRequest.page_token\] parameter in the next list request.
    ///
    /// Each subsequent page will have its own `nextPageToken` to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Nested message and enum types in `ListConnectedResourcesResponse`.
pub mod list_connected_resources_response {
    /// Serverless resource connected to VPC network.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ConnectedResource {
        /// ID of the network to which the resource is connected.
        #[prost(string, tag = "1")]
        pub network_id: ::prost::alloc::string::String,
        /// Type of the serverless resource.
        #[prost(string, tag = "2")]
        pub resource_type: ::prost::alloc::string::String,
        /// ID of the serverless resource.
        #[prost(string, tag = "3")]
        pub resource_id: ::prost::alloc::string::String,
        /// Type of the serverless subresource.
        #[prost(string, tag = "4")]
        pub subresource_type: ::prost::alloc::string::String,
        /// ID of the serverless subresource.
        #[prost(string, tag = "5")]
        pub subresource_id: ::prost::alloc::string::String,
        /// ID of the cloud that the resource belongs to.
        #[prost(string, tag = "6")]
        pub resource_cloud_id: ::prost::alloc::string::String,
        /// ID of the folder thar the resource belongs to.
        #[prost(string, tag = "7")]
        pub resource_folder_id: ::prost::alloc::string::String,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TriggerUsedNetworkCleanupRequest {
    /// ID of the obsolete network to start the cleanup process for.
    #[prost(string, tag = "1")]
    pub network_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TriggerUsedNetworkCleanupResponse {
    /// Timestamp when cleanup of the specified network will be started.
    #[prost(message, optional, tag = "1")]
    pub network_cleanup_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Generated client implementations.
pub mod network_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 VPC networks connected to serverless resources.
    #[derive(Debug, Clone)]
    pub struct NetworkServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl NetworkServiceClient<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> NetworkServiceClient<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,
        ) -> NetworkServiceClient<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,
        {
            NetworkServiceClient::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 network used in serverless resources.
        pub async fn get_used(
            &mut self,
            request: impl tonic::IntoRequest<super::GetUsedNetworkRequest>,
        ) -> std::result::Result<tonic::Response<super::UsedNetwork>, 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.serverless.functions.v1.NetworkService/GetUsed",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.functions.v1.NetworkService",
                        "GetUsed",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of networks in the specified scope that are used in serverless resources.
        pub async fn list_used(
            &mut self,
            request: impl tonic::IntoRequest<super::ListUsedNetworksRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListUsedNetworksResponse>,
            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.serverless.functions.v1.NetworkService/ListUsed",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.functions.v1.NetworkService",
                        "ListUsed",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of serverless resources connected to any network from the specified scope.
        pub async fn list_connected_resources(
            &mut self,
            request: impl tonic::IntoRequest<super::ListConnectedResourcesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListConnectedResourcesResponse>,
            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.serverless.functions.v1.NetworkService/ListConnectedResources",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.functions.v1.NetworkService",
                        "ListConnectedResources",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Forces obsolete used network to start cleanup process as soon as possible.
        /// Invocation does not wait for start or end of the cleanup process.
        /// Second invocation with the same network does nothing until network is completely cleaned-up.
        pub async fn trigger_used_cleanup(
            &mut self,
            request: impl tonic::IntoRequest<super::TriggerUsedNetworkCleanupRequest>,
        ) -> std::result::Result<
            tonic::Response<super::TriggerUsedNetworkCleanupResponse>,
            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.serverless.functions.v1.NetworkService/TriggerUsedCleanup",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.functions.v1.NetworkService",
                        "TriggerUsedCleanup",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}