yandex-cloud 2025.4.14

/// An Address resource. For more information, see \[Address\](/docs/vpc/concepts/address).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Address {
    /// ID of the address. Generated at creation time.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the folder that the address belongs to.
    #[prost(string, tag = "2")]
    pub folder_id: ::prost::alloc::string::String,
    /// Creation timestamp.
    #[prost(message, optional, tag = "3")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Name of the address.
    /// The name is unique within the folder.
    /// Value must match the regular expression ``\|\[a-zA-Z]([-_a-zA-Z0-9]{0,61}[a-zA-Z0-9\])?``.
    #[prost(string, tag = "4")]
    pub name: ::prost::alloc::string::String,
    /// Description of the address. 0-256 characters long.
    #[prost(string, tag = "5")]
    pub description: ::prost::alloc::string::String,
    /// Address labels as `key:value` pairs.
    /// No more than 64 per resource.
    /// The maximum string length in characters for each value is 63.
    /// Each value must match the regular expression `\[-_0-9a-z\]*`.
    /// The string length in characters for each key must be 1-63.
    /// Each key must match the regular expression `\[a-z][-_0-9a-z\]*`.
    #[prost(map = "string, string", tag = "6")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Specifies if address is reserved or not.
    #[prost(bool, tag = "15")]
    pub reserved: bool,
    /// Specifies if address is used or not.
    #[prost(bool, tag = "16")]
    pub used: bool,
    /// Type of the IP address.
    #[prost(enumeration = "address::Type", tag = "17")]
    pub r#type: i32,
    /// Version of the IP address.
    #[prost(enumeration = "address::IpVersion", tag = "18")]
    pub ip_version: i32,
    /// Specifies if address protected from deletion.
    #[prost(bool, tag = "19")]
    pub deletion_protection: bool,
    /// Optional DNS record specifications
    #[prost(message, repeated, tag = "20")]
    pub dns_records: ::prost::alloc::vec::Vec<DnsRecord>,
    /// External ipv4 address specification.
    #[prost(oneof = "address::Address", tags = "7")]
    pub address: ::core::option::Option<address::Address>,
}
/// Nested message and enum types in `Address`.
pub mod address {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Type {
        Unspecified = 0,
        /// Internal IP address.
        Internal = 1,
        /// Public IP address.
        External = 2,
    }
    impl Type {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Type::Unspecified => "TYPE_UNSPECIFIED",
                Type::Internal => "INTERNAL",
                Type::External => "EXTERNAL",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "INTERNAL" => Some(Self::Internal),
                "EXTERNAL" => Some(Self::External),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum IpVersion {
        Unspecified = 0,
        /// IPv4 address.
        Ipv4 = 1,
        /// IPv6 address.
        Ipv6 = 2,
    }
    impl IpVersion {
        /// 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 {
                IpVersion::Unspecified => "IP_VERSION_UNSPECIFIED",
                IpVersion::Ipv4 => "IPV4",
                IpVersion::Ipv6 => "IPV6",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "IP_VERSION_UNSPECIFIED" => Some(Self::Unspecified),
                "IPV4" => Some(Self::Ipv4),
                "IPV6" => Some(Self::Ipv6),
                _ => None,
            }
        }
    }
    /// External ipv4 address specification.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Address {
        #[prost(message, tag = "7")]
        ExternalIpv4Address(super::ExternalIpv4Address),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExternalIpv4Address {
    /// Value of address.
    #[prost(string, tag = "1")]
    pub address: ::prost::alloc::string::String,
    /// Availability zone from which the address will be allocated.
    #[prost(string, tag = "2")]
    pub zone_id: ::prost::alloc::string::String,
    /// Parameters of the allocated address, for example DDoS Protection.
    #[prost(message, optional, tag = "3")]
    pub requirements: ::core::option::Option<AddressRequirements>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AddressRequirements {
    /// DDoS protection provider ID.
    #[prost(string, tag = "1")]
    pub ddos_protection_provider: ::prost::alloc::string::String,
    /// Capability to send SMTP traffic.
    #[prost(string, tag = "2")]
    pub outgoing_smtp_capability: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DnsRecord {
    /// DNS record name (absolute or relative to the DNS zone in use).
    #[prost(string, tag = "1")]
    pub fqdn: ::prost::alloc::string::String,
    /// ID of the public DNS zone.
    #[prost(string, tag = "2")]
    pub dns_zone_id: ::prost::alloc::string::String,
    /// TTL of record.
    #[prost(int64, tag = "3")]
    pub ttl: i64,
    /// If the PTR record is required, this parameter must be set to "true".
    #[prost(bool, tag = "4")]
    pub ptr: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetAddressRequest {
    /// ID of the Address resource to return.
    ///
    /// To get Address resource ID make a \[AddressService.List\] request.
    #[prost(string, tag = "1")]
    pub address_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetAddressByValueRequest {
    /// External ipv4 address specification.
    #[prost(oneof = "get_address_by_value_request::Address", tags = "1")]
    pub address: ::core::option::Option<get_address_by_value_request::Address>,
}
/// Nested message and enum types in `GetAddressByValueRequest`.
pub mod get_address_by_value_request {
    /// External ipv4 address specification.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Address {
        #[prost(string, tag = "1")]
        ExternalIpv4Address(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListAddressesRequest {
    /// ID of the folder to list addresses in.
    ///
    /// To get the folder ID use a \[yandex.cloud.resourcemanager.v1.FolderService.List\] request.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than `page_size`, the service returns a \[ListAddressesResponse.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 `page_token` to the
    /// \[ListAddressesResponse.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 Address listed in the response.
    ///
    /// The expression must specify:
    /// 1. The field name. Currently you can use filtering only on \[Address.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-address`.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListAddressesResponse {
    /// List of addresses.
    #[prost(message, repeated, tag = "1")]
    pub addresses: ::prost::alloc::vec::Vec<Address>,
    /// Token for getting the next page of the list. If the number of results is greater than
    /// the specified \[ListAddressesRequest.page_size\], use `next_page_token` as the value
    /// for the \[ListAddressesRequest.page_token\] parameter in the next list request.
    ///
    /// Each subsequent page will have its own `next_page_token` to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateAddressRequest {
    /// ID of the folder to create a address 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 address.
    /// The name must be unique within the folder.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Description of the address.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Address labels as `key:value` pairs.
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Specifies if address protected from deletion.
    #[prost(bool, tag = "10")]
    pub deletion_protection: bool,
    /// Optional DNS record specifications
    #[prost(message, repeated, tag = "11")]
    pub dns_record_specs: ::prost::alloc::vec::Vec<DnsRecordSpec>,
    /// External ipv4 address specification.
    #[prost(oneof = "create_address_request::AddressSpec", tags = "5")]
    pub address_spec: ::core::option::Option<create_address_request::AddressSpec>,
}
/// Nested message and enum types in `CreateAddressRequest`.
pub mod create_address_request {
    /// External ipv4 address specification.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum AddressSpec {
        #[prost(message, tag = "5")]
        ExternalIpv4AddressSpec(super::ExternalIpv4AddressSpec),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExternalIpv4AddressSpec {
    /// Value of address.
    ///
    /// if unspecified, one will be automatically allocated from other params
    #[prost(string, tag = "1")]
    pub address: ::prost::alloc::string::String,
    /// Availability zone from which the address will be allocated.
    ///
    /// only if address unspecified
    #[prost(string, tag = "2")]
    pub zone_id: ::prost::alloc::string::String,
    /// Parameters of the allocated address, for example DDoS Protection.
    #[prost(message, optional, tag = "3")]
    pub requirements: ::core::option::Option<AddressRequirements>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DnsRecordSpec {
    /// Required. DNS record name (absolute or relative to the DNS zone in use).
    #[prost(string, tag = "1")]
    pub fqdn: ::prost::alloc::string::String,
    /// Required. ID of the public DNS zone. The maximum string length in characters is 20.
    #[prost(string, tag = "2")]
    pub dns_zone_id: ::prost::alloc::string::String,
    /// TTL of record. Acceptable values are 0 to 86400, inclusive.
    #[prost(int64, tag = "3")]
    pub ttl: i64,
    /// Optional. If the PTR record is required, this parameter must be set to "true".
    #[prost(bool, tag = "4")]
    pub ptr: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateAddressMetadata {
    /// ID of the address that is being created.
    #[prost(string, tag = "1")]
    pub address_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateAddressRequest {
    /// ID of the address to update.
    ///
    /// To get the address ID make a \[AddressService.List\] request.
    #[prost(string, tag = "1")]
    pub address_id: ::prost::alloc::string::String,
    /// Field mask that specifies which attributes of the Address should be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// New name for the address.
    /// The name must be unique within the folder.
    #[prost(string, tag = "3")]
    pub name: ::prost::alloc::string::String,
    /// New description of the address.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// Address 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:
    /// 1. Get the current set of labels with a \[AddressService.Get\] request.
    /// 2. Add or remove a label in this set.
    /// 3. Send the new set in this field.
    #[prost(map = "string, string", tag = "5")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Specifies if address is reserved or not.
    #[prost(bool, tag = "6")]
    pub reserved: bool,
    /// Specifies if address protected from deletion.
    #[prost(bool, tag = "7")]
    pub deletion_protection: bool,
    /// Optional DNS record specifications
    #[prost(message, repeated, tag = "8")]
    pub dns_record_specs: ::prost::alloc::vec::Vec<DnsRecordSpec>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateAddressMetadata {
    /// ID of the Address that is being updated.
    #[prost(string, tag = "1")]
    pub address_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteAddressRequest {
    /// ID of the address to delete.
    ///
    /// To get a address ID make a \[AddressService.List\] request.
    #[prost(string, tag = "1")]
    pub address_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteAddressMetadata {
    /// ID of the address that is being deleted.
    #[prost(string, tag = "1")]
    pub address_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListAddressOperationsRequest {
    /// ID of the address to list operations for.
    ///
    /// To get a address ID make a \[AddressService.List\] request.
    #[prost(string, tag = "1")]
    pub address_id: ::prost::alloc::string::String,
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\], the service returns a \[ListAddressOperationsResponse.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 \[page_token\] to the
    /// \[ListAddressOperationsResponse.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 ListAddressOperationsResponse {
    /// List of operations for the specified address.
    #[prost(message, repeated, tag = "1")]
    pub operations: ::prost::alloc::vec::Vec<super::super::operation::Operation>,
    /// Token for getting the next page of the list. If the number of results is greater than
    /// the specified \[ListAddressOperationsRequest.page_size\], use `next_page_token` as the value
    /// for the \[ListAddressOperationsRequest.page_token\] parameter in the next list request.
    ///
    /// Each subsequent page will have its own `next_page_token` to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MoveAddressRequest {
    /// ID of the address that is being moved.
    #[prost(string, tag = "1")]
    pub address_id: ::prost::alloc::string::String,
    /// ID of the folder to move address to.
    #[prost(string, tag = "2")]
    pub destination_folder_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MoveAddressMetadata {
    /// ID of the address that is being moved.
    #[prost(string, tag = "1")]
    pub address_id: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod address_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 Address resources.
    #[derive(Debug, Clone)]
    pub struct AddressServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl AddressServiceClient<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> AddressServiceClient<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,
        ) -> AddressServiceClient<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,
        {
            AddressServiceClient::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 Address resource.
        ///
        /// To get the list of all available Address resources, make a [List] request.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetAddressRequest>,
        ) -> std::result::Result<tonic::Response<super::Address>, 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.vpc.v1.AddressService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.vpc.v1.AddressService", "Get"));
            self.inner.unary(req, path, codec).await
        }
        /// Returns the specified Address resource by a given value.
        ///
        /// To get the list of all available Address resources, make a [List] request.
        pub async fn get_by_value(
            &mut self,
            request: impl tonic::IntoRequest<super::GetAddressByValueRequest>,
        ) -> std::result::Result<tonic::Response<super::Address>, 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.vpc.v1.AddressService/GetByValue",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.vpc.v1.AddressService", "GetByValue"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of Address resources in the specified folder.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListAddressesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListAddressesResponse>,
            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.vpc.v1.AddressService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.vpc.v1.AddressService", "List"));
            self.inner.unary(req, path, codec).await
        }
        /// Creates an address in the specified folder and network.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateAddressRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.AddressService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.vpc.v1.AddressService", "Create"));
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified address.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateAddressRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.AddressService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.vpc.v1.AddressService", "Update"));
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified address.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteAddressRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.AddressService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.vpc.v1.AddressService", "Delete"));
            self.inner.unary(req, path, codec).await
        }
        /// List operations for the specified address.
        pub async fn list_operations(
            &mut self,
            request: impl tonic::IntoRequest<super::ListAddressOperationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListAddressOperationsResponse>,
            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.vpc.v1.AddressService/ListOperations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.vpc.v1.AddressService",
                        "ListOperations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Move an address to another folder
        pub async fn r#move(
            &mut self,
            request: impl tonic::IntoRequest<super::MoveAddressRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.AddressService/Move",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.vpc.v1.AddressService", "Move"));
            self.inner.unary(req, path, codec).await
        }
    }
}
/// A Gateway resource. For more information, see \[Gateway\](/docs/vpc/concepts/gateways).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Gateway {
    /// ID of the gateway. Generated at creation time.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the folder that the gateway belongs to.
    #[prost(string, tag = "2")]
    pub folder_id: ::prost::alloc::string::String,
    /// Creation timestamp.
    #[prost(message, optional, tag = "3")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Name of the gateway.
    /// The name is unique within the folder.
    /// Value must match the regular expression ``\|\[a-z]([-a-z0-9]{0,61}[a-z0-9\])?``.
    #[prost(string, tag = "4")]
    pub name: ::prost::alloc::string::String,
    /// Description of the gateway. 0-256 characters long.
    #[prost(string, tag = "5")]
    pub description: ::prost::alloc::string::String,
    /// Gateway labels as `key:value` pairs.
    /// No more than 64 per resource.
    /// The maximum string length in characters for each value is 63.
    /// Each value must match the regular expression `\[-_./\\@0-9a-z\]*`.
    /// The string length in characters for each key must be 1-63.
    /// Each key must match the regular expression `\[a-z][-_./\\@0-9a-z\]*`.
    #[prost(map = "string, string", tag = "6")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Gateway specification
    #[prost(oneof = "gateway::Gateway", tags = "7")]
    pub gateway: ::core::option::Option<gateway::Gateway>,
}
/// Nested message and enum types in `Gateway`.
pub mod gateway {
    /// Gateway specification
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Gateway {
        #[prost(message, tag = "7")]
        SharedEgressGateway(super::SharedEgressGateway),
    }
}
/// Shared Egress Gateway configuration
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SharedEgressGateway {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetGatewayRequest {
    /// ID of the Gateway resource to return.
    ///
    /// To get Gateway resource ID make a \[GatewayService.List\] request.
    #[prost(string, tag = "1")]
    pub gateway_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListGatewaysRequest {
    /// ID of the folder to list gateways in.
    ///
    /// To get the folder ID use a \[yandex.cloud.resourcemanager.v1.FolderService.List\] request.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than `page_size`, the service returns a \[ListGatewaysResponse.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 `page_token` to the
    /// \[ListGatewaysResponse.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 Gateway listed in the response.
    ///
    /// The expression must specify:
    /// 1. The field name. Currently you can use filtering only on \[Gateway.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-gateway`.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListGatewaysResponse {
    /// List of gateways.
    #[prost(message, repeated, tag = "1")]
    pub gateways: ::prost::alloc::vec::Vec<Gateway>,
    /// Token for getting the next page of the list. If the number of results is greater than
    /// the specified \[ListGatewaysRequest.page_size\], use `next_page_token` as the value
    /// for the \[ListGatewaysRequest.page_token\] parameter in the next list request.
    ///
    /// Each subsequent page will have its own `next_page_token` to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListGatewayOperationsRequest {
    /// ID of the gateway to list operations for.
    ///
    /// To get a gateway ID make a \[GatewayService.List\] request.
    #[prost(string, tag = "1")]
    pub gateway_id: ::prost::alloc::string::String,
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\], the service returns a \[ListGatewayOperationsResponse.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 \[page_token\] to the
    /// \[ListGatewayOperationsResponse.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 ListGatewayOperationsResponse {
    /// List of operations for the specified gateway.
    #[prost(message, repeated, tag = "1")]
    pub operations: ::prost::alloc::vec::Vec<super::super::operation::Operation>,
    /// Token for getting the next page of the list. If the number of results is greater than
    /// the specified \[ListGatewayOperationsRequest.page_size\], use `next_page_token` as the value
    /// for the \[ListGatewayOperationsRequest.page_token\] parameter in the next list request.
    ///
    /// Each subsequent page will have its own `next_page_token` to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SharedEgressGatewaySpec {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateGatewayRequest {
    /// ID of the folder to create a gateway 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 gateway.
    /// The name must be unique within the folder.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Description of the gateway.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Gateway labels as `key:value` pairs.
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Gateway configuration specification
    #[prost(oneof = "create_gateway_request::Gateway", tags = "5")]
    pub gateway: ::core::option::Option<create_gateway_request::Gateway>,
}
/// Nested message and enum types in `CreateGatewayRequest`.
pub mod create_gateway_request {
    /// Gateway configuration specification
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Gateway {
        #[prost(message, tag = "5")]
        SharedEgressGatewaySpec(super::SharedEgressGatewaySpec),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateGatewayMetadata {
    /// ID of the gateway that is being created.
    #[prost(string, tag = "1")]
    pub gateway_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateGatewayRequest {
    /// ID of the gateway to update.
    ///
    /// To get the gateway ID make a \[GatewayService.List\] request.
    #[prost(string, tag = "1")]
    pub gateway_id: ::prost::alloc::string::String,
    /// Field mask that specifies which attributes of the Gateway should be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// New name for the gateway.
    /// The name must be unique within the folder.
    #[prost(string, tag = "3")]
    pub name: ::prost::alloc::string::String,
    /// New description of the gateway.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// Gateway 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:
    /// 1. Get the current set of labels with a \[GatewayService.Get\] request.
    /// 2. Add or remove a label in this set.
    /// 3. Send the new set in this field.
    #[prost(map = "string, string", tag = "5")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// New Gateway configuration specification
    #[prost(oneof = "update_gateway_request::Gateway", tags = "6")]
    pub gateway: ::core::option::Option<update_gateway_request::Gateway>,
}
/// Nested message and enum types in `UpdateGatewayRequest`.
pub mod update_gateway_request {
    /// New Gateway configuration specification
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Gateway {
        #[prost(message, tag = "6")]
        SharedEgressGatewaySpec(super::SharedEgressGatewaySpec),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateGatewayMetadata {
    /// ID of the Gateway that is being updated.
    #[prost(string, tag = "1")]
    pub gateway_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteGatewayRequest {
    /// ID of the gateway to delete.
    ///
    /// To get a gateway ID make a \[GatewayService.List\] request.
    #[prost(string, tag = "1")]
    pub gateway_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteGatewayMetadata {
    /// ID of the gateway that is being deleted.
    #[prost(string, tag = "1")]
    pub gateway_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MoveGatewayRequest {
    #[prost(string, tag = "1")]
    pub gateway_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub destination_folder_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MoveGatewayMetadata {
    #[prost(string, tag = "1")]
    pub gateway_id: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod gateway_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    #[derive(Debug, Clone)]
    pub struct GatewayServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl GatewayServiceClient<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> GatewayServiceClient<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,
        ) -> GatewayServiceClient<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,
        {
            GatewayServiceClient::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 Gateway resource.
        ///
        /// To get the list of all available Gateway resources, make a [List] request.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetGatewayRequest>,
        ) -> std::result::Result<tonic::Response<super::Gateway>, 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.vpc.v1.GatewayService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.vpc.v1.GatewayService", "Get"));
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of Gateway resources in the specified folder.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListGatewaysRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListGatewaysResponse>,
            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.vpc.v1.GatewayService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.vpc.v1.GatewayService", "List"));
            self.inner.unary(req, path, codec).await
        }
        /// Creates a gateway in the specified folder.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateGatewayRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.GatewayService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.vpc.v1.GatewayService", "Create"));
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified gateway.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateGatewayRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.GatewayService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.vpc.v1.GatewayService", "Update"));
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified gateway.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteGatewayRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.GatewayService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.vpc.v1.GatewayService", "Delete"));
            self.inner.unary(req, path, codec).await
        }
        /// List operations for the specified gateway.
        pub async fn list_operations(
            &mut self,
            request: impl tonic::IntoRequest<super::ListGatewayOperationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListGatewayOperationsResponse>,
            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.vpc.v1.GatewayService/ListOperations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.vpc.v1.GatewayService",
                        "ListOperations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Move a gateway to another folder
        pub async fn r#move(
            &mut self,
            request: impl tonic::IntoRequest<super::MoveGatewayRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.GatewayService/Move",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.vpc.v1.GatewayService", "Move"));
            self.inner.unary(req, path, codec).await
        }
    }
}
/// A Network resource. For more information, see \[Networks\](/docs/vpc/concepts/network).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Network {
    /// ID of the network.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the folder that the network belongs to.
    #[prost(string, tag = "2")]
    pub folder_id: ::prost::alloc::string::String,
    /// Creation timestamp in \[RFC3339\](<https://www.ietf.org/rfc/rfc3339.txt>) text format.
    #[prost(message, optional, tag = "3")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Name of the network.
    /// The name is unique within the folder.
    /// Value must match the regular expression ``\|\[a-zA-Z]([-_a-zA-Z0-9]{0,61}[a-zA-Z0-9\])?``.
    #[prost(string, tag = "4")]
    pub name: ::prost::alloc::string::String,
    /// Optional description of the network. 0-256 characters long.
    #[prost(string, tag = "5")]
    pub description: ::prost::alloc::string::String,
    /// Resource labels as `key:value` pairs.
    /// No more than 64 per resource.
    /// The maximum string length in characters for each value is 63.
    /// Each value must match the regular expression `\[-_0-9a-z\]*`.
    /// The string length in characters for each key must be 1-63.
    /// Each key must match the regular expression `\[a-z][-_0-9a-z\]*`.
    #[prost(map = "string, string", tag = "6")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// ID of default security group for network.
    #[prost(string, tag = "7")]
    pub default_security_group_id: ::prost::alloc::string::String,
}
/// A Subnet resource. For more information, see \[Subnets\](/docs/vpc/concepts/network#subnet).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Subnet {
    /// ID of the subnet.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the folder that the subnet belongs to.
    #[prost(string, tag = "2")]
    pub folder_id: ::prost::alloc::string::String,
    /// Creation timestamp in \[RFC3339\](<https://www.ietf.org/rfc/rfc3339.txt>) text format.
    #[prost(message, optional, tag = "3")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Name of the subnet.
    /// The name must be unique within the folder.
    /// Value must match the regular expression ``\|\[a-zA-Z]([-_a-zA-Z0-9]{0,61}[a-zA-Z0-9\])?``.
    #[prost(string, tag = "4")]
    pub name: ::prost::alloc::string::String,
    /// Optional description of the subnet. 0-256 characters long.
    #[prost(string, tag = "5")]
    pub description: ::prost::alloc::string::String,
    /// Resource labels, `key:value` pairs.
    /// No more than 64 per resource.
    /// The maximum string length in characters for each value is 63.
    /// Each value must match the regular expression `\[-_0-9a-z\]*`.
    /// The string length in characters for each key must be 1-63.
    /// Each key must match the regular expression `\[a-z][-_0-9a-z\]*`.
    #[prost(map = "string, string", tag = "6")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// ID of the network the subnet belongs to.
    #[prost(string, tag = "7")]
    pub network_id: ::prost::alloc::string::String,
    /// ID of the availability zone where the subnet resides.
    ///
    /// if subnet will be zonal
    #[prost(string, tag = "8")]
    pub zone_id: ::prost::alloc::string::String,
    /// CIDR block.
    /// The range of internal addresses that are defined for this subnet.
    /// This field can be set only at Subnet resource creation time and cannot be changed.
    /// For example, 10.0.0.0/22 or 192.168.0.0/24.
    /// Minimum subnet size is /28, maximum subnet size is /16.
    #[prost(string, repeated, tag = "10")]
    pub v4_cidr_blocks: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// IPv6 not available yet.
    #[prost(string, repeated, tag = "11")]
    pub v6_cidr_blocks: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// ID of route table the subnet is linked to.
    #[prost(string, tag = "12")]
    pub route_table_id: ::prost::alloc::string::String,
    /// DHCP options for the subnet.
    #[prost(message, optional, tag = "13")]
    pub dhcp_options: ::core::option::Option<DhcpOptions>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DhcpOptions {
    /// A list of DHCP servers for this subnet.
    #[prost(string, repeated, tag = "1")]
    pub domain_name_servers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// A domain name to us as a suffix when resolving host names in this subnet.
    #[prost(string, tag = "2")]
    pub domain_name: ::prost::alloc::string::String,
    /// List of NTP servers for this subnet.
    #[prost(string, repeated, tag = "3")]
    pub ntp_servers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum IpVersion {
    Unspecified = 0,
    Ipv4 = 1,
    Ipv6 = 2,
}
impl IpVersion {
    /// 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 {
            IpVersion::Unspecified => "IP_VERSION_UNSPECIFIED",
            IpVersion::Ipv4 => "IPV4",
            IpVersion::Ipv6 => "IPV6",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "IP_VERSION_UNSPECIFIED" => Some(Self::Unspecified),
            "IPV4" => Some(Self::Ipv4),
            "IPV6" => Some(Self::Ipv6),
            _ => None,
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SecurityGroup {
    /// ID of the security group.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the folder that the security group belongs to.
    #[prost(string, tag = "2")]
    pub folder_id: ::prost::alloc::string::String,
    /// Creation timestamp in \[RFC3339\](<https://www.ietf.org/rfc/rfc3339.txt>) text format.
    #[prost(message, optional, tag = "3")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Name of the security group.
    /// The name must be unique within the folder.
    /// Value must match the regular expression ``\|\[a-zA-Z]([-_a-zA-Z0-9]{0,61}[a-zA-Z0-9\])?``.
    #[prost(string, tag = "4")]
    pub name: ::prost::alloc::string::String,
    /// Description of the security group. 0-256 characters long.
    #[prost(string, tag = "5")]
    pub description: ::prost::alloc::string::String,
    /// Resource labels as `key:value` pairs.
    /// No more than 64 per resource.
    /// The maximum string length in characters for each value is 63.
    /// Each value must match the regular expression `\[-_./\\@0-9a-z\]*`.
    /// The string length in characters for each key must be 1-63.
    /// Each key must match the regular expression `\[a-z][-_./\\@0-9a-z\]*`.
    #[prost(map = "string, string", tag = "6")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// ID of the network that the security group belongs to.
    #[prost(string, tag = "7")]
    pub network_id: ::prost::alloc::string::String,
    /// Security group status.
    #[prost(enumeration = "security_group::Status", tag = "8")]
    pub status: i32,
    /// List of the security group rules.
    #[prost(message, repeated, tag = "9")]
    pub rules: ::prost::alloc::vec::Vec<SecurityGroupRule>,
    /// Flag that indicates that the security group is the default for the network.
    #[prost(bool, tag = "10")]
    pub default_for_network: bool,
}
/// Nested message and enum types in `SecurityGroup`.
pub mod security_group {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Status {
        Unspecified = 0,
        /// Security group is being created.
        Creating = 1,
        /// Security is active and it's rules are applied to the network interfaces.
        Active = 2,
        /// Security group is updating. Updating is a long operation because we must update all instances in SG.
        Updating = 3,
        /// Instance 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::Updating => "UPDATING",
                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),
                "UPDATING" => Some(Self::Updating),
                "DELETING" => Some(Self::Deleting),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SecurityGroupRule {
    /// ID of the rule.
    ///
    /// generated by api server after rule creation
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Description of the rule. 0-256 characters long.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// Resource labels as `` key:value `` pairs. Maximum of 64 per resource.
    #[prost(map = "string, string", tag = "3")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// The direction of network traffic allowed by this rule.
    #[prost(enumeration = "security_group_rule::Direction", tag = "4")]
    pub direction: i32,
    /// The range of ports that allow traffic to pass through. Null value means any.
    #[prost(message, optional, tag = "5")]
    pub ports: ::core::option::Option<PortRange>,
    /// Protocol name. Null value means any protocol.
    /// Values from \[IANA\](<https://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml>).
    #[prost(string, tag = "6")]
    pub protocol_name: ::prost::alloc::string::String,
    /// Protocol number from [IANA protocol numbers](<https://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml>).
    #[prost(int64, tag = "7")]
    pub protocol_number: i64,
    #[prost(oneof = "security_group_rule::Target", tags = "8, 9, 10")]
    pub target: ::core::option::Option<security_group_rule::Target>,
}
/// Nested message and enum types in `SecurityGroupRule`.
pub mod security_group_rule {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Direction {
        Unspecified = 0,
        /// Allows ingress traffic.
        Ingress = 1,
        /// Allows egress traffic.
        Egress = 2,
    }
    impl Direction {
        /// 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 {
                Direction::Unspecified => "DIRECTION_UNSPECIFIED",
                Direction::Ingress => "INGRESS",
                Direction::Egress => "EGRESS",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "DIRECTION_UNSPECIFIED" => Some(Self::Unspecified),
                "INGRESS" => Some(Self::Ingress),
                "EGRESS" => Some(Self::Egress),
                _ => None,
            }
        }
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Target {
        /// CIDR blocks to allow to recieve or send traffic.
        #[prost(message, tag = "8")]
        CidrBlocks(super::CidrBlocks),
        /// ID of the security group to add rule to.
        #[prost(string, tag = "9")]
        SecurityGroupId(::prost::alloc::string::String),
        /// Predefined target. See [security groups rules](/docs/vpc/concepts/security-groups#security-groups-rules) for more information.
        #[prost(string, tag = "10")]
        PredefinedTarget(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PortRange {
    /// The lowest port in the range.
    #[prost(int64, tag = "1")]
    pub from_port: i64,
    /// The highest port in the range.
    #[prost(int64, tag = "2")]
    pub to_port: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CidrBlocks {
    /// IPv4 CIDR blocks to allow traffic to.
    #[prost(string, repeated, tag = "1")]
    pub v4_cidr_blocks: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// IPv6 CIDR blocks to allow traffic to.
    #[prost(string, repeated, tag = "2")]
    pub v6_cidr_blocks: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// A RouteTable resource. For more information, see [Static Routes](/docs/vpc/concepts/routing).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RouteTable {
    /// ID of the route table.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the folder that the route table belongs to.
    #[prost(string, tag = "2")]
    pub folder_id: ::prost::alloc::string::String,
    /// Creation timestamp in \[RFC3339\](<https://www.ietf.org/rfc/rfc3339.txt>) text format.
    #[prost(message, optional, tag = "3")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Name of the route table.
    /// The name must be unique within the folder.
    /// Value must match the regular expression `|\[a-zA-Z]([-_a-zA-Z0-9]{0,61}[a-zA-Z0-9\])?`.
    #[prost(string, tag = "4")]
    pub name: ::prost::alloc::string::String,
    /// Optional description of the route table. 0-256 characters long.
    #[prost(string, tag = "5")]
    pub description: ::prost::alloc::string::String,
    /// Resource labels, `key:value` pairs.
    /// No more than 64 per resource.
    /// The string length in characters for each key must be 1-63.
    /// Each value must match the regular expression `\[-_0-9a-z\]*`.
    /// Each key must match the regular expression `\[a-z][-_0-9a-z\]*`.
    #[prost(map = "string, string", tag = "6")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// ID of the network the route table belongs to.
    #[prost(string, tag = "7")]
    pub network_id: ::prost::alloc::string::String,
    /// List of static routes.
    #[prost(message, repeated, tag = "8")]
    pub static_routes: ::prost::alloc::vec::Vec<StaticRoute>,
}
/// A StaticRoute resource. For more information, see [Static Routes](/docs/vpc/concepts/routing).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StaticRoute {
    /// Resource labels as `` key:value `` pairs. Maximum of 64 per resource.
    #[prost(map = "string, string", tag = "3")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    #[prost(oneof = "static_route::Destination", tags = "1")]
    pub destination: ::core::option::Option<static_route::Destination>,
    #[prost(oneof = "static_route::NextHop", tags = "2, 4")]
    pub next_hop: ::core::option::Option<static_route::NextHop>,
}
/// Nested message and enum types in `StaticRoute`.
pub mod static_route {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Destination {
        /// Destination subnet in CIDR notation
        #[prost(string, tag = "1")]
        DestinationPrefix(::prost::alloc::string::String),
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum NextHop {
        /// Next hop IP address
        #[prost(string, tag = "2")]
        NextHopAddress(::prost::alloc::string::String),
        /// Next hop gateway id
        #[prost(string, tag = "4")]
        GatewayId(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetNetworkRequest {
    /// ID of the Network resource to return.
    /// To get the network ID, use a \[NetworkService.List\] request.
    #[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 ListNetworksRequest {
    /// ID of the folder to list networks in.
    /// To get the folder ID, use a \[yandex.cloud.resourcemanager.v1.FolderService.List\] request.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\],
    /// the service returns a \[ListNetworksResponse.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 \[page_token\] to the
    /// \[ListNetworksResponse.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 you can use filtering only on the \[Network.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\]`.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListNetworksResponse {
    /// List of Network resources.
    #[prost(message, repeated, tag = "1")]
    pub networks: ::prost::alloc::vec::Vec<Network>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListNetworksRequest.page_size\], use
    /// the \[next_page_token\] as the value
    /// for the \[ListNetworksRequest.page_token\] query parameter
    /// in the next list request. Subsequent list requests will have their own
    /// \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateNetworkRequest {
    /// ID of the folder for this request to create a network in.
    /// To get the folder ID, use a \[yandex.cloud.resourcemanager.v1.FolderService.List\] request.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// Name of the network.
    /// The name must be unique within the folder.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Description of the network.
    #[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 CreateNetworkMetadata {
    /// ID of the Network that is being created.
    #[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 UpdateNetworkRequest {
    /// ID of the Network resource to update.
    /// To get the network ID use a \[NetworkService.List\] request.
    #[prost(string, tag = "1")]
    pub network_id: ::prost::alloc::string::String,
    /// Field mask that specifies which fields of the Network resource are going to be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Name of the network.
    /// The name must be unique within the folder.
    #[prost(string, tag = "3")]
    pub name: ::prost::alloc::string::String,
    /// Description of the network.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// Resource labels as `` key:value `` pairs.
    #[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 UpdateNetworkMetadata {
    /// ID of the Network resource that is being updated.
    #[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 DeleteNetworkRequest {
    /// ID of the Network resource to update.
    /// To get the network ID, use a \[NetworkService.List\] request.
    #[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 DeleteNetworkMetadata {
    /// ID of the network that is being deleted.
    #[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 ListNetworkSubnetsRequest {
    /// ID of the Network resource to list subnets for.
    #[prost(string, tag = "1")]
    pub network_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 \[page_size\],
    /// the service returns a \[ListNetworkSubnetsResponse.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. Set \[page_token\]
    /// to the \[ListNetworkSubnetsResponse.next_page_token\]
    /// returned by a previous list request to get the next page of results.
    #[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 ListNetworkSubnetsResponse {
    /// List of subnets that belong to the network which is specified in the request.
    #[prost(message, repeated, tag = "1")]
    pub subnets: ::prost::alloc::vec::Vec<Subnet>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListNetworkSubnetsRequest.page_size\], use
    /// the \[next_page_token\] as the value
    /// for the \[ListNetworkSubnetsRequest.page_token\] query parameter
    /// in the next list request. Subsequent list requests will have their own
    /// \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListNetworkSecurityGroupsRequest {
    /// ID of the Network resource to list security groups for.
    #[prost(string, tag = "1")]
    pub network_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 \[page_size\],
    /// the service returns a \[ListNetworkSecurityGroupsResponse.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. Set \[page_token\]
    /// to the \[ListNetworkSecurityGroupsResponse.next_page_token\]
    /// returned by a previous list request to get the next page of results.
    #[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 ListNetworkSecurityGroupsResponse {
    /// List of security groups that belong to the network which is specified in the request.
    #[prost(message, repeated, tag = "1")]
    pub security_groups: ::prost::alloc::vec::Vec<SecurityGroup>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListNetworkSecurityGroupsRequest.page_size\], use
    /// the \[next_page_token\] as the value
    /// for the \[ListNetworkSecurityGroupsRequest.page_token\] query parameter
    /// in the next list request. Subsequent list requests will have their own
    /// \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListNetworkRouteTablesRequest {
    /// ID of the Network resource to list route tables for.
    #[prost(string, tag = "1")]
    pub network_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 \[page_size\],
    /// the service returns a \[ListNetworkRouteTablesResponse.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. Set \[page_token\]
    /// to the \[ListNetworkRouteTablesResponse.next_page_token\]
    /// returned by a previous list request to get the next page of results.
    #[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 ListNetworkRouteTablesResponse {
    /// List of route tables that belong to the network which is specified in the request.
    #[prost(message, repeated, tag = "1")]
    pub route_tables: ::prost::alloc::vec::Vec<RouteTable>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListNetworkRouteTablesRequest.page_size\], use
    /// the \[next_page_token\] as the value
    /// for the \[ListNetworkRouteTablesRequest.page_token\] query parameter
    /// in the next list request. Subsequent list requests will have their own
    /// \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListNetworkOperationsRequest {
    /// ID of the Network resource to list operations for.
    #[prost(string, tag = "1")]
    pub network_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 \[page_size\], the service returns a \[ListNetworkOperationsResponse.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 \[page_token\] to the
    /// \[ListNetworkOperationsResponse.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 ListNetworkOperationsResponse {
    /// List of operations for the specified network.
    #[prost(message, repeated, tag = "1")]
    pub operations: ::prost::alloc::vec::Vec<super::super::operation::Operation>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListNetworkOperationsRequest.page_size\], use the \[next_page_token\] as the value
    /// for the \[ListNetworkOperationsRequest.page_token\] query parameter in the next list request.
    /// Each subsequent list request will have its own \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MoveNetworkRequest {
    /// ID of the Network resource to move.
    #[prost(string, tag = "1")]
    pub network_id: ::prost::alloc::string::String,
    /// ID of the destination folder.
    #[prost(string, tag = "2")]
    pub destination_folder_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MoveNetworkMetadata {
    /// ID of the network that is being moved.
    #[prost(string, tag = "1")]
    pub network_id: ::prost::alloc::string::String,
}
/// 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 Network 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 resource.
        ///
        /// Get the list of available Network resources by making a [List] request.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetNetworkRequest>,
        ) -> std::result::Result<tonic::Response<super::Network>, 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.vpc.v1.NetworkService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.vpc.v1.NetworkService", "Get"));
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of Network resources in the specified folder.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListNetworksRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListNetworksResponse>,
            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.vpc.v1.NetworkService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.vpc.v1.NetworkService", "List"));
            self.inner.unary(req, path, codec).await
        }
        /// Creates a network in the specified folder using the data specified in the request.
        /// Method starts an asynchronous operation that can be cancelled while it is in progress.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateNetworkRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.NetworkService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.vpc.v1.NetworkService", "Create"));
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified network.
        /// Method starts an asynchronous operation that can be cancelled while it is in progress.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateNetworkRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.NetworkService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.vpc.v1.NetworkService", "Update"));
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified network.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteNetworkRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.NetworkService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.vpc.v1.NetworkService", "Delete"));
            self.inner.unary(req, path, codec).await
        }
        /// Lists subnets from the specified network.
        pub async fn list_subnets(
            &mut self,
            request: impl tonic::IntoRequest<super::ListNetworkSubnetsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListNetworkSubnetsResponse>,
            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.vpc.v1.NetworkService/ListSubnets",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.vpc.v1.NetworkService", "ListSubnets"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists security groups from the specified network.
        pub async fn list_security_groups(
            &mut self,
            request: impl tonic::IntoRequest<super::ListNetworkSecurityGroupsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListNetworkSecurityGroupsResponse>,
            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.vpc.v1.NetworkService/ListSecurityGroups",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.vpc.v1.NetworkService",
                        "ListSecurityGroups",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists route tables from the specified network.
        pub async fn list_route_tables(
            &mut self,
            request: impl tonic::IntoRequest<super::ListNetworkRouteTablesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListNetworkRouteTablesResponse>,
            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.vpc.v1.NetworkService/ListRouteTables",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.vpc.v1.NetworkService",
                        "ListRouteTables",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists operations for the specified network.
        pub async fn list_operations(
            &mut self,
            request: impl tonic::IntoRequest<super::ListNetworkOperationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListNetworkOperationsResponse>,
            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.vpc.v1.NetworkService/ListOperations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.vpc.v1.NetworkService",
                        "ListOperations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Move network to another folder.
        pub async fn r#move(
            &mut self,
            request: impl tonic::IntoRequest<super::MoveNetworkRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.NetworkService/Move",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.vpc.v1.NetworkService", "Move"));
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetRouteTableRequest {
    /// ID of the RouteTable resource to return.
    /// To get the route table ID use a \[RouteTableService.List\] request.
    #[prost(string, tag = "1")]
    pub route_table_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListRouteTablesRequest {
    /// ID of the folder that the route table belongs to.
    /// To get the folder ID use a \[yandex.cloud.resourcemanager.v1.FolderService.List\] request.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\],
    /// the service returns a \[ListRouteTablesResponse.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 \[page_token\] to the
    /// \[ListRouteTablesResponse.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 you can use filtering only on \[RouteTable.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\]`.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListRouteTablesResponse {
    /// List of RouteTable resources.
    #[prost(message, repeated, tag = "1")]
    pub route_tables: ::prost::alloc::vec::Vec<RouteTable>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListRouteTablesRequest.page_size\], use
    /// the \[next_page_token\] as the value
    /// for the \[ListRouteTablesRequest.page_token\] query parameter
    /// in the next list request. Subsequent list requests will have their own
    /// \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateRouteTableRequest {
    /// ID of the folder that the route table belongs to.
    /// To get the folder ID use a \[yandex.cloud.resourcemanager.v1.FolderService.List\] request.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// Name of the route table.
    /// The name must be unique within the folder.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Description of the route table.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Resource labels, `` key:value `` pairs.
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// ID of the network the route table belongs to.
    #[prost(string, tag = "5")]
    pub network_id: ::prost::alloc::string::String,
    /// List of static routes.
    #[prost(message, repeated, tag = "6")]
    pub static_routes: ::prost::alloc::vec::Vec<StaticRoute>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateRouteTableMetadata {
    /// ID of the route table that is being created.
    #[prost(string, tag = "1")]
    pub route_table_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateRouteTableRequest {
    /// ID of the RouteTable resource to update.
    #[prost(string, tag = "1")]
    pub route_table_id: ::prost::alloc::string::String,
    /// Field mask that specifies which fields of the RouteTable resource are going to be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Name of the route table.
    /// The name must be unique within the folder.
    #[prost(string, tag = "3")]
    pub name: ::prost::alloc::string::String,
    /// Description of the route table.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// Resource labels as `` key:value `` pairs.
    #[prost(map = "string, string", tag = "5")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// List of static routes.
    #[prost(message, repeated, tag = "6")]
    pub static_routes: ::prost::alloc::vec::Vec<StaticRoute>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateRouteTableMetadata {
    /// ID of the RouteTable resource that is being updated.
    #[prost(string, tag = "1")]
    pub route_table_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteRouteTableRequest {
    /// ID of the route table to delete.
    /// To get the route table ID use a \[RouteTableService.List\] request.
    #[prost(string, tag = "1")]
    pub route_table_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteRouteTableMetadata {
    /// ID of the RouteTable resource that is being deleted.
    #[prost(string, tag = "1")]
    pub route_table_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListRouteTableOperationsRequest {
    /// ID of the RouteTable resource to list operations for.
    #[prost(string, tag = "1")]
    pub route_table_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 \[page_size\], the service returns a \[ListRouteTableOperationsResponse.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 \[page_token\] to the
    /// \[ListRouteTableOperationsResponse.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 ListRouteTableOperationsResponse {
    /// List of operations for the specified RouteTable resource.
    #[prost(message, repeated, tag = "1")]
    pub operations: ::prost::alloc::vec::Vec<super::super::operation::Operation>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListRouteTableOperationsRequest.page_size\], use the \[next_page_token\] as the value
    /// for the \[ListRouteTableOperationsRequest.page_token\] query parameter in the next list request.
    /// Each subsequent list request will have its own \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MoveRouteTableRequest {
    /// ID of the RouteTable resource to move.
    #[prost(string, tag = "1")]
    pub route_table_id: ::prost::alloc::string::String,
    /// ID of the destination folder.
    #[prost(string, tag = "2")]
    pub destination_folder_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MoveRouteTableMetadata {
    /// ID of the RouteTable resource that is being moved.
    #[prost(string, tag = "1")]
    pub route_table_id: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod route_table_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 RouteTable resources.
    #[derive(Debug, Clone)]
    pub struct RouteTableServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl RouteTableServiceClient<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> RouteTableServiceClient<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,
        ) -> RouteTableServiceClient<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,
        {
            RouteTableServiceClient::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 RouteTable resource.
        ///
        /// To get the list of available RouteTable resources, make a [List] request.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetRouteTableRequest>,
        ) -> std::result::Result<tonic::Response<super::RouteTable>, 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.vpc.v1.RouteTableService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.vpc.v1.RouteTableService", "Get"));
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of RouteTable resources in the specified folder.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListRouteTablesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListRouteTablesResponse>,
            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.vpc.v1.RouteTableService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.vpc.v1.RouteTableService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a route table in the specified folder and network.
        /// Method starts an asynchronous operation that can be cancelled while it is in progress.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateRouteTableRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.RouteTableService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.vpc.v1.RouteTableService", "Create"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified route table.
        /// Method starts an asynchronous operation that can be cancelled while it is in progress.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateRouteTableRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.RouteTableService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.vpc.v1.RouteTableService", "Update"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified route table.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteRouteTableRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.RouteTableService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.vpc.v1.RouteTableService", "Delete"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// List operations for the specified route table.
        pub async fn list_operations(
            &mut self,
            request: impl tonic::IntoRequest<super::ListRouteTableOperationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListRouteTableOperationsResponse>,
            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.vpc.v1.RouteTableService/ListOperations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.vpc.v1.RouteTableService",
                        "ListOperations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Move route table to another folder.
        pub async fn r#move(
            &mut self,
            request: impl tonic::IntoRequest<super::MoveRouteTableRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.RouteTableService/Move",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.vpc.v1.RouteTableService", "Move"),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetSecurityGroupRequest {
    /// ID of the Security Group resource to return.
    /// To get the security group ID, use a \[SecurityGroup.List\] request.
    #[prost(string, tag = "1")]
    pub security_group_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSecurityGroupsRequest {
    /// ID of the folder to list security groups in.
    /// To get the folder ID, use a \[yandex.cloud.resourcemanager.v1.FolderService.List\] request.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\],
    /// the service returns a \[ListSecurityGroupsResponse.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 \[page_token\] to the
    /// \[ListSecurityGroupsResponse.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 you can use filtering only on the \[SecurityGroup.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\]`.
    ///
    /// filter by network_id is here
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSecurityGroupsResponse {
    /// List of SecurityGroup resources.
    #[prost(message, repeated, tag = "1")]
    pub security_groups: ::prost::alloc::vec::Vec<SecurityGroup>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListNetworksRequest.page_size\], use
    /// the \[next_page_token\] as the value
    /// for the \[ListNetworksRequest.page_token\] query parameter
    /// in the next list request. Subsequent list requests will have their own
    /// \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateSecurityGroupRequest {
    /// ID of the folder for this request to create a security group in.
    /// To get the folder ID, use a \[yandex.cloud.resourcemanager.v1.FolderService.List\] request.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// Name of the security group.
    /// The name must be unique within the folder.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Description of the security group.
    #[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,
    >,
    /// ID of the Network to create security group for.
    #[prost(string, tag = "5")]
    pub network_id: ::prost::alloc::string::String,
    /// Security rules specifications.
    #[prost(message, repeated, tag = "6")]
    pub rule_specs: ::prost::alloc::vec::Vec<SecurityGroupRuleSpec>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SecurityGroupRuleSpec {
    /// Description of the security rule.
    #[prost(string, tag = "1")]
    pub description: ::prost::alloc::string::String,
    /// Rule labels as `` key:value `` pairs.
    #[prost(map = "string, string", tag = "2")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// The direction of network traffic allowed by this rule.
    #[prost(enumeration = "security_group_rule::Direction", tag = "3")]
    pub direction: i32,
    /// The range of ports that allow traffic to pass through. Null value means any port.
    ///
    /// null value means any port
    #[prost(message, optional, tag = "4")]
    pub ports: ::core::option::Option<PortRange>,
    /// Values from [IANA protocol numbers](<https://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml>).
    /// Null value means any protocol.
    #[prost(oneof = "security_group_rule_spec::Protocol", tags = "5, 6")]
    pub protocol: ::core::option::Option<security_group_rule_spec::Protocol>,
    #[prost(oneof = "security_group_rule_spec::Target", tags = "7, 8, 9")]
    pub target: ::core::option::Option<security_group_rule_spec::Target>,
}
/// Nested message and enum types in `SecurityGroupRuleSpec`.
pub mod security_group_rule_spec {
    /// Values from [IANA protocol numbers](<https://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml>).
    /// Null value means any protocol.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Protocol {
        /// Protocol name.
        #[prost(string, tag = "5")]
        ProtocolName(::prost::alloc::string::String),
        /// Protocol number from [IANA protocol numbers](<https://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml>).
        #[prost(int64, tag = "6")]
        ProtocolNumber(i64),
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Target {
        /// CIDR blocks to allow to recieve or send traffic.
        #[prost(message, tag = "7")]
        CidrBlocks(super::CidrBlocks),
        /// ID of the security group to add rule to.
        #[prost(string, tag = "8")]
        SecurityGroupId(::prost::alloc::string::String),
        /// Predefined target. See [security groups rules](/docs/vpc/concepts/security-groups#security-groups-rules) for more information.
        ///
        /// string subnet_id = .. ;
        #[prost(string, tag = "9")]
        PredefinedTarget(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateSecurityGroupMetadata {
    /// ID of the security group that is being created.
    #[prost(string, tag = "1")]
    pub security_group_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateSecurityGroupRequest {
    /// ID of the security group to update.
    ///
    /// To get the security group ID make a \[SecurityGroupService.List\] request.
    #[prost(string, tag = "1")]
    pub security_group_id: ::prost::alloc::string::String,
    /// Field mask that specifies which attributes of the Address should be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// New name for the security group.
    /// The name must be unique within the folder.
    #[prost(string, tag = "3")]
    pub name: ::prost::alloc::string::String,
    /// New description of the security group.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// Security group 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:
    /// 1. Get the current set of labels with a \[SecurityGroupService.Get\] request.
    /// 2. Add or remove a label in this set.
    /// 3. Send the new set in this field.
    #[prost(map = "string, string", tag = "5")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Updated rule list. All existing rules will be replaced with given list.
    #[prost(message, repeated, tag = "6")]
    pub rule_specs: ::prost::alloc::vec::Vec<SecurityGroupRuleSpec>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateSecurityGroupMetadata {
    /// ID of the SecurityGroup that is being updated.
    #[prost(string, tag = "1")]
    pub security_group_id: ::prost::alloc::string::String,
    /// List of added security rules IDs.
    #[prost(string, repeated, tag = "2")]
    pub added_rule_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateSecurityGroupRulesRequest {
    /// ID of the SecurityGroup that is being updated with new rules.
    #[prost(string, tag = "1")]
    pub security_group_id: ::prost::alloc::string::String,
    /// List of rules IDs to delete.
    #[prost(string, repeated, tag = "2")]
    pub deletion_rule_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Security rules specifications.
    #[prost(message, repeated, tag = "3")]
    pub addition_rule_specs: ::prost::alloc::vec::Vec<SecurityGroupRuleSpec>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateSecurityGroupRuleRequest {
    /// ID of the SecurityGroup to update rule in.
    #[prost(string, tag = "1")]
    pub security_group_id: ::prost::alloc::string::String,
    /// ID of the rule to update.
    #[prost(string, tag = "2")]
    pub rule_id: ::prost::alloc::string::String,
    /// Field mask that specifies which attributes of the Address should be updated.
    #[prost(message, optional, tag = "3")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// New description of the rule.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// Rule 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:
    /// 1. Get the current set of labels with a \[AddressService.Get\] request.
    /// 2. Add or remove a label in this set.
    /// 3. Send the new set in this field.
    #[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 UpdateSecurityGroupRuleMetadata {
    /// ID of the SecurityGroup that is being updated with new rules.
    #[prost(string, tag = "1")]
    pub security_group_id: ::prost::alloc::string::String,
    /// ID of the rule that is being updated.
    #[prost(string, tag = "2")]
    pub rule_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteSecurityGroupRequest {
    /// ID of the security group to delete.
    ///
    /// To get a address ID make a \[SecurityGroup.List\] request.
    #[prost(string, tag = "1")]
    pub security_group_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteSecurityGroupMetadata {
    /// ID of the SecurityGroup that is being deleted.
    #[prost(string, tag = "1")]
    pub security_group_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSecurityGroupOperationsRequest {
    /// ID of the address to list operations for.
    ///
    /// To get a address ID make a \[SecurityGroup.List\] request.
    #[prost(string, tag = "1")]
    pub security_group_id: ::prost::alloc::string::String,
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\], the service returns a \[ListSecurityGroupOperationsResponse.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 \[page_token\] to the
    /// \[ListSecurityGroupOperationsResponse.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 ListSecurityGroupOperationsResponse {
    /// List of operations for the specified security group.
    #[prost(message, repeated, tag = "1")]
    pub operations: ::prost::alloc::vec::Vec<super::super::operation::Operation>,
    /// Token for getting the next page of the list. If the number of results is greater than
    /// the specified \[ListSecurityGroupOperationsRequest.page_size\], use `next_page_token` as the value
    /// for the \[ListSecurityGroupOperationsRequest.page_token\] parameter in the next list request.
    ///
    /// Each subsequent page will have its own `next_page_token` to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MoveSecurityGroupRequest {
    /// ID of the security group to move.
    #[prost(string, tag = "1")]
    pub security_group_id: ::prost::alloc::string::String,
    /// ID of the folder to move security group to.
    #[prost(string, tag = "2")]
    pub destination_folder_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MoveSecurityGroupMetadata {
    /// ID of the security group that is being moved.
    #[prost(string, tag = "1")]
    pub security_group_id: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod security_group_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 SecurityGroup resources.
    #[derive(Debug, Clone)]
    pub struct SecurityGroupServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl SecurityGroupServiceClient<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> SecurityGroupServiceClient<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,
        ) -> SecurityGroupServiceClient<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,
        {
            SecurityGroupServiceClient::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 SecurityGroup resource.
        ///
        /// To get the list of all available SecurityGroup resources, make a [List] request.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetSecurityGroupRequest>,
        ) -> std::result::Result<tonic::Response<super::SecurityGroup>, 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.vpc.v1.SecurityGroupService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.vpc.v1.SecurityGroupService", "Get"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of SecurityGroup resources in the specified folder.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListSecurityGroupsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListSecurityGroupsResponse>,
            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.vpc.v1.SecurityGroupService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.vpc.v1.SecurityGroupService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a security group in the specified folder and network.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateSecurityGroupRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.SecurityGroupService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.vpc.v1.SecurityGroupService", "Create"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified security group.
        /// Method starts an asynchronous operation that can be cancelled while it is in progress.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateSecurityGroupRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.SecurityGroupService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.vpc.v1.SecurityGroupService", "Update"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the rules of the specified security group.
        pub async fn update_rules(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateSecurityGroupRulesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.SecurityGroupService/UpdateRules",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.vpc.v1.SecurityGroupService",
                        "UpdateRules",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified rule.
        pub async fn update_rule(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateSecurityGroupRuleRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.SecurityGroupService/UpdateRule",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.vpc.v1.SecurityGroupService",
                        "UpdateRule",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified security group.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteSecurityGroupRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.SecurityGroupService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.vpc.v1.SecurityGroupService", "Delete"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Moves security groups to another folder.
        pub async fn r#move(
            &mut self,
            request: impl tonic::IntoRequest<super::MoveSecurityGroupRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.SecurityGroupService/Move",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.vpc.v1.SecurityGroupService", "Move"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists operations for the specified security groups.
        pub async fn list_operations(
            &mut self,
            request: impl tonic::IntoRequest<super::ListSecurityGroupOperationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListSecurityGroupOperationsResponse>,
            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.vpc.v1.SecurityGroupService/ListOperations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.vpc.v1.SecurityGroupService",
                        "ListOperations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetSubnetRequest {
    /// ID of the Subnet resource to return.
    /// To get the subnet ID use a \[SubnetService.List\] request.
    #[prost(string, tag = "1")]
    pub subnet_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSubnetsRequest {
    /// ID of the folder to list subnets in.
    /// To get the folder ID use a \[yandex.cloud.resourcemanager.v1.FolderService.List\] request.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\],
    /// the service returns a \[ListSubnetsResponse.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 \[page_token\] to the
    /// \[ListSubnetsResponse.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 you can use filtering only on \[Subnet.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\]`.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSubnetsResponse {
    /// List of Subnet resources.
    #[prost(message, repeated, tag = "1")]
    pub subnets: ::prost::alloc::vec::Vec<Subnet>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListSubnetsRequest.page_size\], use
    /// the \[next_page_token\] as the value
    /// for the \[ListSubnetsRequest.page_token\] query parameter
    /// in the next list request. Subsequent list requests will have their own
    /// \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateSubnetRequest {
    /// ID of the folder to create a subnet in.
    /// To get folder ID use a \[yandex.cloud.resourcemanager.v1.FolderService.List\] request.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// Name of the subnet.
    /// The name must be unique within the folder.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Description of the subnet.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Resource labels, `` key:value `` pairs.
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// ID of the network to create subnet in.
    #[prost(string, tag = "5")]
    pub network_id: ::prost::alloc::string::String,
    /// ID of the availability zone where the subnet resides.
    /// To get a list of available zones, use the \[yandex.cloud.compute.v1.ZoneService.List\] request.
    #[prost(string, tag = "6")]
    pub zone_id: ::prost::alloc::string::String,
    /// CIDR block.
    /// The range of internal addresses that are defined for this subnet.
    /// For example, 10.0.0.0/22 or 192.168.0.0/24.
    /// Minimum subnet size is /28, maximum subnet size is /16.
    #[prost(string, repeated, tag = "7")]
    pub v4_cidr_blocks: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// ID of route table the subnet is linked to.
    #[prost(string, tag = "9")]
    pub route_table_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "10")]
    pub dhcp_options: ::core::option::Option<DhcpOptions>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateSubnetMetadata {
    /// ID of the subnet that is being created.
    #[prost(string, tag = "1")]
    pub subnet_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateSubnetRequest {
    /// ID of the Subnet resource to update.
    #[prost(string, tag = "1")]
    pub subnet_id: ::prost::alloc::string::String,
    /// Field mask that specifies which fields of the Subnet resource are going to be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Name of the subnet.
    /// The name must be unique within the folder.
    #[prost(string, tag = "3")]
    pub name: ::prost::alloc::string::String,
    /// Description of the subnet.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// Resource labels as `` key:value `` pairs.
    #[prost(map = "string, string", tag = "5")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// ID of route table the subnet is linked to.
    #[prost(string, tag = "6")]
    pub route_table_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "7")]
    pub dhcp_options: ::core::option::Option<DhcpOptions>,
    /// New CIDR blocks which will overwrite the existing ones.
    #[prost(string, repeated, tag = "8")]
    pub v4_cidr_blocks: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateSubnetMetadata {
    /// ID of the Subnet resource that is being updated.
    #[prost(string, tag = "1")]
    pub subnet_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AddSubnetCidrBlocksRequest {
    /// ID of the Subnet resource that is being updated.
    #[prost(string, tag = "1")]
    pub subnet_id: ::prost::alloc::string::String,
    /// CIDR block.
    /// The range of internal addresses that should be added to this subnet.
    /// For example, 10.0.0.0/22 or 192.168.0.0/24.
    /// Minimum subnet size is /28, maximum subnet size is /16.
    #[prost(string, repeated, tag = "2")]
    pub v4_cidr_blocks: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AddSubnetCidrBlocksMetadata {
    /// ID of the Subnet resource that is being updated.
    #[prost(string, tag = "1")]
    pub subnet_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RemoveSubnetCidrBlocksRequest {
    /// ID of the Subnet resource that is being updated.
    #[prost(string, tag = "1")]
    pub subnet_id: ::prost::alloc::string::String,
    /// CIDR block.
    /// The range of internal addresses that are removed from this subnet.
    #[prost(string, repeated, tag = "2")]
    pub v4_cidr_blocks: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RemoveSubnetCidrBlocksMetadata {
    /// ID of the Subnet resource that is being updated.
    #[prost(string, tag = "1")]
    pub subnet_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteSubnetRequest {
    /// ID of the subnet to delete.
    /// To get the subnet ID use a \[SubnetService.List\] request.
    #[prost(string, tag = "1")]
    pub subnet_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteSubnetMetadata {
    /// ID of the Subnet resource that is being deleted.
    #[prost(string, tag = "1")]
    pub subnet_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSubnetOperationsRequest {
    /// ID of the Subnet resource to list operations for.
    #[prost(string, tag = "1")]
    pub subnet_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 \[page_size\], the service returns a \[ListSubnetOperationsResponse.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 \[page_token\] to the
    /// \[ListSubnetOperationsResponse.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 ListSubnetOperationsResponse {
    /// List of operations for the specified Subnet resource.
    #[prost(message, repeated, tag = "1")]
    pub operations: ::prost::alloc::vec::Vec<super::super::operation::Operation>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListSubnetOperationsRequest.page_size\], use the \[next_page_token\] as the value
    /// for the \[ListSubnetOperationsRequest.page_token\] query parameter in the next list request.
    /// Each subsequent list request will have its own \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MoveSubnetRequest {
    /// ID of the Subnet resource to move.
    #[prost(string, tag = "1")]
    pub subnet_id: ::prost::alloc::string::String,
    /// ID of the destination folder.
    #[prost(string, tag = "2")]
    pub destination_folder_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MoveSubnetMetadata {
    /// ID of the Subnet resource that is being moved.
    #[prost(string, tag = "1")]
    pub subnet_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListUsedAddressesRequest {
    #[prost(string, tag = "1")]
    pub subnet_id: ::prost::alloc::string::String,
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListUsedAddressesResponse {
    #[prost(message, repeated, tag = "1")]
    pub addresses: ::prost::alloc::vec::Vec<UsedAddress>,
    #[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 UsedAddress {
    #[prost(string, tag = "1")]
    pub address: ::prost::alloc::string::String,
    #[prost(enumeration = "IpVersion", tag = "2")]
    pub ip_version: i32,
    #[prost(message, repeated, tag = "3")]
    pub references: ::prost::alloc::vec::Vec<super::super::reference::Reference>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RelocateSubnetRequest {
    #[prost(string, tag = "1")]
    pub subnet_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub destination_zone_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RelocateSubnetMetadata {
    #[prost(string, tag = "1")]
    pub subnet_id: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod subnet_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 Subnet resources.
    #[derive(Debug, Clone)]
    pub struct SubnetServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl SubnetServiceClient<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> SubnetServiceClient<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,
        ) -> SubnetServiceClient<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,
        {
            SubnetServiceClient::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 Subnet resource.
        ///
        /// To get the list of available Subnet resources, make a [List] request.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetSubnetRequest>,
        ) -> std::result::Result<tonic::Response<super::Subnet>, 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.vpc.v1.SubnetService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.vpc.v1.SubnetService", "Get"));
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of Subnet resources in the specified folder.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListSubnetsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListSubnetsResponse>,
            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.vpc.v1.SubnetService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.vpc.v1.SubnetService", "List"));
            self.inner.unary(req, path, codec).await
        }
        /// Creates a subnet in the specified folder and network.
        /// Method starts an asynchronous operation that can be cancelled while it is in progress.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateSubnetRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.SubnetService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.vpc.v1.SubnetService", "Create"));
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified subnet.
        /// Method starts an asynchronous operation that can be cancelled while it is in progress.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateSubnetRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.SubnetService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.vpc.v1.SubnetService", "Update"));
            self.inner.unary(req, path, codec).await
        }
        /// Adds CIDR blocks to the specified subnet.
        /// Method starts an asynchronous operation that can be cancelled while it is in progress.
        pub async fn add_cidr_blocks(
            &mut self,
            request: impl tonic::IntoRequest<super::AddSubnetCidrBlocksRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.SubnetService/AddCidrBlocks",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.vpc.v1.SubnetService", "AddCidrBlocks"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Removes CIDR blocks from the specified subnet.
        /// Method starts an asynchronous operation that can be cancelled while it is in progress.
        pub async fn remove_cidr_blocks(
            &mut self,
            request: impl tonic::IntoRequest<super::RemoveSubnetCidrBlocksRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.SubnetService/RemoveCidrBlocks",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.vpc.v1.SubnetService",
                        "RemoveCidrBlocks",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified subnet.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteSubnetRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.SubnetService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.vpc.v1.SubnetService", "Delete"));
            self.inner.unary(req, path, codec).await
        }
        /// List operations for the specified subnet.
        pub async fn list_operations(
            &mut self,
            request: impl tonic::IntoRequest<super::ListSubnetOperationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListSubnetOperationsResponse>,
            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.vpc.v1.SubnetService/ListOperations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.vpc.v1.SubnetService",
                        "ListOperations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Move subnet to another folder.
        pub async fn r#move(
            &mut self,
            request: impl tonic::IntoRequest<super::MoveSubnetRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.SubnetService/Move",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.vpc.v1.SubnetService", "Move"));
            self.inner.unary(req, path, codec).await
        }
        pub async fn relocate(
            &mut self,
            request: impl tonic::IntoRequest<super::RelocateSubnetRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.vpc.v1.SubnetService/Relocate",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.vpc.v1.SubnetService", "Relocate"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// List used addresses in specified subnet.
        pub async fn list_used_addresses(
            &mut self,
            request: impl tonic::IntoRequest<super::ListUsedAddressesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListUsedAddressesResponse>,
            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.vpc.v1.SubnetService/ListUsedAddresses",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.vpc.v1.SubnetService",
                        "ListUsedAddresses",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}