google_cloud_networkconnectivity_v1/

model.rs

// Copyright 2025 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Code generated by sidekick. DO NOT EDIT.

#![allow(rustdoc::redundant_explicit_links)]
#![allow(rustdoc::broken_intra_doc_links)]
#![no_implicit_prelude]
extern crate async_trait;
extern crate bytes;
extern crate gax;
extern crate iam_v1;
extern crate lazy_static;
extern crate location;
extern crate longrunning;
extern crate lro;
extern crate reqwest;
extern crate serde;
extern crate serde_json;
extern crate serde_with;
extern crate std;
extern crate tracing;
extern crate wkt;

/// Represents the metadata of the long-running operation.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct OperationMetadata {
    /// Output only. The time the operation was created.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The time the operation finished running.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub end_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Server-defined resource path for the target of the operation.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub target: std::string::String,

    /// Output only. Name of the verb executed by the operation.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub verb: std::string::String,

    /// Output only. Human-readable status of the operation, if any.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub status_message: std::string::String,

    /// Output only. Identifies whether the user has requested cancellation
    /// of the operation. Operations that have been cancelled successfully
    /// have [Operation.error][] value with a
    /// [google.rpc.Status.code][google.rpc.Status.code] of 1, corresponding to
    /// `Code.CANCELLED`.
    ///
    /// [google.rpc.Status.code]: rpc::model::Status::code
    pub requested_cancellation: bool,

    /// Output only. API version used to start the operation.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub api_version: std::string::String,
}

impl OperationMetadata {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [create_time][crate::model::OperationMetadata::create_time].
    pub fn set_create_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.create_time = v.into();
        self
    }

    /// Sets the value of [end_time][crate::model::OperationMetadata::end_time].
    pub fn set_end_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.end_time = v.into();
        self
    }

    /// Sets the value of [target][crate::model::OperationMetadata::target].
    pub fn set_target<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.target = v.into();
        self
    }

    /// Sets the value of [verb][crate::model::OperationMetadata::verb].
    pub fn set_verb<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.verb = v.into();
        self
    }

    /// Sets the value of [status_message][crate::model::OperationMetadata::status_message].
    pub fn set_status_message<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.status_message = v.into();
        self
    }

    /// Sets the value of [requested_cancellation][crate::model::OperationMetadata::requested_cancellation].
    pub fn set_requested_cancellation<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.requested_cancellation = v.into();
        self
    }

    /// Sets the value of [api_version][crate::model::OperationMetadata::api_version].
    pub fn set_api_version<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.api_version = v.into();
        self
    }
}

impl wkt::message::Message for OperationMetadata {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.OperationMetadata"
    }
}

/// A Network Connectivity Center hub is a global management resource to which
/// you attach spokes. A single hub can contain spokes from multiple regions.
/// However, if any of a hub's spokes use the site-to-site data transfer feature,
/// the resources associated with those spokes must all be in the same VPC
/// network. Spokes that do not use site-to-site data transfer can be associated
/// with any VPC network in your project.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct Hub {
    /// Immutable. The name of the hub. Hub names must be unique. They use the
    /// following form:
    /// `projects/{project_number}/locations/global/hubs/{hub_id}`
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    /// Output only. The time the hub was created.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The time the hub was last updated.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// Optional labels in key-value pair format. For more information about
    /// labels, see [Requirements for
    /// labels](https://cloud.google.com/resource-manager/docs/creating-managing-labels#requirements).
    #[serde(skip_serializing_if = "std::collections::HashMap::is_empty")]
    pub labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// An optional description of the hub.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub description: std::string::String,

    /// Output only. The Google-generated UUID for the hub. This value is unique
    /// across all hub resources. If a hub is deleted and another with the same
    /// name is created, the new hub is assigned a different unique_id.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub unique_id: std::string::String,

    /// Output only. The current lifecycle state of this hub.
    pub state: crate::model::State,

    /// The VPC networks associated with this hub's spokes.
    ///
    /// This field is read-only. Network Connectivity Center automatically
    /// populates it based on the set of spokes attached to the hub.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub routing_vpcs: std::vec::Vec<crate::model::RoutingVPC>,

    /// Output only. The route tables that belong to this hub. They use the
    /// following form:
    /// `projects/{project_number}/locations/global/hubs/{hub_id}/routeTables/{route_table_id}`
    ///
    /// This field is read-only. Network Connectivity Center automatically
    /// populates it based on the route tables nested under the hub.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub route_tables: std::vec::Vec<std::string::String>,

    /// Output only. A summary of the spokes associated with a hub. The
    /// summary includes a count of spokes according to type
    /// and according to state. If any spokes are inactive,
    /// the summary also lists the reasons they are inactive,
    /// including a count for each reason.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub spoke_summary: std::option::Option<crate::model::SpokeSummary>,

    /// Optional. The policy mode of this hub. This field can be either
    /// PRESET or CUSTOM. If unspecified, the
    /// policy_mode defaults to PRESET.
    pub policy_mode: crate::model::PolicyMode,

    /// Optional. The topology implemented in this hub. Currently, this field is
    /// only used when policy_mode = PRESET. The available preset topologies are
    /// MESH and STAR. If preset_topology is unspecified and policy_mode = PRESET,
    /// the preset_topology defaults to MESH. When policy_mode = CUSTOM,
    /// the preset_topology is set to PRESET_TOPOLOGY_UNSPECIFIED.
    pub preset_topology: crate::model::PresetTopology,

    /// Optional. Whether Private Service Connect transitivity is enabled for the
    /// hub. If true, Private Service Connect endpoints in VPC spokes attached to
    /// the hub are made accessible to other VPC spokes attached to the hub.
    /// The default value is false.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub export_psc: std::option::Option<bool>,
}

impl Hub {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::Hub::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [create_time][crate::model::Hub::create_time].
    pub fn set_create_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.create_time = v.into();
        self
    }

    /// Sets the value of [update_time][crate::model::Hub::update_time].
    pub fn set_update_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.update_time = v.into();
        self
    }

    /// Sets the value of [description][crate::model::Hub::description].
    pub fn set_description<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.description = v.into();
        self
    }

    /// Sets the value of [unique_id][crate::model::Hub::unique_id].
    pub fn set_unique_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.unique_id = v.into();
        self
    }

    /// Sets the value of [state][crate::model::Hub::state].
    pub fn set_state<T: std::convert::Into<crate::model::State>>(mut self, v: T) -> Self {
        self.state = v.into();
        self
    }

    /// Sets the value of [spoke_summary][crate::model::Hub::spoke_summary].
    pub fn set_spoke_summary<
        T: std::convert::Into<std::option::Option<crate::model::SpokeSummary>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.spoke_summary = v.into();
        self
    }

    /// Sets the value of [policy_mode][crate::model::Hub::policy_mode].
    pub fn set_policy_mode<T: std::convert::Into<crate::model::PolicyMode>>(
        mut self,
        v: T,
    ) -> Self {
        self.policy_mode = v.into();
        self
    }

    /// Sets the value of [preset_topology][crate::model::Hub::preset_topology].
    pub fn set_preset_topology<T: std::convert::Into<crate::model::PresetTopology>>(
        mut self,
        v: T,
    ) -> Self {
        self.preset_topology = v.into();
        self
    }

    /// Sets the value of [export_psc][crate::model::Hub::export_psc].
    pub fn set_export_psc<T: std::convert::Into<std::option::Option<bool>>>(
        mut self,
        v: T,
    ) -> Self {
        self.export_psc = v.into();
        self
    }

    /// Sets the value of [routing_vpcs][crate::model::Hub::routing_vpcs].
    pub fn set_routing_vpcs<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::RoutingVPC>,
    {
        use std::iter::Iterator;
        self.routing_vpcs = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [route_tables][crate::model::Hub::route_tables].
    pub fn set_route_tables<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.route_tables = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [labels][crate::model::Hub::labels].
    pub fn set_labels<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.labels = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }
}

impl wkt::message::Message for Hub {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.Hub"
    }
}

/// RoutingVPC contains information about the VPC networks associated
/// with the spokes of a Network Connectivity Center hub.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct RoutingVPC {
    /// The URI of the VPC network.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub uri: std::string::String,

    /// Output only. If true, indicates that this VPC network is currently
    /// associated with spokes that use the data transfer feature (spokes where the
    /// site_to_site_data_transfer field is set to true). If you create new spokes
    /// that use data transfer, they must be associated with this VPC network. At
    /// most, one VPC network will have this field set to true.
    pub required_for_new_site_to_site_data_transfer_spokes: bool,
}

impl RoutingVPC {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [uri][crate::model::RoutingVPC::uri].
    pub fn set_uri<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.uri = v.into();
        self
    }

    /// Sets the value of [required_for_new_site_to_site_data_transfer_spokes][crate::model::RoutingVPC::required_for_new_site_to_site_data_transfer_spokes].
    pub fn set_required_for_new_site_to_site_data_transfer_spokes<T: std::convert::Into<bool>>(
        mut self,
        v: T,
    ) -> Self {
        self.required_for_new_site_to_site_data_transfer_spokes = v.into();
        self
    }
}

impl wkt::message::Message for RoutingVPC {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.RoutingVPC"
    }
}

/// A Network Connectivity Center spoke represents one or more network
/// connectivity resources.
///
/// When you create a spoke, you associate it with a hub. You must also
/// identify a value for exactly one of the following fields:
///
/// * linked_vpn_tunnels
/// * linked_interconnect_attachments
/// * linked_router_appliance_instances
/// * linked_vpc_network
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct Spoke {
    /// Immutable. The name of the spoke. Spoke names must be unique. They use the
    /// following form:
    /// `projects/{project_number}/locations/{region}/spokes/{spoke_id}`
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    /// Output only. The time the spoke was created.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The time the spoke was last updated.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// Optional labels in key-value pair format. For more information about
    /// labels, see [Requirements for
    /// labels](https://cloud.google.com/resource-manager/docs/creating-managing-labels#requirements).
    #[serde(skip_serializing_if = "std::collections::HashMap::is_empty")]
    pub labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// An optional description of the spoke.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub description: std::string::String,

    /// Immutable. The name of the hub that this spoke is attached to.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub hub: std::string::String,

    /// Optional. The name of the group that this spoke is associated with.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub group: std::string::String,

    /// VPN tunnels that are associated with the spoke.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub linked_vpn_tunnels: std::option::Option<crate::model::LinkedVpnTunnels>,

    /// VLAN attachments that are associated with the spoke.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub linked_interconnect_attachments:
        std::option::Option<crate::model::LinkedInterconnectAttachments>,

    /// Router appliance instances that are associated with the spoke.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub linked_router_appliance_instances:
        std::option::Option<crate::model::LinkedRouterApplianceInstances>,

    /// Optional. VPC network that is associated with the spoke.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub linked_vpc_network: std::option::Option<crate::model::LinkedVpcNetwork>,

    /// Optional. The linked producer VPC that is associated with the spoke.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub linked_producer_vpc_network: std::option::Option<crate::model::LinkedProducerVpcNetwork>,

    /// Output only. The Google-generated UUID for the spoke. This value is unique
    /// across all spoke resources. If a spoke is deleted and another with the same
    /// name is created, the new spoke is assigned a different `unique_id`.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub unique_id: std::string::String,

    /// Output only. The current lifecycle state of this spoke.
    pub state: crate::model::State,

    /// Output only. The reasons for current state of the spoke. Only present when
    /// the spoke is in the `INACTIVE` state.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub reasons: std::vec::Vec<crate::model::spoke::StateReason>,

    /// Output only. The type of resource associated with the spoke.
    pub spoke_type: crate::model::SpokeType,
}

impl Spoke {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::Spoke::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [create_time][crate::model::Spoke::create_time].
    pub fn set_create_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.create_time = v.into();
        self
    }

    /// Sets the value of [update_time][crate::model::Spoke::update_time].
    pub fn set_update_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.update_time = v.into();
        self
    }

    /// Sets the value of [description][crate::model::Spoke::description].
    pub fn set_description<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.description = v.into();
        self
    }

    /// Sets the value of [hub][crate::model::Spoke::hub].
    pub fn set_hub<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.hub = v.into();
        self
    }

    /// Sets the value of [group][crate::model::Spoke::group].
    pub fn set_group<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.group = v.into();
        self
    }

    /// Sets the value of [linked_vpn_tunnels][crate::model::Spoke::linked_vpn_tunnels].
    pub fn set_linked_vpn_tunnels<
        T: std::convert::Into<std::option::Option<crate::model::LinkedVpnTunnels>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.linked_vpn_tunnels = v.into();
        self
    }

    /// Sets the value of [linked_interconnect_attachments][crate::model::Spoke::linked_interconnect_attachments].
    pub fn set_linked_interconnect_attachments<
        T: std::convert::Into<std::option::Option<crate::model::LinkedInterconnectAttachments>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.linked_interconnect_attachments = v.into();
        self
    }

    /// Sets the value of [linked_router_appliance_instances][crate::model::Spoke::linked_router_appliance_instances].
    pub fn set_linked_router_appliance_instances<
        T: std::convert::Into<std::option::Option<crate::model::LinkedRouterApplianceInstances>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.linked_router_appliance_instances = v.into();
        self
    }

    /// Sets the value of [linked_vpc_network][crate::model::Spoke::linked_vpc_network].
    pub fn set_linked_vpc_network<
        T: std::convert::Into<std::option::Option<crate::model::LinkedVpcNetwork>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.linked_vpc_network = v.into();
        self
    }

    /// Sets the value of [linked_producer_vpc_network][crate::model::Spoke::linked_producer_vpc_network].
    pub fn set_linked_producer_vpc_network<
        T: std::convert::Into<std::option::Option<crate::model::LinkedProducerVpcNetwork>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.linked_producer_vpc_network = v.into();
        self
    }

    /// Sets the value of [unique_id][crate::model::Spoke::unique_id].
    pub fn set_unique_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.unique_id = v.into();
        self
    }

    /// Sets the value of [state][crate::model::Spoke::state].
    pub fn set_state<T: std::convert::Into<crate::model::State>>(mut self, v: T) -> Self {
        self.state = v.into();
        self
    }

    /// Sets the value of [spoke_type][crate::model::Spoke::spoke_type].
    pub fn set_spoke_type<T: std::convert::Into<crate::model::SpokeType>>(mut self, v: T) -> Self {
        self.spoke_type = v.into();
        self
    }

    /// Sets the value of [reasons][crate::model::Spoke::reasons].
    pub fn set_reasons<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::spoke::StateReason>,
    {
        use std::iter::Iterator;
        self.reasons = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [labels][crate::model::Spoke::labels].
    pub fn set_labels<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.labels = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }
}

impl wkt::message::Message for Spoke {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.Spoke"
    }
}

/// Defines additional types related to Spoke
pub mod spoke {
    #[allow(unused_imports)]
    use super::*;

    /// The reason a spoke is inactive.
    #[serde_with::serde_as]
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    #[serde(default, rename_all = "camelCase")]
    #[non_exhaustive]
    pub struct StateReason {
        /// The code associated with this reason.
        pub code: crate::model::spoke::state_reason::Code,

        /// Human-readable details about this reason.
        #[serde(skip_serializing_if = "std::string::String::is_empty")]
        pub message: std::string::String,

        /// Additional information provided by the user in the RejectSpoke call.
        #[serde(skip_serializing_if = "std::string::String::is_empty")]
        pub user_details: std::string::String,
    }

    impl StateReason {
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [code][crate::model::spoke::StateReason::code].
        pub fn set_code<T: std::convert::Into<crate::model::spoke::state_reason::Code>>(
            mut self,
            v: T,
        ) -> Self {
            self.code = v.into();
            self
        }

        /// Sets the value of [message][crate::model::spoke::StateReason::message].
        pub fn set_message<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.message = v.into();
            self
        }

        /// Sets the value of [user_details][crate::model::spoke::StateReason::user_details].
        pub fn set_user_details<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.user_details = v.into();
            self
        }
    }

    impl wkt::message::Message for StateReason {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.networkconnectivity.v1.Spoke.StateReason"
        }
    }

    /// Defines additional types related to StateReason
    pub mod state_reason {
        #[allow(unused_imports)]
        use super::*;

        /// The Code enum represents the various reasons a state can be `INACTIVE`.
        #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
        pub struct Code(std::borrow::Cow<'static, str>);

        impl Code {
            /// Creates a new Code instance.
            pub const fn new(v: &'static str) -> Self {
                Self(std::borrow::Cow::Borrowed(v))
            }

            /// Gets the enum value.
            pub fn value(&self) -> &str {
                &self.0
            }
        }

        /// Useful constants to work with [Code](Code)
        pub mod code {
            use super::Code;

            /// No information available.
            pub const CODE_UNSPECIFIED: Code = Code::new("CODE_UNSPECIFIED");

            /// The proposed spoke is pending review.
            pub const PENDING_REVIEW: Code = Code::new("PENDING_REVIEW");

            /// The proposed spoke has been rejected by the hub administrator.
            pub const REJECTED: Code = Code::new("REJECTED");

            /// The spoke has been deactivated internally.
            pub const PAUSED: Code = Code::new("PAUSED");

            /// Network Connectivity Center encountered errors while accepting
            /// the spoke.
            pub const FAILED: Code = Code::new("FAILED");
        }

        impl std::convert::From<std::string::String> for Code {
            fn from(value: std::string::String) -> Self {
                Self(std::borrow::Cow::Owned(value))
            }
        }
    }
}

#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct RouteTable {
    /// Immutable. The name of the route table. Route table names must be unique.
    /// They use the following form:
    /// `projects/{project_number}/locations/global/hubs/{hub}/routeTables/{route_table_id}`
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    /// Output only. The time the route table was created.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The time the route table was last updated.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// Optional labels in key-value pair format. For more information about
    /// labels, see [Requirements for
    /// labels](https://cloud.google.com/resource-manager/docs/creating-managing-labels#requirements).
    #[serde(skip_serializing_if = "std::collections::HashMap::is_empty")]
    pub labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// An optional description of the route table.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub description: std::string::String,

    /// Output only. The Google-generated UUID for the route table. This value is
    /// unique across all route table resources. If a route table is deleted and
    /// another with the same name is created, the new route table is assigned
    /// a different `uid`.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub uid: std::string::String,

    /// Output only. The current lifecycle state of this route table.
    pub state: crate::model::State,
}

impl RouteTable {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::RouteTable::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [create_time][crate::model::RouteTable::create_time].
    pub fn set_create_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.create_time = v.into();
        self
    }

    /// Sets the value of [update_time][crate::model::RouteTable::update_time].
    pub fn set_update_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.update_time = v.into();
        self
    }

    /// Sets the value of [description][crate::model::RouteTable::description].
    pub fn set_description<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.description = v.into();
        self
    }

    /// Sets the value of [uid][crate::model::RouteTable::uid].
    pub fn set_uid<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.uid = v.into();
        self
    }

    /// Sets the value of [state][crate::model::RouteTable::state].
    pub fn set_state<T: std::convert::Into<crate::model::State>>(mut self, v: T) -> Self {
        self.state = v.into();
        self
    }

    /// Sets the value of [labels][crate::model::RouteTable::labels].
    pub fn set_labels<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.labels = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }
}

impl wkt::message::Message for RouteTable {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.RouteTable"
    }
}

/// A route defines a path from VM instances within a spoke to a specific
/// destination resource. Only VPC spokes have routes.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct Route {
    /// Immutable. The name of the route. Route names must be unique. Route names
    /// use the following form:
    /// `projects/{project_number}/locations/global/hubs/{hub}/routeTables/{route_table_id}/routes/{route_id}`
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    /// Output only. The time the route was created.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The time the route was last updated.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// The destination IP address range.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub ip_cidr_range: std::string::String,

    /// Output only. The route's type. Its type is determined by the properties of
    /// its IP address range.
    #[serde(rename = "type")]
    pub r#type: crate::model::RouteType,

    /// Immutable. The destination VPC network for packets on this route.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub next_hop_vpc_network: std::option::Option<crate::model::NextHopVpcNetwork>,

    /// Optional labels in key-value pair format. For more information about
    /// labels, see [Requirements for
    /// labels](https://cloud.google.com/resource-manager/docs/creating-managing-labels#requirements).
    #[serde(skip_serializing_if = "std::collections::HashMap::is_empty")]
    pub labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// An optional description of the route.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub description: std::string::String,

    /// Output only. The Google-generated UUID for the route. This value is unique
    /// across all Network Connectivity Center route resources. If a
    /// route is deleted and another with the same name is created,
    /// the new route is assigned a different `uid`.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub uid: std::string::String,

    /// Output only. The current lifecycle state of the route.
    pub state: crate::model::State,

    /// Immutable. The spoke that this route leads to.
    /// Example: projects/12345/locations/global/spokes/SPOKE
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub spoke: std::string::String,

    /// Output only. The origin location of the route.
    /// Uses the following form: "projects/{project}/locations/{location}"
    /// Example: projects/1234/locations/us-central1
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub location: std::string::String,

    /// Output only. The priority of this route. Priority is used to break ties in
    /// cases where a destination matches more than one route. In these cases the
    /// route with the lowest-numbered priority value wins.
    #[serde_as(as = "serde_with::DisplayFromStr")]
    pub priority: i64,

    /// Immutable. The next-hop VPN tunnel for packets on this route.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub next_hop_vpn_tunnel: std::option::Option<crate::model::NextHopVPNTunnel>,

    /// Immutable. The next-hop Router appliance instance for packets on this
    /// route.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub next_hop_router_appliance_instance:
        std::option::Option<crate::model::NextHopRouterApplianceInstance>,

    /// Immutable. The next-hop VLAN attachment for packets on this route.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub next_hop_interconnect_attachment:
        std::option::Option<crate::model::NextHopInterconnectAttachment>,
}

impl Route {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::Route::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [create_time][crate::model::Route::create_time].
    pub fn set_create_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.create_time = v.into();
        self
    }

    /// Sets the value of [update_time][crate::model::Route::update_time].
    pub fn set_update_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.update_time = v.into();
        self
    }

    /// Sets the value of [ip_cidr_range][crate::model::Route::ip_cidr_range].
    pub fn set_ip_cidr_range<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.ip_cidr_range = v.into();
        self
    }

    /// Sets the value of [r#type][crate::model::Route::type].
    pub fn set_type<T: std::convert::Into<crate::model::RouteType>>(mut self, v: T) -> Self {
        self.r#type = v.into();
        self
    }

    /// Sets the value of [next_hop_vpc_network][crate::model::Route::next_hop_vpc_network].
    pub fn set_next_hop_vpc_network<
        T: std::convert::Into<std::option::Option<crate::model::NextHopVpcNetwork>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.next_hop_vpc_network = v.into();
        self
    }

    /// Sets the value of [description][crate::model::Route::description].
    pub fn set_description<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.description = v.into();
        self
    }

    /// Sets the value of [uid][crate::model::Route::uid].
    pub fn set_uid<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.uid = v.into();
        self
    }

    /// Sets the value of [state][crate::model::Route::state].
    pub fn set_state<T: std::convert::Into<crate::model::State>>(mut self, v: T) -> Self {
        self.state = v.into();
        self
    }

    /// Sets the value of [spoke][crate::model::Route::spoke].
    pub fn set_spoke<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.spoke = v.into();
        self
    }

    /// Sets the value of [location][crate::model::Route::location].
    pub fn set_location<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.location = v.into();
        self
    }

    /// Sets the value of [priority][crate::model::Route::priority].
    pub fn set_priority<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.priority = v.into();
        self
    }

    /// Sets the value of [next_hop_vpn_tunnel][crate::model::Route::next_hop_vpn_tunnel].
    pub fn set_next_hop_vpn_tunnel<
        T: std::convert::Into<std::option::Option<crate::model::NextHopVPNTunnel>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.next_hop_vpn_tunnel = v.into();
        self
    }

    /// Sets the value of [next_hop_router_appliance_instance][crate::model::Route::next_hop_router_appliance_instance].
    pub fn set_next_hop_router_appliance_instance<
        T: std::convert::Into<std::option::Option<crate::model::NextHopRouterApplianceInstance>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.next_hop_router_appliance_instance = v.into();
        self
    }

    /// Sets the value of [next_hop_interconnect_attachment][crate::model::Route::next_hop_interconnect_attachment].
    pub fn set_next_hop_interconnect_attachment<
        T: std::convert::Into<std::option::Option<crate::model::NextHopInterconnectAttachment>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.next_hop_interconnect_attachment = v.into();
        self
    }

    /// Sets the value of [labels][crate::model::Route::labels].
    pub fn set_labels<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.labels = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }
}

impl wkt::message::Message for Route {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.Route"
    }
}

/// A group represents a subset of spokes attached to a hub.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct Group {
    /// Immutable. The name of the group. Group names must be unique. They
    /// use the following form:
    /// `projects/{project_number}/locations/global/hubs/{hub}/groups/{group_id}`
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    /// Output only. The time the group was created.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The time the group was last updated.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// Optional. Labels in key-value pair format. For more information about
    /// labels, see [Requirements for
    /// labels](https://cloud.google.com/resource-manager/docs/creating-managing-labels#requirements).
    #[serde(skip_serializing_if = "std::collections::HashMap::is_empty")]
    pub labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// Optional. The description of the group.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub description: std::string::String,

    /// Output only. The Google-generated UUID for the group. This value is unique
    /// across all group resources. If a group is deleted and
    /// another with the same name is created, the new route table is assigned
    /// a different unique_id.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub uid: std::string::String,

    /// Output only. The current lifecycle state of this group.
    pub state: crate::model::State,

    /// Optional. The auto-accept setting for this group.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub auto_accept: std::option::Option<crate::model::AutoAccept>,

    /// Output only. The name of the route table that corresponds to this group.
    /// They use the following form:
    /// `projects/{project_number}/locations/global/hubs/{hub_id}/routeTables/{route_table_id}`
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub route_table: std::string::String,
}

impl Group {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::Group::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [create_time][crate::model::Group::create_time].
    pub fn set_create_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.create_time = v.into();
        self
    }

    /// Sets the value of [update_time][crate::model::Group::update_time].
    pub fn set_update_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.update_time = v.into();
        self
    }

    /// Sets the value of [description][crate::model::Group::description].
    pub fn set_description<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.description = v.into();
        self
    }

    /// Sets the value of [uid][crate::model::Group::uid].
    pub fn set_uid<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.uid = v.into();
        self
    }

    /// Sets the value of [state][crate::model::Group::state].
    pub fn set_state<T: std::convert::Into<crate::model::State>>(mut self, v: T) -> Self {
        self.state = v.into();
        self
    }

    /// Sets the value of [auto_accept][crate::model::Group::auto_accept].
    pub fn set_auto_accept<T: std::convert::Into<std::option::Option<crate::model::AutoAccept>>>(
        mut self,
        v: T,
    ) -> Self {
        self.auto_accept = v.into();
        self
    }

    /// Sets the value of [route_table][crate::model::Group::route_table].
    pub fn set_route_table<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.route_table = v.into();
        self
    }

    /// Sets the value of [labels][crate::model::Group::labels].
    pub fn set_labels<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.labels = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }
}

impl wkt::message::Message for Group {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.Group"
    }
}

/// The auto-accept setting for a group controls whether
/// proposed spokes are automatically attached to the hub. If auto-accept is
/// enabled, the spoke immediately is attached to the hub and becomes part of the
/// group. In this case, the new spoke is in the ACTIVE state.
/// If auto-accept is disabled, the spoke goes to the INACTIVE
/// state, and it must be reviewed and accepted by a hub
/// administrator.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct AutoAccept {
    /// A list of project ids or project numbers for which you want
    /// to enable auto-accept. The auto-accept setting is applied to
    /// spokes being created or updated in these projects.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub auto_accept_projects: std::vec::Vec<std::string::String>,
}

impl AutoAccept {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [auto_accept_projects][crate::model::AutoAccept::auto_accept_projects].
    pub fn set_auto_accept_projects<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.auto_accept_projects = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for AutoAccept {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.AutoAccept"
    }
}

/// Request for
/// [HubService.ListHubs][google.cloud.networkconnectivity.v1.HubService.ListHubs]
/// method.
///
/// [google.cloud.networkconnectivity.v1.HubService.ListHubs]: crate::client::HubService::list_hubs
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListHubsRequest {
    /// Required. The parent resource's name.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub parent: std::string::String,

    /// The maximum number of results per page to return.
    pub page_size: i32,

    /// The page token.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub page_token: std::string::String,

    /// An expression that filters the list of results.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub filter: std::string::String,

    /// Sort the results by a certain order.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub order_by: std::string::String,
}

impl ListHubsRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::ListHubsRequest::parent].
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [page_size][crate::model::ListHubsRequest::page_size].
    pub fn set_page_size<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.page_size = v.into();
        self
    }

    /// Sets the value of [page_token][crate::model::ListHubsRequest::page_token].
    pub fn set_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.page_token = v.into();
        self
    }

    /// Sets the value of [filter][crate::model::ListHubsRequest::filter].
    pub fn set_filter<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.filter = v.into();
        self
    }

    /// Sets the value of [order_by][crate::model::ListHubsRequest::order_by].
    pub fn set_order_by<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.order_by = v.into();
        self
    }
}

impl wkt::message::Message for ListHubsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.ListHubsRequest"
    }
}

/// Response for
/// [HubService.ListHubs][google.cloud.networkconnectivity.v1.HubService.ListHubs]
/// method.
///
/// [google.cloud.networkconnectivity.v1.HubService.ListHubs]: crate::client::HubService::list_hubs
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListHubsResponse {
    /// The requested hubs.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub hubs: std::vec::Vec<crate::model::Hub>,

    /// The token for the next page of the response. To see more results,
    /// use this value as the page_token for your next request. If this value
    /// is empty, there are no more results.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub next_page_token: std::string::String,

    /// Locations that could not be reached.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub unreachable: std::vec::Vec<std::string::String>,
}

impl ListHubsResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [next_page_token][crate::model::ListHubsResponse::next_page_token].
    pub fn set_next_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.next_page_token = v.into();
        self
    }

    /// Sets the value of [hubs][crate::model::ListHubsResponse::hubs].
    pub fn set_hubs<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::Hub>,
    {
        use std::iter::Iterator;
        self.hubs = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [unreachable][crate::model::ListHubsResponse::unreachable].
    pub fn set_unreachable<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.unreachable = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for ListHubsResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.ListHubsResponse"
    }
}

#[cfg(feature = "unstable-stream")]
impl gax::paginator::PageableResponse for ListHubsResponse {
    type PageItem = crate::model::Hub;

    fn items(self) -> std::vec::Vec<Self::PageItem> {
        self.hubs
    }

    fn next_page_token(&self) -> std::string::String {
        gax::paginator::extract_token(&self.next_page_token)
    }
}

/// Request for
/// [HubService.GetHub][google.cloud.networkconnectivity.v1.HubService.GetHub]
/// method.
///
/// [google.cloud.networkconnectivity.v1.HubService.GetHub]: crate::client::HubService::get_hub
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct GetHubRequest {
    /// Required. The name of the hub resource to get.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,
}

impl GetHubRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::GetHubRequest::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for GetHubRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.GetHubRequest"
    }
}

/// Request for
/// [HubService.CreateHub][google.cloud.networkconnectivity.v1.HubService.CreateHub]
/// method.
///
/// [google.cloud.networkconnectivity.v1.HubService.CreateHub]: crate::client::HubService::create_hub
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct CreateHubRequest {
    /// Required. The parent resource.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub parent: std::string::String,

    /// Required. A unique identifier for the hub.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub hub_id: std::string::String,

    /// Required. The initial values for a new hub.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub hub: std::option::Option<crate::model::Hub>,

    /// Optional. A request ID to identify requests. Specify a unique request ID so
    /// that if you must retry your request, the server knows to ignore the request
    /// if it has already been completed. The server guarantees that a request
    /// doesn't result in creation of duplicate commitments for at least 60
    /// minutes.
    ///
    /// For example, consider a situation where you make an initial request and
    /// the request times out. If you make the request again with the same request
    /// ID, the server can check to see whether the original operation
    /// was received. If it was, the server ignores the second request. This
    /// behavior prevents clients from mistakenly creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID, with the exception that zero UUID is
    /// not supported (00000000-0000-0000-0000-000000000000).
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub request_id: std::string::String,
}

impl CreateHubRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::CreateHubRequest::parent].
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [hub_id][crate::model::CreateHubRequest::hub_id].
    pub fn set_hub_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.hub_id = v.into();
        self
    }

    /// Sets the value of [hub][crate::model::CreateHubRequest::hub].
    pub fn set_hub<T: std::convert::Into<std::option::Option<crate::model::Hub>>>(
        mut self,
        v: T,
    ) -> Self {
        self.hub = v.into();
        self
    }

    /// Sets the value of [request_id][crate::model::CreateHubRequest::request_id].
    pub fn set_request_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.request_id = v.into();
        self
    }
}

impl wkt::message::Message for CreateHubRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.CreateHubRequest"
    }
}

/// Request for
/// [HubService.UpdateHub][google.cloud.networkconnectivity.v1.HubService.UpdateHub]
/// method.
///
/// [google.cloud.networkconnectivity.v1.HubService.UpdateHub]: crate::client::HubService::update_hub
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct UpdateHubRequest {
    /// Optional. In the case of an update to an existing hub, field mask is used
    /// to specify the fields to be overwritten. The fields specified in the
    /// update_mask are relative to the resource, not the full request. A field is
    /// overwritten if it is in the mask. If the user does not provide a mask, then
    /// all fields are overwritten.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub update_mask: std::option::Option<wkt::FieldMask>,

    /// Required. The state that the hub should be in after the update.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub hub: std::option::Option<crate::model::Hub>,

    /// Optional. A request ID to identify requests. Specify a unique request ID so
    /// that if you must retry your request, the server knows to ignore the request
    /// if it has already been completed. The server guarantees that a request
    /// doesn't result in creation of duplicate commitments for at least 60
    /// minutes.
    ///
    /// For example, consider a situation where you make an initial request and
    /// the request times out. If you make the request again with the same request
    /// ID, the server can check to see whether the original operation
    /// was received. If it was, the server ignores the second request. This
    /// behavior prevents clients from mistakenly creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID, with the exception that zero UUID is
    /// not supported (00000000-0000-0000-0000-000000000000).
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub request_id: std::string::String,
}

impl UpdateHubRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [update_mask][crate::model::UpdateHubRequest::update_mask].
    pub fn set_update_mask<T: std::convert::Into<std::option::Option<wkt::FieldMask>>>(
        mut self,
        v: T,
    ) -> Self {
        self.update_mask = v.into();
        self
    }

    /// Sets the value of [hub][crate::model::UpdateHubRequest::hub].
    pub fn set_hub<T: std::convert::Into<std::option::Option<crate::model::Hub>>>(
        mut self,
        v: T,
    ) -> Self {
        self.hub = v.into();
        self
    }

    /// Sets the value of [request_id][crate::model::UpdateHubRequest::request_id].
    pub fn set_request_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.request_id = v.into();
        self
    }
}

impl wkt::message::Message for UpdateHubRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.UpdateHubRequest"
    }
}

/// The request for
/// [HubService.DeleteHub][google.cloud.networkconnectivity.v1.HubService.DeleteHub].
///
/// [google.cloud.networkconnectivity.v1.HubService.DeleteHub]: crate::client::HubService::delete_hub
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct DeleteHubRequest {
    /// Required. The name of the hub to delete.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    /// Optional. A request ID to identify requests. Specify a unique request ID so
    /// that if you must retry your request, the server knows to ignore the request
    /// if it has already been completed. The server guarantees that a request
    /// doesn't result in creation of duplicate commitments for at least 60
    /// minutes.
    ///
    /// For example, consider a situation where you make an initial request and
    /// the request times out. If you make the request again with the same request
    /// ID, the server can check to see whether the original operation
    /// was received. If it was, the server ignores the second request. This
    /// behavior prevents clients from mistakenly creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID, with the exception that zero UUID is
    /// not supported (00000000-0000-0000-0000-000000000000).
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub request_id: std::string::String,
}

impl DeleteHubRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::DeleteHubRequest::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [request_id][crate::model::DeleteHubRequest::request_id].
    pub fn set_request_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.request_id = v.into();
        self
    }
}

impl wkt::message::Message for DeleteHubRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.DeleteHubRequest"
    }
}

/// The request for
/// [HubService.ListHubSpokes][google.cloud.networkconnectivity.v1.HubService.ListHubSpokes].
///
/// [google.cloud.networkconnectivity.v1.HubService.ListHubSpokes]: crate::client::HubService::list_hub_spokes
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListHubSpokesRequest {
    /// Required. The name of the hub.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    /// A list of locations.
    /// Specify one of the following: `[global]`, a single region (for
    /// example, `[us-central1]`), or a combination of
    /// values (for example, `[global, us-central1, us-west1]`).
    /// If the spoke_locations field is populated, the list of results
    /// includes only spokes in the specified location.
    /// If the spoke_locations field is not populated, the list of results
    /// includes spokes in all locations.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub spoke_locations: std::vec::Vec<std::string::String>,

    /// The maximum number of results to return per page.
    pub page_size: i32,

    /// The page token.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub page_token: std::string::String,

    /// An expression that filters the list of results.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub filter: std::string::String,

    /// Sort the results by name or create_time.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub order_by: std::string::String,

    /// The view of the spoke to return.
    /// The view that you use determines which spoke fields are included in the
    /// response.
    pub view: crate::model::list_hub_spokes_request::SpokeView,
}

impl ListHubSpokesRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::ListHubSpokesRequest::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [page_size][crate::model::ListHubSpokesRequest::page_size].
    pub fn set_page_size<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.page_size = v.into();
        self
    }

    /// Sets the value of [page_token][crate::model::ListHubSpokesRequest::page_token].
    pub fn set_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.page_token = v.into();
        self
    }

    /// Sets the value of [filter][crate::model::ListHubSpokesRequest::filter].
    pub fn set_filter<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.filter = v.into();
        self
    }

    /// Sets the value of [order_by][crate::model::ListHubSpokesRequest::order_by].
    pub fn set_order_by<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.order_by = v.into();
        self
    }

    /// Sets the value of [view][crate::model::ListHubSpokesRequest::view].
    pub fn set_view<T: std::convert::Into<crate::model::list_hub_spokes_request::SpokeView>>(
        mut self,
        v: T,
    ) -> Self {
        self.view = v.into();
        self
    }

    /// Sets the value of [spoke_locations][crate::model::ListHubSpokesRequest::spoke_locations].
    pub fn set_spoke_locations<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.spoke_locations = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for ListHubSpokesRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.ListHubSpokesRequest"
    }
}

/// Defines additional types related to ListHubSpokesRequest
pub mod list_hub_spokes_request {
    #[allow(unused_imports)]
    use super::*;

    /// Enum that controls which spoke fields are included in the response.
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    pub struct SpokeView(std::borrow::Cow<'static, str>);

    impl SpokeView {
        /// Creates a new SpokeView instance.
        pub const fn new(v: &'static str) -> Self {
            Self(std::borrow::Cow::Borrowed(v))
        }

        /// Gets the enum value.
        pub fn value(&self) -> &str {
            &self.0
        }
    }

    /// Useful constants to work with [SpokeView](SpokeView)
    pub mod spoke_view {
        use super::SpokeView;

        /// The spoke view is unspecified. When the spoke view is unspecified, the
        /// API returns the same fields as the `BASIC` view.
        pub const SPOKE_VIEW_UNSPECIFIED: SpokeView = SpokeView::new("SPOKE_VIEW_UNSPECIFIED");

        /// Includes `name`, `create_time`, `hub`, `unique_id`, `state`, `reasons`,
        /// and `spoke_type`. This is the default value.
        pub const BASIC: SpokeView = SpokeView::new("BASIC");

        /// Includes all spoke fields except `labels`.
        /// You can use the `DETAILED` view only when you set the `spoke_locations`
        /// field to `[global]`.
        pub const DETAILED: SpokeView = SpokeView::new("DETAILED");
    }

    impl std::convert::From<std::string::String> for SpokeView {
        fn from(value: std::string::String) -> Self {
            Self(std::borrow::Cow::Owned(value))
        }
    }
}

/// The response for
/// [HubService.ListHubSpokes][google.cloud.networkconnectivity.v1.HubService.ListHubSpokes].
///
/// [google.cloud.networkconnectivity.v1.HubService.ListHubSpokes]: crate::client::HubService::list_hub_spokes
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListHubSpokesResponse {
    /// The requested spokes.
    /// The spoke fields can be partially populated based on the `view` field in
    /// the request message.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub spokes: std::vec::Vec<crate::model::Spoke>,

    /// The token for the next page of the response. To see more results,
    /// use this value as the page_token for your next request. If this value
    /// is empty, there are no more results.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub next_page_token: std::string::String,

    /// Locations that could not be reached.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub unreachable: std::vec::Vec<std::string::String>,
}

impl ListHubSpokesResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [next_page_token][crate::model::ListHubSpokesResponse::next_page_token].
    pub fn set_next_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.next_page_token = v.into();
        self
    }

    /// Sets the value of [spokes][crate::model::ListHubSpokesResponse::spokes].
    pub fn set_spokes<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::Spoke>,
    {
        use std::iter::Iterator;
        self.spokes = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [unreachable][crate::model::ListHubSpokesResponse::unreachable].
    pub fn set_unreachable<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.unreachable = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for ListHubSpokesResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.ListHubSpokesResponse"
    }
}

#[cfg(feature = "unstable-stream")]
impl gax::paginator::PageableResponse for ListHubSpokesResponse {
    type PageItem = crate::model::Spoke;

    fn items(self) -> std::vec::Vec<Self::PageItem> {
        self.spokes
    }

    fn next_page_token(&self) -> std::string::String {
        gax::paginator::extract_token(&self.next_page_token)
    }
}

/// The request for
/// [HubService.QueryHubStatus][google.cloud.networkconnectivity.v1.HubService.QueryHubStatus].
///
/// [google.cloud.networkconnectivity.v1.HubService.QueryHubStatus]: crate::client::HubService::query_hub_status
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct QueryHubStatusRequest {
    /// Required. The name of the hub.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    /// Optional. The maximum number of results to return per page.
    pub page_size: i32,

    /// Optional. The page token.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub page_token: std::string::String,

    /// Optional. An expression that filters the list of results.
    /// The filter can be used to filter the results by the following fields:
    ///
    /// * `psc_propagation_status.source_spoke`
    /// * `psc_propagation_status.source_group`
    /// * `psc_propagation_status.source_forwarding_rule`
    /// * `psc_propagation_status.target_spoke`
    /// * `psc_propagation_status.target_group`
    /// * `psc_propagation_status.code`
    /// * `psc_propagation_status.message`
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub filter: std::string::String,

    /// Optional. Sort the results in ascending order by the specified fields.
    /// A comma-separated list of any of these fields:
    ///
    /// * `psc_propagation_status.source_spoke`
    /// * `psc_propagation_status.source_group`
    /// * `psc_propagation_status.source_forwarding_rule`
    /// * `psc_propagation_status.target_spoke`
    /// * `psc_propagation_status.target_group`
    /// * `psc_propagation_status.code`
    ///   If `group_by` is set, the value of the `order_by` field must be the
    ///   same as or a subset of the `group_by` field.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub order_by: std::string::String,

    /// Optional. Aggregate the results by the specified fields.
    /// A comma-separated list of any of these fields:
    ///
    /// * `psc_propagation_status.source_spoke`
    /// * `psc_propagation_status.source_group`
    /// * `psc_propagation_status.source_forwarding_rule`
    /// * `psc_propagation_status.target_spoke`
    /// * `psc_propagation_status.target_group`
    /// * `psc_propagation_status.code`
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub group_by: std::string::String,
}

impl QueryHubStatusRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::QueryHubStatusRequest::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [page_size][crate::model::QueryHubStatusRequest::page_size].
    pub fn set_page_size<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.page_size = v.into();
        self
    }

    /// Sets the value of [page_token][crate::model::QueryHubStatusRequest::page_token].
    pub fn set_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.page_token = v.into();
        self
    }

    /// Sets the value of [filter][crate::model::QueryHubStatusRequest::filter].
    pub fn set_filter<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.filter = v.into();
        self
    }

    /// Sets the value of [order_by][crate::model::QueryHubStatusRequest::order_by].
    pub fn set_order_by<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.order_by = v.into();
        self
    }

    /// Sets the value of [group_by][crate::model::QueryHubStatusRequest::group_by].
    pub fn set_group_by<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.group_by = v.into();
        self
    }
}

impl wkt::message::Message for QueryHubStatusRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.QueryHubStatusRequest"
    }
}

/// The response for
/// [HubService.QueryHubStatus][google.cloud.networkconnectivity.v1.HubService.QueryHubStatus].
///
/// [google.cloud.networkconnectivity.v1.HubService.QueryHubStatus]: crate::client::HubService::query_hub_status
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct QueryHubStatusResponse {
    /// The list of hub status.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub hub_status_entries: std::vec::Vec<crate::model::HubStatusEntry>,

    /// The token for the next page of the response. To see more results,
    /// use this value as the page_token for your next request. If this value
    /// is empty, there are no more results.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub next_page_token: std::string::String,
}

impl QueryHubStatusResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [next_page_token][crate::model::QueryHubStatusResponse::next_page_token].
    pub fn set_next_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.next_page_token = v.into();
        self
    }

    /// Sets the value of [hub_status_entries][crate::model::QueryHubStatusResponse::hub_status_entries].
    pub fn set_hub_status_entries<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::HubStatusEntry>,
    {
        use std::iter::Iterator;
        self.hub_status_entries = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for QueryHubStatusResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.QueryHubStatusResponse"
    }
}

#[cfg(feature = "unstable-stream")]
impl gax::paginator::PageableResponse for QueryHubStatusResponse {
    type PageItem = crate::model::HubStatusEntry;

    fn items(self) -> std::vec::Vec<Self::PageItem> {
        self.hub_status_entries
    }

    fn next_page_token(&self) -> std::string::String {
        gax::paginator::extract_token(&self.next_page_token)
    }
}

/// A hub status entry represents the status of a set of propagated Private
/// Service Connect connections grouped by certain fields.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct HubStatusEntry {
    /// The number of propagated Private Service Connect connections with this
    /// status. If the `group_by` field was not set in the request message, the
    /// value of this field is 1.
    pub count: i32,

    /// The fields that this entry is grouped by. This has the same value as the
    /// `group_by` field in the request message.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub group_by: std::string::String,

    /// The Private Service Connect propagation status.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub psc_propagation_status: std::option::Option<crate::model::PscPropagationStatus>,
}

impl HubStatusEntry {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [count][crate::model::HubStatusEntry::count].
    pub fn set_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.count = v.into();
        self
    }

    /// Sets the value of [group_by][crate::model::HubStatusEntry::group_by].
    pub fn set_group_by<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.group_by = v.into();
        self
    }

    /// Sets the value of [psc_propagation_status][crate::model::HubStatusEntry::psc_propagation_status].
    pub fn set_psc_propagation_status<
        T: std::convert::Into<std::option::Option<crate::model::PscPropagationStatus>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.psc_propagation_status = v.into();
        self
    }
}

impl wkt::message::Message for HubStatusEntry {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.HubStatusEntry"
    }
}

/// The status of one or more propagated Private Service Connect connections in a
/// hub.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct PscPropagationStatus {
    /// The name of the spoke that the source forwarding rule belongs to.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub source_spoke: std::string::String,

    /// The name of the group that the source spoke belongs to.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub source_group: std::string::String,

    /// The name of the forwarding rule exported to the hub.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub source_forwarding_rule: std::string::String,

    /// The name of the spoke that the source forwarding rule propagates to.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub target_spoke: std::string::String,

    /// The name of the group that the target spoke belongs to.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub target_group: std::string::String,

    /// The propagation status.
    pub code: crate::model::psc_propagation_status::Code,

    /// The human-readable summary of the Private Service Connect connection
    /// propagation status.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub message: std::string::String,
}

impl PscPropagationStatus {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [source_spoke][crate::model::PscPropagationStatus::source_spoke].
    pub fn set_source_spoke<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.source_spoke = v.into();
        self
    }

    /// Sets the value of [source_group][crate::model::PscPropagationStatus::source_group].
    pub fn set_source_group<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.source_group = v.into();
        self
    }

    /// Sets the value of [source_forwarding_rule][crate::model::PscPropagationStatus::source_forwarding_rule].
    pub fn set_source_forwarding_rule<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.source_forwarding_rule = v.into();
        self
    }

    /// Sets the value of [target_spoke][crate::model::PscPropagationStatus::target_spoke].
    pub fn set_target_spoke<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.target_spoke = v.into();
        self
    }

    /// Sets the value of [target_group][crate::model::PscPropagationStatus::target_group].
    pub fn set_target_group<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.target_group = v.into();
        self
    }

    /// Sets the value of [code][crate::model::PscPropagationStatus::code].
    pub fn set_code<T: std::convert::Into<crate::model::psc_propagation_status::Code>>(
        mut self,
        v: T,
    ) -> Self {
        self.code = v.into();
        self
    }

    /// Sets the value of [message][crate::model::PscPropagationStatus::message].
    pub fn set_message<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.message = v.into();
        self
    }
}

impl wkt::message::Message for PscPropagationStatus {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.PscPropagationStatus"
    }
}

/// Defines additional types related to PscPropagationStatus
pub mod psc_propagation_status {
    #[allow(unused_imports)]
    use super::*;

    /// The Code enum represents the state of the Private Service Connect
    /// propagation.
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    pub struct Code(std::borrow::Cow<'static, str>);

    impl Code {
        /// Creates a new Code instance.
        pub const fn new(v: &'static str) -> Self {
            Self(std::borrow::Cow::Borrowed(v))
        }

        /// Gets the enum value.
        pub fn value(&self) -> &str {
            &self.0
        }
    }

    /// Useful constants to work with [Code](Code)
    pub mod code {
        use super::Code;

        /// The code is unspecified.
        pub const CODE_UNSPECIFIED: Code = Code::new("CODE_UNSPECIFIED");

        /// The propagated Private Service Connect connection is ready.
        pub const READY: Code = Code::new("READY");

        /// The Private Service Connect connection is propagating. This is a
        /// transient state.
        pub const PROPAGATING: Code = Code::new("PROPAGATING");

        /// The Private Service Connect connection propagation failed because the VPC
        /// network or the project of the target spoke has exceeded the connection
        /// limit set by the producer.
        pub const ERROR_PRODUCER_PROPAGATED_CONNECTION_LIMIT_EXCEEDED: Code =
            Code::new("ERROR_PRODUCER_PROPAGATED_CONNECTION_LIMIT_EXCEEDED");

        /// The Private Service Connect connection propagation failed because the NAT
        /// IP subnet space has been exhausted. It is equivalent to the `Needs
        /// attention` status of the Private Service Connect connection. See
        /// <https://cloud.google.com/vpc/docs/about-accessing-vpc-hosted-services-endpoints#connection-statuses>.
        pub const ERROR_PRODUCER_NAT_IP_SPACE_EXHAUSTED: Code =
            Code::new("ERROR_PRODUCER_NAT_IP_SPACE_EXHAUSTED");

        /// The Private Service Connect connection propagation failed because the
        /// `PSC_ILB_CONSUMER_FORWARDING_RULES_PER_PRODUCER_NETWORK` quota in the
        /// producer VPC network has been exceeded.
        pub const ERROR_PRODUCER_QUOTA_EXCEEDED: Code = Code::new("ERROR_PRODUCER_QUOTA_EXCEEDED");

        /// The Private Service Connect connection propagation failed because the
        /// `PSC_PROPAGATED_CONNECTIONS_PER_VPC_NETWORK` quota in the consumer
        /// VPC network has been exceeded.
        pub const ERROR_CONSUMER_QUOTA_EXCEEDED: Code = Code::new("ERROR_CONSUMER_QUOTA_EXCEEDED");
    }

    impl std::convert::From<std::string::String> for Code {
        fn from(value: std::string::String) -> Self {
            Self(std::borrow::Cow::Owned(value))
        }
    }
}

/// The request for
/// [HubService.ListSpokes][google.cloud.networkconnectivity.v1.HubService.ListSpokes].
///
/// [google.cloud.networkconnectivity.v1.HubService.ListSpokes]: crate::client::HubService::list_spokes
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListSpokesRequest {
    /// Required. The parent resource.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub parent: std::string::String,

    /// The maximum number of results to return per page.
    pub page_size: i32,

    /// The page token.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub page_token: std::string::String,

    /// An expression that filters the list of results.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub filter: std::string::String,

    /// Sort the results by a certain order.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub order_by: std::string::String,
}

impl ListSpokesRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::ListSpokesRequest::parent].
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [page_size][crate::model::ListSpokesRequest::page_size].
    pub fn set_page_size<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.page_size = v.into();
        self
    }

    /// Sets the value of [page_token][crate::model::ListSpokesRequest::page_token].
    pub fn set_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.page_token = v.into();
        self
    }

    /// Sets the value of [filter][crate::model::ListSpokesRequest::filter].
    pub fn set_filter<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.filter = v.into();
        self
    }

    /// Sets the value of [order_by][crate::model::ListSpokesRequest::order_by].
    pub fn set_order_by<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.order_by = v.into();
        self
    }
}

impl wkt::message::Message for ListSpokesRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.ListSpokesRequest"
    }
}

/// The response for
/// [HubService.ListSpokes][google.cloud.networkconnectivity.v1.HubService.ListSpokes].
///
/// [google.cloud.networkconnectivity.v1.HubService.ListSpokes]: crate::client::HubService::list_spokes
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListSpokesResponse {
    /// The requested spokes.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub spokes: std::vec::Vec<crate::model::Spoke>,

    /// The token for the next page of the response. To see more results,
    /// use this value as the page_token for your next request. If this value
    /// is empty, there are no more results.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub next_page_token: std::string::String,

    /// Locations that could not be reached.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub unreachable: std::vec::Vec<std::string::String>,
}

impl ListSpokesResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [next_page_token][crate::model::ListSpokesResponse::next_page_token].
    pub fn set_next_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.next_page_token = v.into();
        self
    }

    /// Sets the value of [spokes][crate::model::ListSpokesResponse::spokes].
    pub fn set_spokes<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::Spoke>,
    {
        use std::iter::Iterator;
        self.spokes = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [unreachable][crate::model::ListSpokesResponse::unreachable].
    pub fn set_unreachable<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.unreachable = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for ListSpokesResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.ListSpokesResponse"
    }
}

#[cfg(feature = "unstable-stream")]
impl gax::paginator::PageableResponse for ListSpokesResponse {
    type PageItem = crate::model::Spoke;

    fn items(self) -> std::vec::Vec<Self::PageItem> {
        self.spokes
    }

    fn next_page_token(&self) -> std::string::String {
        gax::paginator::extract_token(&self.next_page_token)
    }
}

/// The request for
/// [HubService.GetSpoke][google.cloud.networkconnectivity.v1.HubService.GetSpoke].
///
/// [google.cloud.networkconnectivity.v1.HubService.GetSpoke]: crate::client::HubService::get_spoke
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct GetSpokeRequest {
    /// Required. The name of the spoke resource.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,
}

impl GetSpokeRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::GetSpokeRequest::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for GetSpokeRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.GetSpokeRequest"
    }
}

/// The request for
/// [HubService.CreateSpoke][google.cloud.networkconnectivity.v1.HubService.CreateSpoke].
///
/// [google.cloud.networkconnectivity.v1.HubService.CreateSpoke]: crate::client::HubService::create_spoke
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct CreateSpokeRequest {
    /// Required. The parent resource.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub parent: std::string::String,

    /// Required. Unique id for the spoke to create.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub spoke_id: std::string::String,

    /// Required. The initial values for a new spoke.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub spoke: std::option::Option<crate::model::Spoke>,

    /// Optional. A request ID to identify requests. Specify a unique request ID so
    /// that if you must retry your request, the server knows to ignore the request
    /// if it has already been completed. The server guarantees that a request
    /// doesn't result in creation of duplicate commitments for at least 60
    /// minutes.
    ///
    /// For example, consider a situation where you make an initial request and
    /// the request times out. If you make the request again with the same request
    /// ID, the server can check to see whether the original operation
    /// was received. If it was, the server ignores the second request. This
    /// behavior prevents clients from mistakenly creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID, with the exception that zero UUID is
    /// not supported (00000000-0000-0000-0000-000000000000).
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub request_id: std::string::String,
}

impl CreateSpokeRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::CreateSpokeRequest::parent].
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [spoke_id][crate::model::CreateSpokeRequest::spoke_id].
    pub fn set_spoke_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.spoke_id = v.into();
        self
    }

    /// Sets the value of [spoke][crate::model::CreateSpokeRequest::spoke].
    pub fn set_spoke<T: std::convert::Into<std::option::Option<crate::model::Spoke>>>(
        mut self,
        v: T,
    ) -> Self {
        self.spoke = v.into();
        self
    }

    /// Sets the value of [request_id][crate::model::CreateSpokeRequest::request_id].
    pub fn set_request_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.request_id = v.into();
        self
    }
}

impl wkt::message::Message for CreateSpokeRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.CreateSpokeRequest"
    }
}

/// Request for
/// [HubService.UpdateSpoke][google.cloud.networkconnectivity.v1.HubService.UpdateSpoke]
/// method.
///
/// [google.cloud.networkconnectivity.v1.HubService.UpdateSpoke]: crate::client::HubService::update_spoke
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct UpdateSpokeRequest {
    /// Optional. In the case of an update to an existing spoke, field mask is used
    /// to specify the fields to be overwritten. The fields specified in the
    /// update_mask are relative to the resource, not the full request. A field is
    /// overwritten if it is in the mask. If the user does not provide a mask, then
    /// all fields are overwritten.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub update_mask: std::option::Option<wkt::FieldMask>,

    /// Required. The state that the spoke should be in after the update.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub spoke: std::option::Option<crate::model::Spoke>,

    /// Optional. A request ID to identify requests. Specify a unique request ID so
    /// that if you must retry your request, the server knows to ignore the request
    /// if it has already been completed. The server guarantees that a request
    /// doesn't result in creation of duplicate commitments for at least 60
    /// minutes.
    ///
    /// For example, consider a situation where you make an initial request and
    /// the request times out. If you make the request again with the same request
    /// ID, the server can check to see whether the original operation
    /// was received. If it was, the server ignores the second request. This
    /// behavior prevents clients from mistakenly creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID, with the exception that zero UUID is
    /// not supported (00000000-0000-0000-0000-000000000000).
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub request_id: std::string::String,
}

impl UpdateSpokeRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [update_mask][crate::model::UpdateSpokeRequest::update_mask].
    pub fn set_update_mask<T: std::convert::Into<std::option::Option<wkt::FieldMask>>>(
        mut self,
        v: T,
    ) -> Self {
        self.update_mask = v.into();
        self
    }

    /// Sets the value of [spoke][crate::model::UpdateSpokeRequest::spoke].
    pub fn set_spoke<T: std::convert::Into<std::option::Option<crate::model::Spoke>>>(
        mut self,
        v: T,
    ) -> Self {
        self.spoke = v.into();
        self
    }

    /// Sets the value of [request_id][crate::model::UpdateSpokeRequest::request_id].
    pub fn set_request_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.request_id = v.into();
        self
    }
}

impl wkt::message::Message for UpdateSpokeRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.UpdateSpokeRequest"
    }
}

/// The request for
/// [HubService.DeleteSpoke][google.cloud.networkconnectivity.v1.HubService.DeleteSpoke].
///
/// [google.cloud.networkconnectivity.v1.HubService.DeleteSpoke]: crate::client::HubService::delete_spoke
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct DeleteSpokeRequest {
    /// Required. The name of the spoke to delete.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    /// Optional. A request ID to identify requests. Specify a unique request ID so
    /// that if you must retry your request, the server knows to ignore the request
    /// if it has already been completed. The server guarantees that a request
    /// doesn't result in creation of duplicate commitments for at least 60
    /// minutes.
    ///
    /// For example, consider a situation where you make an initial request and
    /// the request times out. If you make the request again with the same request
    /// ID, the server can check to see whether the original operation
    /// was received. If it was, the server ignores the second request. This
    /// behavior prevents clients from mistakenly creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID, with the exception that zero UUID is
    /// not supported (00000000-0000-0000-0000-000000000000).
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub request_id: std::string::String,
}

impl DeleteSpokeRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::DeleteSpokeRequest::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [request_id][crate::model::DeleteSpokeRequest::request_id].
    pub fn set_request_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.request_id = v.into();
        self
    }
}

impl wkt::message::Message for DeleteSpokeRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.DeleteSpokeRequest"
    }
}

/// The request for
/// [HubService.AcceptHubSpoke][google.cloud.networkconnectivity.v1.HubService.AcceptHubSpoke].
///
/// [google.cloud.networkconnectivity.v1.HubService.AcceptHubSpoke]: crate::client::HubService::accept_hub_spoke
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct AcceptHubSpokeRequest {
    /// Required. The name of the hub into which to accept the spoke.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    /// Required. The URI of the spoke to accept into the hub.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub spoke_uri: std::string::String,

    /// Optional. A request ID to identify requests. Specify a unique request ID so
    /// that if you must retry your request, the server knows to ignore the request
    /// if it has already been completed. The server guarantees that a request
    /// doesn't result in creation of duplicate commitments for at least 60
    /// minutes.
    ///
    /// For example, consider a situation where you make an initial request and
    /// the request times out. If you make the request again with the same request
    /// ID, the server can check to see whether the original operation
    /// was received. If it was, the server ignores the second request. This
    /// behavior prevents clients from mistakenly creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID, with the exception that zero UUID is
    /// not supported (00000000-0000-0000-0000-000000000000).
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub request_id: std::string::String,
}

impl AcceptHubSpokeRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::AcceptHubSpokeRequest::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [spoke_uri][crate::model::AcceptHubSpokeRequest::spoke_uri].
    pub fn set_spoke_uri<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.spoke_uri = v.into();
        self
    }

    /// Sets the value of [request_id][crate::model::AcceptHubSpokeRequest::request_id].
    pub fn set_request_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.request_id = v.into();
        self
    }
}

impl wkt::message::Message for AcceptHubSpokeRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.AcceptHubSpokeRequest"
    }
}

/// The response for
/// [HubService.AcceptHubSpoke][google.cloud.networkconnectivity.v1.HubService.AcceptHubSpoke].
///
/// [google.cloud.networkconnectivity.v1.HubService.AcceptHubSpoke]: crate::client::HubService::accept_hub_spoke
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct AcceptHubSpokeResponse {
    /// The spoke that was operated on.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub spoke: std::option::Option<crate::model::Spoke>,
}

impl AcceptHubSpokeResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [spoke][crate::model::AcceptHubSpokeResponse::spoke].
    pub fn set_spoke<T: std::convert::Into<std::option::Option<crate::model::Spoke>>>(
        mut self,
        v: T,
    ) -> Self {
        self.spoke = v.into();
        self
    }
}

impl wkt::message::Message for AcceptHubSpokeResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.AcceptHubSpokeResponse"
    }
}

/// The request for
/// [HubService.RejectHubSpoke][google.cloud.networkconnectivity.v1.HubService.RejectHubSpoke].
///
/// [google.cloud.networkconnectivity.v1.HubService.RejectHubSpoke]: crate::client::HubService::reject_hub_spoke
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct RejectHubSpokeRequest {
    /// Required. The name of the hub from which to reject the spoke.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    /// Required. The URI of the spoke to reject from the hub.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub spoke_uri: std::string::String,

    /// Optional. A request ID to identify requests. Specify a unique request ID so
    /// that if you must retry your request, the server knows to ignore the request
    /// if it has already been completed. The server guarantees that a request
    /// doesn't result in creation of duplicate commitments for at least 60
    /// minutes.
    ///
    /// For example, consider a situation where you make an initial request and
    /// the request times out. If you make the request again with the same request
    /// ID, the server can check to see whether the original operation
    /// was received. If it was, the server ignores the second request. This
    /// behavior prevents clients from mistakenly creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID, with the exception that zero UUID is
    /// not supported (00000000-0000-0000-0000-000000000000).
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub request_id: std::string::String,

    /// Optional. Additional information provided by the hub administrator.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub details: std::string::String,
}

impl RejectHubSpokeRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::RejectHubSpokeRequest::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [spoke_uri][crate::model::RejectHubSpokeRequest::spoke_uri].
    pub fn set_spoke_uri<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.spoke_uri = v.into();
        self
    }

    /// Sets the value of [request_id][crate::model::RejectHubSpokeRequest::request_id].
    pub fn set_request_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.request_id = v.into();
        self
    }

    /// Sets the value of [details][crate::model::RejectHubSpokeRequest::details].
    pub fn set_details<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.details = v.into();
        self
    }
}

impl wkt::message::Message for RejectHubSpokeRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.RejectHubSpokeRequest"
    }
}

/// The response for
/// [HubService.RejectHubSpoke][google.cloud.networkconnectivity.v1.HubService.RejectHubSpoke].
///
/// [google.cloud.networkconnectivity.v1.HubService.RejectHubSpoke]: crate::client::HubService::reject_hub_spoke
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct RejectHubSpokeResponse {
    /// The spoke that was operated on.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub spoke: std::option::Option<crate::model::Spoke>,
}

impl RejectHubSpokeResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [spoke][crate::model::RejectHubSpokeResponse::spoke].
    pub fn set_spoke<T: std::convert::Into<std::option::Option<crate::model::Spoke>>>(
        mut self,
        v: T,
    ) -> Self {
        self.spoke = v.into();
        self
    }
}

impl wkt::message::Message for RejectHubSpokeResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.RejectHubSpokeResponse"
    }
}

/// The request for
/// [HubService.GetRouteTable][google.cloud.networkconnectivity.v1.HubService.GetRouteTable].
///
/// [google.cloud.networkconnectivity.v1.HubService.GetRouteTable]: crate::client::HubService::get_route_table
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct GetRouteTableRequest {
    /// Required. The name of the route table resource.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,
}

impl GetRouteTableRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::GetRouteTableRequest::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for GetRouteTableRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.GetRouteTableRequest"
    }
}

/// The request for
/// [HubService.GetRoute][google.cloud.networkconnectivity.v1.HubService.GetRoute].
///
/// [google.cloud.networkconnectivity.v1.HubService.GetRoute]: crate::client::HubService::get_route
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct GetRouteRequest {
    /// Required. The name of the route resource.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,
}

impl GetRouteRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::GetRouteRequest::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for GetRouteRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.GetRouteRequest"
    }
}

/// Request for
/// [HubService.ListRoutes][google.cloud.networkconnectivity.v1.HubService.ListRoutes]
/// method.
///
/// [google.cloud.networkconnectivity.v1.HubService.ListRoutes]: crate::client::HubService::list_routes
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListRoutesRequest {
    /// Required. The parent resource's name.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub parent: std::string::String,

    /// The maximum number of results to return per page.
    pub page_size: i32,

    /// The page token.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub page_token: std::string::String,

    /// An expression that filters the list of results.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub filter: std::string::String,

    /// Sort the results by a certain order.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub order_by: std::string::String,
}

impl ListRoutesRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::ListRoutesRequest::parent].
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [page_size][crate::model::ListRoutesRequest::page_size].
    pub fn set_page_size<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.page_size = v.into();
        self
    }

    /// Sets the value of [page_token][crate::model::ListRoutesRequest::page_token].
    pub fn set_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.page_token = v.into();
        self
    }

    /// Sets the value of [filter][crate::model::ListRoutesRequest::filter].
    pub fn set_filter<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.filter = v.into();
        self
    }

    /// Sets the value of [order_by][crate::model::ListRoutesRequest::order_by].
    pub fn set_order_by<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.order_by = v.into();
        self
    }
}

impl wkt::message::Message for ListRoutesRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.ListRoutesRequest"
    }
}

/// Response for
/// [HubService.ListRoutes][google.cloud.networkconnectivity.v1.HubService.ListRoutes]
/// method.
///
/// [google.cloud.networkconnectivity.v1.HubService.ListRoutes]: crate::client::HubService::list_routes
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListRoutesResponse {
    /// The requested routes.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub routes: std::vec::Vec<crate::model::Route>,

    /// The token for the next page of the response. To see more results,
    /// use this value as the page_token for your next request. If this value
    /// is empty, there are no more results.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub next_page_token: std::string::String,

    /// RouteTables that could not be reached.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub unreachable: std::vec::Vec<std::string::String>,
}

impl ListRoutesResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [next_page_token][crate::model::ListRoutesResponse::next_page_token].
    pub fn set_next_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.next_page_token = v.into();
        self
    }

    /// Sets the value of [routes][crate::model::ListRoutesResponse::routes].
    pub fn set_routes<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::Route>,
    {
        use std::iter::Iterator;
        self.routes = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [unreachable][crate::model::ListRoutesResponse::unreachable].
    pub fn set_unreachable<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.unreachable = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for ListRoutesResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.ListRoutesResponse"
    }
}

#[cfg(feature = "unstable-stream")]
impl gax::paginator::PageableResponse for ListRoutesResponse {
    type PageItem = crate::model::Route;

    fn items(self) -> std::vec::Vec<Self::PageItem> {
        self.routes
    }

    fn next_page_token(&self) -> std::string::String {
        gax::paginator::extract_token(&self.next_page_token)
    }
}

/// Request for
/// [HubService.ListRouteTables][google.cloud.networkconnectivity.v1.HubService.ListRouteTables]
/// method.
///
/// [google.cloud.networkconnectivity.v1.HubService.ListRouteTables]: crate::client::HubService::list_route_tables
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListRouteTablesRequest {
    /// Required. The parent resource's name.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub parent: std::string::String,

    /// The maximum number of results to return per page.
    pub page_size: i32,

    /// The page token.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub page_token: std::string::String,

    /// An expression that filters the list of results.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub filter: std::string::String,

    /// Sort the results by a certain order.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub order_by: std::string::String,
}

impl ListRouteTablesRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::ListRouteTablesRequest::parent].
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [page_size][crate::model::ListRouteTablesRequest::page_size].
    pub fn set_page_size<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.page_size = v.into();
        self
    }

    /// Sets the value of [page_token][crate::model::ListRouteTablesRequest::page_token].
    pub fn set_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.page_token = v.into();
        self
    }

    /// Sets the value of [filter][crate::model::ListRouteTablesRequest::filter].
    pub fn set_filter<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.filter = v.into();
        self
    }

    /// Sets the value of [order_by][crate::model::ListRouteTablesRequest::order_by].
    pub fn set_order_by<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.order_by = v.into();
        self
    }
}

impl wkt::message::Message for ListRouteTablesRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.ListRouteTablesRequest"
    }
}

/// Response for
/// [HubService.ListRouteTables][google.cloud.networkconnectivity.v1.HubService.ListRouteTables]
/// method.
///
/// [google.cloud.networkconnectivity.v1.HubService.ListRouteTables]: crate::client::HubService::list_route_tables
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListRouteTablesResponse {
    /// The requested route tables.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub route_tables: std::vec::Vec<crate::model::RouteTable>,

    /// The token for the next page of the response. To see more results,
    /// use this value as the page_token for your next request. If this value
    /// is empty, there are no more results.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub next_page_token: std::string::String,

    /// Hubs that could not be reached.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub unreachable: std::vec::Vec<std::string::String>,
}

impl ListRouteTablesResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [next_page_token][crate::model::ListRouteTablesResponse::next_page_token].
    pub fn set_next_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.next_page_token = v.into();
        self
    }

    /// Sets the value of [route_tables][crate::model::ListRouteTablesResponse::route_tables].
    pub fn set_route_tables<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::RouteTable>,
    {
        use std::iter::Iterator;
        self.route_tables = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [unreachable][crate::model::ListRouteTablesResponse::unreachable].
    pub fn set_unreachable<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.unreachable = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for ListRouteTablesResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.ListRouteTablesResponse"
    }
}

#[cfg(feature = "unstable-stream")]
impl gax::paginator::PageableResponse for ListRouteTablesResponse {
    type PageItem = crate::model::RouteTable;

    fn items(self) -> std::vec::Vec<Self::PageItem> {
        self.route_tables
    }

    fn next_page_token(&self) -> std::string::String {
        gax::paginator::extract_token(&self.next_page_token)
    }
}

/// Request for
/// [HubService.ListGroups][google.cloud.networkconnectivity.v1.HubService.ListGroups]
/// method.
///
/// [google.cloud.networkconnectivity.v1.HubService.ListGroups]: crate::client::HubService::list_groups
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListGroupsRequest {
    /// Required. The parent resource's name.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub parent: std::string::String,

    /// The maximum number of results to return per page.
    pub page_size: i32,

    /// The page token.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub page_token: std::string::String,

    /// An expression that filters the list of results.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub filter: std::string::String,

    /// Sort the results by a certain order.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub order_by: std::string::String,
}

impl ListGroupsRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::ListGroupsRequest::parent].
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [page_size][crate::model::ListGroupsRequest::page_size].
    pub fn set_page_size<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.page_size = v.into();
        self
    }

    /// Sets the value of [page_token][crate::model::ListGroupsRequest::page_token].
    pub fn set_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.page_token = v.into();
        self
    }

    /// Sets the value of [filter][crate::model::ListGroupsRequest::filter].
    pub fn set_filter<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.filter = v.into();
        self
    }

    /// Sets the value of [order_by][crate::model::ListGroupsRequest::order_by].
    pub fn set_order_by<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.order_by = v.into();
        self
    }
}

impl wkt::message::Message for ListGroupsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.ListGroupsRequest"
    }
}

/// Response for
/// [HubService.ListGroups][google.cloud.networkconnectivity.v1.HubService.ListGroups]
/// method.
///
/// [google.cloud.networkconnectivity.v1.HubService.ListGroups]: crate::client::HubService::list_groups
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListGroupsResponse {
    /// The requested groups.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub groups: std::vec::Vec<crate::model::Group>,

    /// The token for the next page of the response. To see more results,
    /// use this value as the page_token for your next request. If this value
    /// is empty, there are no more results.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub next_page_token: std::string::String,

    /// Hubs that could not be reached.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub unreachable: std::vec::Vec<std::string::String>,
}

impl ListGroupsResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [next_page_token][crate::model::ListGroupsResponse::next_page_token].
    pub fn set_next_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.next_page_token = v.into();
        self
    }

    /// Sets the value of [groups][crate::model::ListGroupsResponse::groups].
    pub fn set_groups<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::Group>,
    {
        use std::iter::Iterator;
        self.groups = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [unreachable][crate::model::ListGroupsResponse::unreachable].
    pub fn set_unreachable<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.unreachable = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for ListGroupsResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.ListGroupsResponse"
    }
}

#[cfg(feature = "unstable-stream")]
impl gax::paginator::PageableResponse for ListGroupsResponse {
    type PageItem = crate::model::Group;

    fn items(self) -> std::vec::Vec<Self::PageItem> {
        self.groups
    }

    fn next_page_token(&self) -> std::string::String {
        gax::paginator::extract_token(&self.next_page_token)
    }
}

/// A collection of Cloud VPN tunnel resources. These resources should be
/// redundant HA VPN tunnels that all advertise the same prefixes to Google
/// Cloud. Alternatively, in a passive/active configuration, all tunnels
/// should be capable of advertising the same prefixes.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct LinkedVpnTunnels {
    /// The URIs of linked VPN tunnel resources.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub uris: std::vec::Vec<std::string::String>,

    /// A value that controls whether site-to-site data transfer is enabled for
    /// these resources. Data transfer is available only in [supported
    /// locations](https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/locations).
    pub site_to_site_data_transfer: bool,

    /// Output only. The VPC network where these VPN tunnels are located.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub vpc_network: std::string::String,

    /// Optional. IP ranges allowed to be included during import from hub (does not
    /// control transit connectivity). The only allowed value for now is
    /// "ALL_IPV4_RANGES".
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub include_import_ranges: std::vec::Vec<std::string::String>,
}

impl LinkedVpnTunnels {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [site_to_site_data_transfer][crate::model::LinkedVpnTunnels::site_to_site_data_transfer].
    pub fn set_site_to_site_data_transfer<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.site_to_site_data_transfer = v.into();
        self
    }

    /// Sets the value of [vpc_network][crate::model::LinkedVpnTunnels::vpc_network].
    pub fn set_vpc_network<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.vpc_network = v.into();
        self
    }

    /// Sets the value of [uris][crate::model::LinkedVpnTunnels::uris].
    pub fn set_uris<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.uris = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [include_import_ranges][crate::model::LinkedVpnTunnels::include_import_ranges].
    pub fn set_include_import_ranges<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.include_import_ranges = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for LinkedVpnTunnels {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.LinkedVpnTunnels"
    }
}

/// A collection of VLAN attachment resources. These resources should
/// be redundant attachments that all advertise the same prefixes to Google
/// Cloud. Alternatively, in active/passive configurations, all attachments
/// should be capable of advertising the same prefixes.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct LinkedInterconnectAttachments {
    /// The URIs of linked interconnect attachment resources
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub uris: std::vec::Vec<std::string::String>,

    /// A value that controls whether site-to-site data transfer is enabled for
    /// these resources. Data transfer is available only in [supported
    /// locations](https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/locations).
    pub site_to_site_data_transfer: bool,

    /// Output only. The VPC network where these VLAN attachments are located.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub vpc_network: std::string::String,

    /// Optional. IP ranges allowed to be included during import from hub (does not
    /// control transit connectivity). The only allowed value for now is
    /// "ALL_IPV4_RANGES".
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub include_import_ranges: std::vec::Vec<std::string::String>,
}

impl LinkedInterconnectAttachments {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [site_to_site_data_transfer][crate::model::LinkedInterconnectAttachments::site_to_site_data_transfer].
    pub fn set_site_to_site_data_transfer<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.site_to_site_data_transfer = v.into();
        self
    }

    /// Sets the value of [vpc_network][crate::model::LinkedInterconnectAttachments::vpc_network].
    pub fn set_vpc_network<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.vpc_network = v.into();
        self
    }

    /// Sets the value of [uris][crate::model::LinkedInterconnectAttachments::uris].
    pub fn set_uris<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.uris = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [include_import_ranges][crate::model::LinkedInterconnectAttachments::include_import_ranges].
    pub fn set_include_import_ranges<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.include_import_ranges = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for LinkedInterconnectAttachments {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.LinkedInterconnectAttachments"
    }
}

/// A collection of router appliance instances. If you configure multiple router
/// appliance instances to receive data from the same set of sites outside of
/// Google Cloud, we recommend that you associate those instances with the same
/// spoke.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct LinkedRouterApplianceInstances {
    /// The list of router appliance instances.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub instances: std::vec::Vec<crate::model::RouterApplianceInstance>,

    /// A value that controls whether site-to-site data transfer is enabled for
    /// these resources. Data transfer is available only in [supported
    /// locations](https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/locations).
    pub site_to_site_data_transfer: bool,

    /// Output only. The VPC network where these router appliance instances are
    /// located.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub vpc_network: std::string::String,

    /// Optional. IP ranges allowed to be included during import from hub (does not
    /// control transit connectivity). The only allowed value for now is
    /// "ALL_IPV4_RANGES".
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub include_import_ranges: std::vec::Vec<std::string::String>,
}

impl LinkedRouterApplianceInstances {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [site_to_site_data_transfer][crate::model::LinkedRouterApplianceInstances::site_to_site_data_transfer].
    pub fn set_site_to_site_data_transfer<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.site_to_site_data_transfer = v.into();
        self
    }

    /// Sets the value of [vpc_network][crate::model::LinkedRouterApplianceInstances::vpc_network].
    pub fn set_vpc_network<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.vpc_network = v.into();
        self
    }

    /// Sets the value of [instances][crate::model::LinkedRouterApplianceInstances::instances].
    pub fn set_instances<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::RouterApplianceInstance>,
    {
        use std::iter::Iterator;
        self.instances = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [include_import_ranges][crate::model::LinkedRouterApplianceInstances::include_import_ranges].
    pub fn set_include_import_ranges<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.include_import_ranges = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for LinkedRouterApplianceInstances {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.LinkedRouterApplianceInstances"
    }
}

/// An existing VPC network.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct LinkedVpcNetwork {
    /// Required. The URI of the VPC network resource.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub uri: std::string::String,

    /// Optional. IP ranges encompassing the subnets to be excluded from peering.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub exclude_export_ranges: std::vec::Vec<std::string::String>,

    /// Optional. IP ranges allowed to be included from peering.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub include_export_ranges: std::vec::Vec<std::string::String>,

    /// Output only. The list of Producer VPC spokes that this VPC spoke is a
    /// service consumer VPC spoke for. These producer VPCs are connected through
    /// VPC peering to this spoke's backing VPC network.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub producer_vpc_spokes: std::vec::Vec<std::string::String>,
}

impl LinkedVpcNetwork {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [uri][crate::model::LinkedVpcNetwork::uri].
    pub fn set_uri<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.uri = v.into();
        self
    }

    /// Sets the value of [exclude_export_ranges][crate::model::LinkedVpcNetwork::exclude_export_ranges].
    pub fn set_exclude_export_ranges<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.exclude_export_ranges = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [include_export_ranges][crate::model::LinkedVpcNetwork::include_export_ranges].
    pub fn set_include_export_ranges<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.include_export_ranges = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [producer_vpc_spokes][crate::model::LinkedVpcNetwork::producer_vpc_spokes].
    pub fn set_producer_vpc_spokes<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.producer_vpc_spokes = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for LinkedVpcNetwork {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.LinkedVpcNetwork"
    }
}

#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct LinkedProducerVpcNetwork {
    /// Immutable. The URI of the Service Consumer VPC that the Producer VPC is
    /// peered with.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub network: std::string::String,

    /// Output only. The Service Consumer Network spoke.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub service_consumer_vpc_spoke: std::string::String,

    /// Immutable. The name of the VPC peering between the Service Consumer VPC and
    /// the Producer VPC (defined in the Tenant project) which is added to the NCC
    /// hub. This peering must be in ACTIVE state.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub peering: std::string::String,

    /// Output only. The URI of the Producer VPC.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub producer_network: std::string::String,

    /// Optional. IP ranges encompassing the subnets to be excluded from peering.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub exclude_export_ranges: std::vec::Vec<std::string::String>,

    /// Optional. IP ranges allowed to be included from peering.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub include_export_ranges: std::vec::Vec<std::string::String>,
}

impl LinkedProducerVpcNetwork {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [network][crate::model::LinkedProducerVpcNetwork::network].
    pub fn set_network<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.network = v.into();
        self
    }

    /// Sets the value of [service_consumer_vpc_spoke][crate::model::LinkedProducerVpcNetwork::service_consumer_vpc_spoke].
    pub fn set_service_consumer_vpc_spoke<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.service_consumer_vpc_spoke = v.into();
        self
    }

    /// Sets the value of [peering][crate::model::LinkedProducerVpcNetwork::peering].
    pub fn set_peering<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.peering = v.into();
        self
    }

    /// Sets the value of [producer_network][crate::model::LinkedProducerVpcNetwork::producer_network].
    pub fn set_producer_network<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.producer_network = v.into();
        self
    }

    /// Sets the value of [exclude_export_ranges][crate::model::LinkedProducerVpcNetwork::exclude_export_ranges].
    pub fn set_exclude_export_ranges<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.exclude_export_ranges = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [include_export_ranges][crate::model::LinkedProducerVpcNetwork::include_export_ranges].
    pub fn set_include_export_ranges<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.include_export_ranges = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for LinkedProducerVpcNetwork {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.LinkedProducerVpcNetwork"
    }
}

/// A router appliance instance is a Compute Engine virtual machine (VM) instance
/// that acts as a BGP speaker. A router appliance instance is specified by the
/// URI of the VM and the internal IP address of one of the VM's network
/// interfaces.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct RouterApplianceInstance {
    /// The URI of the VM.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub virtual_machine: std::string::String,

    /// The IP address on the VM to use for peering.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub ip_address: std::string::String,
}

impl RouterApplianceInstance {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [virtual_machine][crate::model::RouterApplianceInstance::virtual_machine].
    pub fn set_virtual_machine<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.virtual_machine = v.into();
        self
    }

    /// Sets the value of [ip_address][crate::model::RouterApplianceInstance::ip_address].
    pub fn set_ip_address<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.ip_address = v.into();
        self
    }
}

impl wkt::message::Message for RouterApplianceInstance {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.RouterApplianceInstance"
    }
}

/// Metadata about locations
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct LocationMetadata {
    /// List of supported features
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub location_features: std::vec::Vec<crate::model::LocationFeature>,
}

impl LocationMetadata {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [location_features][crate::model::LocationMetadata::location_features].
    pub fn set_location_features<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::LocationFeature>,
    {
        use std::iter::Iterator;
        self.location_features = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for LocationMetadata {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.LocationMetadata"
    }
}

#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct NextHopVpcNetwork {
    /// The URI of the VPC network resource
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub uri: std::string::String,
}

impl NextHopVpcNetwork {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [uri][crate::model::NextHopVpcNetwork::uri].
    pub fn set_uri<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.uri = v.into();
        self
    }
}

impl wkt::message::Message for NextHopVpcNetwork {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.NextHopVpcNetwork"
    }
}

/// A route next hop that leads to a VPN tunnel resource.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct NextHopVPNTunnel {
    /// The URI of the VPN tunnel resource.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub uri: std::string::String,

    /// The VPC network where this VPN tunnel is located.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub vpc_network: std::string::String,

    /// Indicates whether site-to-site data transfer is allowed for this VPN tunnel
    /// resource. Data transfer is available only in [supported
    /// locations](https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/locations).
    pub site_to_site_data_transfer: bool,
}

impl NextHopVPNTunnel {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [uri][crate::model::NextHopVPNTunnel::uri].
    pub fn set_uri<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.uri = v.into();
        self
    }

    /// Sets the value of [vpc_network][crate::model::NextHopVPNTunnel::vpc_network].
    pub fn set_vpc_network<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.vpc_network = v.into();
        self
    }

    /// Sets the value of [site_to_site_data_transfer][crate::model::NextHopVPNTunnel::site_to_site_data_transfer].
    pub fn set_site_to_site_data_transfer<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.site_to_site_data_transfer = v.into();
        self
    }
}

impl wkt::message::Message for NextHopVPNTunnel {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.NextHopVPNTunnel"
    }
}

/// A route next hop that leads to a Router appliance instance.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct NextHopRouterApplianceInstance {
    /// The URI of the Router appliance instance.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub uri: std::string::String,

    /// The VPC network where this VM is located.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub vpc_network: std::string::String,

    /// Indicates whether site-to-site data transfer is allowed for this Router
    /// appliance instance resource. Data transfer is available only in [supported
    /// locations](https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/locations).
    pub site_to_site_data_transfer: bool,
}

impl NextHopRouterApplianceInstance {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [uri][crate::model::NextHopRouterApplianceInstance::uri].
    pub fn set_uri<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.uri = v.into();
        self
    }

    /// Sets the value of [vpc_network][crate::model::NextHopRouterApplianceInstance::vpc_network].
    pub fn set_vpc_network<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.vpc_network = v.into();
        self
    }

    /// Sets the value of [site_to_site_data_transfer][crate::model::NextHopRouterApplianceInstance::site_to_site_data_transfer].
    pub fn set_site_to_site_data_transfer<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.site_to_site_data_transfer = v.into();
        self
    }
}

impl wkt::message::Message for NextHopRouterApplianceInstance {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.NextHopRouterApplianceInstance"
    }
}

/// A route next hop that leads to an interconnect attachment resource.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct NextHopInterconnectAttachment {
    /// The URI of the interconnect attachment resource.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub uri: std::string::String,

    /// The VPC network where this interconnect attachment is located.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub vpc_network: std::string::String,

    /// Indicates whether site-to-site data transfer is allowed for this
    /// interconnect attachment resource. Data transfer is available only in
    /// [supported
    /// locations](https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/locations).
    pub site_to_site_data_transfer: bool,
}

impl NextHopInterconnectAttachment {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [uri][crate::model::NextHopInterconnectAttachment::uri].
    pub fn set_uri<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.uri = v.into();
        self
    }

    /// Sets the value of [vpc_network][crate::model::NextHopInterconnectAttachment::vpc_network].
    pub fn set_vpc_network<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.vpc_network = v.into();
        self
    }

    /// Sets the value of [site_to_site_data_transfer][crate::model::NextHopInterconnectAttachment::site_to_site_data_transfer].
    pub fn set_site_to_site_data_transfer<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.site_to_site_data_transfer = v.into();
        self
    }
}

impl wkt::message::Message for NextHopInterconnectAttachment {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.NextHopInterconnectAttachment"
    }
}

/// Summarizes information about the spokes associated with a hub.
/// The summary includes a count of spokes according to type
/// and according to state. If any spokes are inactive,
/// the summary also lists the reasons they are inactive,
/// including a count for each reason.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct SpokeSummary {
    /// Output only. Counts the number of spokes of each type that are
    /// associated with a specific hub.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub spoke_type_counts: std::vec::Vec<crate::model::spoke_summary::SpokeTypeCount>,

    /// Output only. Counts the number of spokes that are in each state
    /// and associated with a given hub.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub spoke_state_counts: std::vec::Vec<crate::model::spoke_summary::SpokeStateCount>,

    /// Output only. Counts the number of spokes that are inactive for each
    /// possible reason and associated with a given hub.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub spoke_state_reason_counts:
        std::vec::Vec<crate::model::spoke_summary::SpokeStateReasonCount>,
}

impl SpokeSummary {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [spoke_type_counts][crate::model::SpokeSummary::spoke_type_counts].
    pub fn set_spoke_type_counts<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::spoke_summary::SpokeTypeCount>,
    {
        use std::iter::Iterator;
        self.spoke_type_counts = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [spoke_state_counts][crate::model::SpokeSummary::spoke_state_counts].
    pub fn set_spoke_state_counts<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::spoke_summary::SpokeStateCount>,
    {
        use std::iter::Iterator;
        self.spoke_state_counts = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [spoke_state_reason_counts][crate::model::SpokeSummary::spoke_state_reason_counts].
    pub fn set_spoke_state_reason_counts<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::spoke_summary::SpokeStateReasonCount>,
    {
        use std::iter::Iterator;
        self.spoke_state_reason_counts = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for SpokeSummary {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.SpokeSummary"
    }
}

/// Defines additional types related to SpokeSummary
pub mod spoke_summary {
    #[allow(unused_imports)]
    use super::*;

    /// The number of spokes of a given type that are associated
    /// with a specific hub. The type indicates what kind of
    /// resource is associated with the spoke.
    #[serde_with::serde_as]
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    #[serde(default, rename_all = "camelCase")]
    #[non_exhaustive]
    pub struct SpokeTypeCount {
        /// Output only. The type of the spokes.
        pub spoke_type: crate::model::SpokeType,

        /// Output only. The total number of spokes of this type that are
        /// associated with the hub.
        #[serde_as(as = "serde_with::DisplayFromStr")]
        pub count: i64,
    }

    impl SpokeTypeCount {
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [spoke_type][crate::model::spoke_summary::SpokeTypeCount::spoke_type].
        pub fn set_spoke_type<T: std::convert::Into<crate::model::SpokeType>>(
            mut self,
            v: T,
        ) -> Self {
            self.spoke_type = v.into();
            self
        }

        /// Sets the value of [count][crate::model::spoke_summary::SpokeTypeCount::count].
        pub fn set_count<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
            self.count = v.into();
            self
        }
    }

    impl wkt::message::Message for SpokeTypeCount {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.networkconnectivity.v1.SpokeSummary.SpokeTypeCount"
        }
    }

    /// The number of spokes that are in a particular state
    /// and associated with a given hub.
    #[serde_with::serde_as]
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    #[serde(default, rename_all = "camelCase")]
    #[non_exhaustive]
    pub struct SpokeStateCount {
        /// Output only. The state of the spokes.
        pub state: crate::model::State,

        /// Output only. The total number of spokes that are in this state
        /// and associated with a given hub.
        #[serde_as(as = "serde_with::DisplayFromStr")]
        pub count: i64,
    }

    impl SpokeStateCount {
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [state][crate::model::spoke_summary::SpokeStateCount::state].
        pub fn set_state<T: std::convert::Into<crate::model::State>>(mut self, v: T) -> Self {
            self.state = v.into();
            self
        }

        /// Sets the value of [count][crate::model::spoke_summary::SpokeStateCount::count].
        pub fn set_count<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
            self.count = v.into();
            self
        }
    }

    impl wkt::message::Message for SpokeStateCount {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.networkconnectivity.v1.SpokeSummary.SpokeStateCount"
        }
    }

    /// The number of spokes in the hub that are inactive for this reason.
    #[serde_with::serde_as]
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    #[serde(default, rename_all = "camelCase")]
    #[non_exhaustive]
    pub struct SpokeStateReasonCount {
        /// Output only. The reason that a spoke is inactive.
        pub state_reason_code: crate::model::spoke::state_reason::Code,

        /// Output only. The total number of spokes that are inactive for a
        /// particular reason and associated with a given hub.
        #[serde_as(as = "serde_with::DisplayFromStr")]
        pub count: i64,
    }

    impl SpokeStateReasonCount {
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [state_reason_code][crate::model::spoke_summary::SpokeStateReasonCount::state_reason_code].
        pub fn set_state_reason_code<
            T: std::convert::Into<crate::model::spoke::state_reason::Code>,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.state_reason_code = v.into();
            self
        }

        /// Sets the value of [count][crate::model::spoke_summary::SpokeStateReasonCount::count].
        pub fn set_count<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
            self.count = v.into();
            self
        }
    }

    impl wkt::message::Message for SpokeStateReasonCount {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.networkconnectivity.v1.SpokeSummary.SpokeStateReasonCount"
        }
    }
}

/// The request for
/// [HubService.GetGroup][google.cloud.networkconnectivity.v1.HubService.GetGroup].
///
/// [google.cloud.networkconnectivity.v1.HubService.GetGroup]: crate::client::HubService::get_group
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct GetGroupRequest {
    /// Required. The name of the route table resource.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,
}

impl GetGroupRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::GetGroupRequest::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for GetGroupRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.GetGroupRequest"
    }
}

/// Request for
/// [HubService.UpdateGroup][google.cloud.networkconnectivity.v1.HubService.UpdateGroup]
/// method.
///
/// [google.cloud.networkconnectivity.v1.HubService.UpdateGroup]: crate::client::HubService::update_group
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct UpdateGroupRequest {
    /// Optional. In the case of an update to an existing group, field mask is used
    /// to specify the fields to be overwritten. The fields specified in the
    /// update_mask are relative to the resource, not the full request. A field is
    /// overwritten if it is in the mask. If the user does not provide a mask, then
    /// all fields are overwritten.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub update_mask: std::option::Option<wkt::FieldMask>,

    /// Required. The state that the group should be in after the update.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub group: std::option::Option<crate::model::Group>,

    /// Optional. A request ID to identify requests. Specify a unique request ID so
    /// that if you must retry your request, the server knows to ignore the request
    /// if it has already been completed. The server guarantees that a request
    /// doesn't result in creation of duplicate commitments for at least 60
    /// minutes.
    ///
    /// For example, consider a situation where you make an initial request and
    /// the request times out. If you make the request again with the same request
    /// ID, the server can check to see whether the original operation
    /// was received. If it was, the server ignores the second request. This
    /// behavior prevents clients from mistakenly creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID, with the exception that zero UUID is
    /// not supported (00000000-0000-0000-0000-000000000000).
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub request_id: std::string::String,
}

impl UpdateGroupRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [update_mask][crate::model::UpdateGroupRequest::update_mask].
    pub fn set_update_mask<T: std::convert::Into<std::option::Option<wkt::FieldMask>>>(
        mut self,
        v: T,
    ) -> Self {
        self.update_mask = v.into();
        self
    }

    /// Sets the value of [group][crate::model::UpdateGroupRequest::group].
    pub fn set_group<T: std::convert::Into<std::option::Option<crate::model::Group>>>(
        mut self,
        v: T,
    ) -> Self {
        self.group = v.into();
        self
    }

    /// Sets the value of [request_id][crate::model::UpdateGroupRequest::request_id].
    pub fn set_request_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.request_id = v.into();
        self
    }
}

impl wkt::message::Message for UpdateGroupRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.UpdateGroupRequest"
    }
}

/// Policy Based Routes (PBR) are more powerful routes that allows GCP customers
/// to route their L4 network traffic based on not just destination IP, but also
/// source IP, protocol and more. A PBR always take precedence when it conflicts
/// with other types of routes.
/// Next id: 22
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct PolicyBasedRoute {
    /// Immutable. A unique name of the resource in the form of
    /// `projects/{project_number}/locations/global/PolicyBasedRoutes/{policy_based_route_id}`
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    /// Output only. Time when the PolicyBasedRoute was created.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Time when the PolicyBasedRoute was updated.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// User-defined labels.
    #[serde(skip_serializing_if = "std::collections::HashMap::is_empty")]
    pub labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// Optional. An optional description of this resource. Provide this field when
    /// you create the resource.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub description: std::string::String,

    /// Required. Fully-qualified URL of the network that this route applies to.
    /// e.g. projects/my-project/global/networks/my-network.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub network: std::string::String,

    /// Required. The filter to match L4 traffic.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub filter: std::option::Option<crate::model::policy_based_route::Filter>,

    /// Optional. The priority of this policy based route. Priority is used to
    /// break ties in cases where there are more than one matching policy based
    /// routes found. In cases where multiple policy based routes are matched, the
    /// one with the lowest-numbered priority value wins. The default value is
    /// 1000. The priority value must be from 1 to 65535, inclusive.
    pub priority: i32,

    /// Output only. If potential misconfigurations are detected for this route,
    /// this field will be populated with warning messages.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub warnings: std::vec::Vec<crate::model::policy_based_route::Warnings>,

    /// Output only. Server-defined fully-qualified URL for this resource.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub self_link: std::string::String,

    /// Output only. Type of this resource. Always
    /// networkconnectivity#policyBasedRoute for Policy Based Route resources.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub kind: std::string::String,

    /// Target specifies network endpoints to which this policy based route applies
    /// to. If none of the target is specified, the PBR will be installed on all
    /// network endpoints (e.g. VMs, VPNs, and Interconnects) in the VPC.
    #[serde(flatten, skip_serializing_if = "std::option::Option::is_none")]
    pub target: std::option::Option<crate::model::policy_based_route::Target>,

    #[serde(flatten, skip_serializing_if = "std::option::Option::is_none")]
    pub next_hop: std::option::Option<crate::model::policy_based_route::NextHop>,
}

impl PolicyBasedRoute {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::PolicyBasedRoute::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [create_time][crate::model::PolicyBasedRoute::create_time].
    pub fn set_create_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.create_time = v.into();
        self
    }

    /// Sets the value of [update_time][crate::model::PolicyBasedRoute::update_time].
    pub fn set_update_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.update_time = v.into();
        self
    }

    /// Sets the value of [description][crate::model::PolicyBasedRoute::description].
    pub fn set_description<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.description = v.into();
        self
    }

    /// Sets the value of [network][crate::model::PolicyBasedRoute::network].
    pub fn set_network<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.network = v.into();
        self
    }

    /// Sets the value of [filter][crate::model::PolicyBasedRoute::filter].
    pub fn set_filter<
        T: std::convert::Into<std::option::Option<crate::model::policy_based_route::Filter>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.filter = v.into();
        self
    }

    /// Sets the value of [priority][crate::model::PolicyBasedRoute::priority].
    pub fn set_priority<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.priority = v.into();
        self
    }

    /// Sets the value of [self_link][crate::model::PolicyBasedRoute::self_link].
    pub fn set_self_link<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.self_link = v.into();
        self
    }

    /// Sets the value of [kind][crate::model::PolicyBasedRoute::kind].
    pub fn set_kind<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.kind = v.into();
        self
    }

    /// Sets the value of [warnings][crate::model::PolicyBasedRoute::warnings].
    pub fn set_warnings<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::policy_based_route::Warnings>,
    {
        use std::iter::Iterator;
        self.warnings = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [labels][crate::model::PolicyBasedRoute::labels].
    pub fn set_labels<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.labels = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

    /// Sets the value of `target`.
    pub fn set_target<
        T: std::convert::Into<std::option::Option<crate::model::policy_based_route::Target>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.target = v.into();
        self
    }

    /// The value of [target][crate::model::PolicyBasedRoute::target]
    /// if it holds a `VirtualMachine`, `None` if the field is not set or
    /// holds a different branch.
    pub fn get_virtual_machine(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::policy_based_route::VirtualMachine>>
    {
        #[allow(unreachable_patterns)]
        self.target.as_ref().and_then(|v| match v {
            crate::model::policy_based_route::Target::VirtualMachine(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// The value of [target][crate::model::PolicyBasedRoute::target]
    /// if it holds a `InterconnectAttachment`, `None` if the field is not set or
    /// holds a different branch.
    pub fn get_interconnect_attachment(
        &self,
    ) -> std::option::Option<
        &std::boxed::Box<crate::model::policy_based_route::InterconnectAttachment>,
    > {
        #[allow(unreachable_patterns)]
        self.target.as_ref().and_then(|v| match v {
            crate::model::policy_based_route::Target::InterconnectAttachment(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [target][crate::model::PolicyBasedRoute::target]
    /// to hold a `VirtualMachine`.
    ///
    /// Note that all the setters affecting `target` are
    /// mutually exclusive.
    pub fn set_virtual_machine<
        T: std::convert::Into<std::boxed::Box<crate::model::policy_based_route::VirtualMachine>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.target = std::option::Option::Some(
            crate::model::policy_based_route::Target::VirtualMachine(v.into()),
        );
        self
    }

    /// Sets the value of [target][crate::model::PolicyBasedRoute::target]
    /// to hold a `InterconnectAttachment`.
    ///
    /// Note that all the setters affecting `target` are
    /// mutually exclusive.
    pub fn set_interconnect_attachment<
        T: std::convert::Into<
            std::boxed::Box<crate::model::policy_based_route::InterconnectAttachment>,
        >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.target = std::option::Option::Some(
            crate::model::policy_based_route::Target::InterconnectAttachment(v.into()),
        );
        self
    }

    /// Sets the value of `next_hop`.
    pub fn set_next_hop<
        T: std::convert::Into<std::option::Option<crate::model::policy_based_route::NextHop>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.next_hop = v.into();
        self
    }

    /// The value of [next_hop][crate::model::PolicyBasedRoute::next_hop]
    /// if it holds a `NextHopIlbIp`, `None` if the field is not set or
    /// holds a different branch.
    pub fn get_next_hop_ilb_ip(&self) -> std::option::Option<&std::string::String> {
        #[allow(unreachable_patterns)]
        self.next_hop.as_ref().and_then(|v| match v {
            crate::model::policy_based_route::NextHop::NextHopIlbIp(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// The value of [next_hop][crate::model::PolicyBasedRoute::next_hop]
    /// if it holds a `NextHopOtherRoutes`, `None` if the field is not set or
    /// holds a different branch.
    pub fn get_next_hop_other_routes(
        &self,
    ) -> std::option::Option<&crate::model::policy_based_route::OtherRoutes> {
        #[allow(unreachable_patterns)]
        self.next_hop.as_ref().and_then(|v| match v {
            crate::model::policy_based_route::NextHop::NextHopOtherRoutes(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [next_hop][crate::model::PolicyBasedRoute::next_hop]
    /// to hold a `NextHopIlbIp`.
    ///
    /// Note that all the setters affecting `next_hop` are
    /// mutually exclusive.
    pub fn set_next_hop_ilb_ip<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.next_hop = std::option::Option::Some(
            crate::model::policy_based_route::NextHop::NextHopIlbIp(v.into()),
        );
        self
    }

    /// Sets the value of [next_hop][crate::model::PolicyBasedRoute::next_hop]
    /// to hold a `NextHopOtherRoutes`.
    ///
    /// Note that all the setters affecting `next_hop` are
    /// mutually exclusive.
    pub fn set_next_hop_other_routes<
        T: std::convert::Into<crate::model::policy_based_route::OtherRoutes>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.next_hop = std::option::Option::Some(
            crate::model::policy_based_route::NextHop::NextHopOtherRoutes(v.into()),
        );
        self
    }
}

impl wkt::message::Message for PolicyBasedRoute {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.PolicyBasedRoute"
    }
}

/// Defines additional types related to PolicyBasedRoute
pub mod policy_based_route {
    #[allow(unused_imports)]
    use super::*;

    /// VM instances to which this policy based route applies to.
    #[serde_with::serde_as]
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    #[serde(default, rename_all = "camelCase")]
    #[non_exhaustive]
    pub struct VirtualMachine {
        /// Optional. A list of VM instance tags to which this policy based route
        /// applies to. VM instances that have ANY of tags specified here will
        /// install this PBR.
        #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
        pub tags: std::vec::Vec<std::string::String>,
    }

    impl VirtualMachine {
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [tags][crate::model::policy_based_route::VirtualMachine::tags].
        pub fn set_tags<T, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = V>,
            V: std::convert::Into<std::string::String>,
        {
            use std::iter::Iterator;
            self.tags = v.into_iter().map(|i| i.into()).collect();
            self
        }
    }

    impl wkt::message::Message for VirtualMachine {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.networkconnectivity.v1.PolicyBasedRoute.VirtualMachine"
        }
    }

    /// InterconnectAttachment to which this route applies to.
    #[serde_with::serde_as]
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    #[serde(default, rename_all = "camelCase")]
    #[non_exhaustive]
    pub struct InterconnectAttachment {
        /// Optional. Cloud region to install this policy based route on interconnect
        /// attachment. Use `all` to install it on all interconnect attachments.
        #[serde(skip_serializing_if = "std::string::String::is_empty")]
        pub region: std::string::String,
    }

    impl InterconnectAttachment {
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [region][crate::model::policy_based_route::InterconnectAttachment::region].
        pub fn set_region<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.region = v.into();
            self
        }
    }

    impl wkt::message::Message for InterconnectAttachment {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.networkconnectivity.v1.PolicyBasedRoute.InterconnectAttachment"
        }
    }

    /// Filter matches L4 traffic.
    #[serde_with::serde_as]
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    #[serde(default, rename_all = "camelCase")]
    #[non_exhaustive]
    pub struct Filter {
        /// Optional. The IP protocol that this policy based route applies to. Valid
        /// values are 'TCP', 'UDP', and 'ALL'. Default is 'ALL'.
        #[serde(skip_serializing_if = "std::string::String::is_empty")]
        pub ip_protocol: std::string::String,

        /// Optional. The source IP range of outgoing packets that this policy based
        /// route applies to. Default is "0.0.0.0/0" if protocol version is IPv4.
        #[serde(skip_serializing_if = "std::string::String::is_empty")]
        pub src_range: std::string::String,

        /// Optional. The destination IP range of outgoing packets that this policy
        /// based route applies to. Default is "0.0.0.0/0" if protocol version is
        /// IPv4.
        #[serde(skip_serializing_if = "std::string::String::is_empty")]
        pub dest_range: std::string::String,

        /// Required. Internet protocol versions this policy based route applies to.
        /// For this version, only IPV4 is supported.
        pub protocol_version: crate::model::policy_based_route::filter::ProtocolVersion,
    }

    impl Filter {
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [ip_protocol][crate::model::policy_based_route::Filter::ip_protocol].
        pub fn set_ip_protocol<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.ip_protocol = v.into();
            self
        }

        /// Sets the value of [src_range][crate::model::policy_based_route::Filter::src_range].
        pub fn set_src_range<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.src_range = v.into();
            self
        }

        /// Sets the value of [dest_range][crate::model::policy_based_route::Filter::dest_range].
        pub fn set_dest_range<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.dest_range = v.into();
            self
        }

        /// Sets the value of [protocol_version][crate::model::policy_based_route::Filter::protocol_version].
        pub fn set_protocol_version<
            T: std::convert::Into<crate::model::policy_based_route::filter::ProtocolVersion>,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.protocol_version = v.into();
            self
        }
    }

    impl wkt::message::Message for Filter {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.networkconnectivity.v1.PolicyBasedRoute.Filter"
        }
    }

    /// Defines additional types related to Filter
    pub mod filter {
        #[allow(unused_imports)]
        use super::*;

        /// The internet protocol version.
        #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
        pub struct ProtocolVersion(std::borrow::Cow<'static, str>);

        impl ProtocolVersion {
            /// Creates a new ProtocolVersion instance.
            pub const fn new(v: &'static str) -> Self {
                Self(std::borrow::Cow::Borrowed(v))
            }

            /// Gets the enum value.
            pub fn value(&self) -> &str {
                &self.0
            }
        }

        /// Useful constants to work with [ProtocolVersion](ProtocolVersion)
        pub mod protocol_version {
            use super::ProtocolVersion;

            /// Default value.
            pub const PROTOCOL_VERSION_UNSPECIFIED: ProtocolVersion =
                ProtocolVersion::new("PROTOCOL_VERSION_UNSPECIFIED");

            /// The PBR is for IPv4 internet protocol traffic.
            pub const IPV4: ProtocolVersion = ProtocolVersion::new("IPV4");
        }

        impl std::convert::From<std::string::String> for ProtocolVersion {
            fn from(value: std::string::String) -> Self {
                Self(std::borrow::Cow::Owned(value))
            }
        }
    }

    /// Informational warning message.
    #[serde_with::serde_as]
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    #[serde(default, rename_all = "camelCase")]
    #[non_exhaustive]
    pub struct Warnings {
        /// Output only. A warning code, if applicable.
        pub code: crate::model::policy_based_route::warnings::Code,

        /// Output only. Metadata about this warning in key: value format. The key
        /// should provides more detail on the warning being returned. For example,
        /// for warnings where there are no results in a list request for a
        /// particular zone, this key might be scope and the key value might be the
        /// zone name. Other examples might be a key indicating a deprecated resource
        /// and a suggested replacement.
        #[serde(skip_serializing_if = "std::collections::HashMap::is_empty")]
        pub data: std::collections::HashMap<std::string::String, std::string::String>,

        /// Output only. A human-readable description of the warning code.
        #[serde(skip_serializing_if = "std::string::String::is_empty")]
        pub warning_message: std::string::String,
    }

    impl Warnings {
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [code][crate::model::policy_based_route::Warnings::code].
        pub fn set_code<T: std::convert::Into<crate::model::policy_based_route::warnings::Code>>(
            mut self,
            v: T,
        ) -> Self {
            self.code = v.into();
            self
        }

        /// Sets the value of [warning_message][crate::model::policy_based_route::Warnings::warning_message].
        pub fn set_warning_message<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.warning_message = v.into();
            self
        }

        /// Sets the value of [data][crate::model::policy_based_route::Warnings::data].
        pub fn set_data<T, K, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = (K, V)>,
            K: std::convert::Into<std::string::String>,
            V: std::convert::Into<std::string::String>,
        {
            use std::iter::Iterator;
            self.data = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
            self
        }
    }

    impl wkt::message::Message for Warnings {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.networkconnectivity.v1.PolicyBasedRoute.Warnings"
        }
    }

    /// Defines additional types related to Warnings
    pub mod warnings {
        #[allow(unused_imports)]
        use super::*;

        /// Warning code for Policy Based Routing. Expect to add values in the
        /// future.
        #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
        pub struct Code(std::borrow::Cow<'static, str>);

        impl Code {
            /// Creates a new Code instance.
            pub const fn new(v: &'static str) -> Self {
                Self(std::borrow::Cow::Borrowed(v))
            }

            /// Gets the enum value.
            pub fn value(&self) -> &str {
                &self.0
            }
        }

        /// Useful constants to work with [Code](Code)
        pub mod code {
            use super::Code;

            /// Default value.
            pub const WARNING_UNSPECIFIED: Code = Code::new("WARNING_UNSPECIFIED");

            /// The policy based route is not active and functioning. Common causes are
            /// the dependent network was deleted or the resource project was turned
            /// off.
            pub const RESOURCE_NOT_ACTIVE: Code = Code::new("RESOURCE_NOT_ACTIVE");

            /// The policy based route is being modified (e.g. created/deleted) at this
            /// time.
            pub const RESOURCE_BEING_MODIFIED: Code = Code::new("RESOURCE_BEING_MODIFIED");
        }

        impl std::convert::From<std::string::String> for Code {
            fn from(value: std::string::String) -> Self {
                Self(std::borrow::Cow::Owned(value))
            }
        }
    }

    /// The other routing cases.
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    pub struct OtherRoutes(std::borrow::Cow<'static, str>);

    impl OtherRoutes {
        /// Creates a new OtherRoutes instance.
        pub const fn new(v: &'static str) -> Self {
            Self(std::borrow::Cow::Borrowed(v))
        }

        /// Gets the enum value.
        pub fn value(&self) -> &str {
            &self.0
        }
    }

    /// Useful constants to work with [OtherRoutes](OtherRoutes)
    pub mod other_routes {
        use super::OtherRoutes;

        /// Default value.
        pub const OTHER_ROUTES_UNSPECIFIED: OtherRoutes =
            OtherRoutes::new("OTHER_ROUTES_UNSPECIFIED");

        /// Use the routes from the default routing tables (system-generated routes,
        /// custom routes, peering route) to determine the next hop. This will
        /// effectively exclude matching packets being applied on other PBRs with a
        /// lower priority.
        pub const DEFAULT_ROUTING: OtherRoutes = OtherRoutes::new("DEFAULT_ROUTING");
    }

    impl std::convert::From<std::string::String> for OtherRoutes {
        fn from(value: std::string::String) -> Self {
            Self(std::borrow::Cow::Owned(value))
        }
    }

    /// Target specifies network endpoints to which this policy based route applies
    /// to. If none of the target is specified, the PBR will be installed on all
    /// network endpoints (e.g. VMs, VPNs, and Interconnects) in the VPC.
    #[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
    #[serde(rename_all = "camelCase")]
    #[non_exhaustive]
    pub enum Target {
        /// Optional. VM instances to which this policy based route applies to.
        VirtualMachine(std::boxed::Box<crate::model::policy_based_route::VirtualMachine>),
        /// Optional. The interconnect attachments to which this route applies to.
        InterconnectAttachment(
            std::boxed::Box<crate::model::policy_based_route::InterconnectAttachment>,
        ),
    }

    #[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
    #[serde(rename_all = "camelCase")]
    #[non_exhaustive]
    pub enum NextHop {
        /// Optional. The IP of a global access enabled L4 ILB that should be the
        /// next hop to handle matching packets. For this version, only
        /// next_hop_ilb_ip is supported.
        NextHopIlbIp(std::string::String),
        /// Optional. Other routes that will be referenced to determine the next hop
        /// of the packet.
        NextHopOtherRoutes(crate::model::policy_based_route::OtherRoutes),
    }
}

/// Request for [PolicyBasedRouting.ListPolicyBasedRoutes][] method.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListPolicyBasedRoutesRequest {
    /// Required. The parent resource's name.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub parent: std::string::String,

    /// The maximum number of results per page that should be returned.
    pub page_size: i32,

    /// The page token.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub page_token: std::string::String,

    /// A filter expression that filters the results listed in the response.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub filter: std::string::String,

    /// Sort the results by a certain order.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub order_by: std::string::String,
}

impl ListPolicyBasedRoutesRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::ListPolicyBasedRoutesRequest::parent].
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [page_size][crate::model::ListPolicyBasedRoutesRequest::page_size].
    pub fn set_page_size<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.page_size = v.into();
        self
    }

    /// Sets the value of [page_token][crate::model::ListPolicyBasedRoutesRequest::page_token].
    pub fn set_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.page_token = v.into();
        self
    }

    /// Sets the value of [filter][crate::model::ListPolicyBasedRoutesRequest::filter].
    pub fn set_filter<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.filter = v.into();
        self
    }

    /// Sets the value of [order_by][crate::model::ListPolicyBasedRoutesRequest::order_by].
    pub fn set_order_by<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.order_by = v.into();
        self
    }
}

impl wkt::message::Message for ListPolicyBasedRoutesRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.ListPolicyBasedRoutesRequest"
    }
}

/// Response for [PolicyBasedRouting.ListPolicyBasedRoutes][] method.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListPolicyBasedRoutesResponse {
    /// Policy based routes to be returned.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub policy_based_routes: std::vec::Vec<crate::model::PolicyBasedRoute>,

    /// The next pagination token in the List response. It should be used as
    /// page_token for the following request. An empty value means no more result.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub next_page_token: std::string::String,

    /// Locations that could not be reached.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub unreachable: std::vec::Vec<std::string::String>,
}

impl ListPolicyBasedRoutesResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [next_page_token][crate::model::ListPolicyBasedRoutesResponse::next_page_token].
    pub fn set_next_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.next_page_token = v.into();
        self
    }

    /// Sets the value of [policy_based_routes][crate::model::ListPolicyBasedRoutesResponse::policy_based_routes].
    pub fn set_policy_based_routes<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::PolicyBasedRoute>,
    {
        use std::iter::Iterator;
        self.policy_based_routes = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [unreachable][crate::model::ListPolicyBasedRoutesResponse::unreachable].
    pub fn set_unreachable<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.unreachable = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for ListPolicyBasedRoutesResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.ListPolicyBasedRoutesResponse"
    }
}

#[cfg(feature = "unstable-stream")]
impl gax::paginator::PageableResponse for ListPolicyBasedRoutesResponse {
    type PageItem = crate::model::PolicyBasedRoute;

    fn items(self) -> std::vec::Vec<Self::PageItem> {
        self.policy_based_routes
    }

    fn next_page_token(&self) -> std::string::String {
        gax::paginator::extract_token(&self.next_page_token)
    }
}

/// Request for [PolicyBasedRouting.GetPolicyBasedRoute][] method.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct GetPolicyBasedRouteRequest {
    /// Required. Name of the PolicyBasedRoute resource to get.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,
}

impl GetPolicyBasedRouteRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::GetPolicyBasedRouteRequest::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for GetPolicyBasedRouteRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.GetPolicyBasedRouteRequest"
    }
}

/// Request for [PolicyBasedRouting.CreatePolicyBasedRoute][] method.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct CreatePolicyBasedRouteRequest {
    /// Required. The parent resource's name of the PolicyBasedRoute.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub parent: std::string::String,

    /// Required. Unique id for the Policy Based Route to create.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub policy_based_route_id: std::string::String,

    /// Required. Initial values for a new Policy Based Route.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub policy_based_route: std::option::Option<crate::model::PolicyBasedRoute>,

    /// Optional. An optional request ID to identify requests. Specify a unique
    /// request ID so that if you must retry your request, the server will know to
    /// ignore the request if it has already been completed. The server will
    /// guarantee that for at least 60 minutes since the first request.
    ///
    /// For example, consider a situation where you make an initial request and
    /// the request times out. If you make the request again with the same request
    /// ID, the server can check if original operation with the same request ID
    /// was received, and if so, will ignore the second request. This prevents
    /// clients from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported (00000000-0000-0000-0000-000000000000).
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub request_id: std::string::String,
}

impl CreatePolicyBasedRouteRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::CreatePolicyBasedRouteRequest::parent].
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [policy_based_route_id][crate::model::CreatePolicyBasedRouteRequest::policy_based_route_id].
    pub fn set_policy_based_route_id<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.policy_based_route_id = v.into();
        self
    }

    /// Sets the value of [policy_based_route][crate::model::CreatePolicyBasedRouteRequest::policy_based_route].
    pub fn set_policy_based_route<
        T: std::convert::Into<std::option::Option<crate::model::PolicyBasedRoute>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.policy_based_route = v.into();
        self
    }

    /// Sets the value of [request_id][crate::model::CreatePolicyBasedRouteRequest::request_id].
    pub fn set_request_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.request_id = v.into();
        self
    }
}

impl wkt::message::Message for CreatePolicyBasedRouteRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.CreatePolicyBasedRouteRequest"
    }
}

/// Request for [PolicyBasedRouting.DeletePolicyBasedRoute][] method.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct DeletePolicyBasedRouteRequest {
    /// Required. Name of the PolicyBasedRoute resource to delete.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    /// Optional. An optional request ID to identify requests. Specify a unique
    /// request ID so that if you must retry your request, the server will know to
    /// ignore the request if it has already been completed. The server will
    /// guarantee that for at least 60 minutes after the first request.
    ///
    /// For example, consider a situation where you make an initial request and
    /// the request times out. If you make the request again with the same request
    /// ID, the server can check if original operation with the same request ID
    /// was received, and if so, will ignore the second request. This prevents
    /// clients from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported (00000000-0000-0000-0000-000000000000).
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub request_id: std::string::String,
}

impl DeletePolicyBasedRouteRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::DeletePolicyBasedRouteRequest::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [request_id][crate::model::DeletePolicyBasedRouteRequest::request_id].
    pub fn set_request_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.request_id = v.into();
        self
    }
}

impl wkt::message::Message for DeletePolicyBasedRouteRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.networkconnectivity.v1.DeletePolicyBasedRouteRequest"
    }
}

/// Supported features for a location
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct LocationFeature(std::borrow::Cow<'static, str>);

impl LocationFeature {
    /// Creates a new LocationFeature instance.
    pub const fn new(v: &'static str) -> Self {
        Self(std::borrow::Cow::Borrowed(v))
    }

    /// Gets the enum value.
    pub fn value(&self) -> &str {
        &self.0
    }
}

/// Useful constants to work with [LocationFeature](LocationFeature)
pub mod location_feature {
    use super::LocationFeature;

    /// No publicly supported feature in this location
    pub const LOCATION_FEATURE_UNSPECIFIED: LocationFeature =
        LocationFeature::new("LOCATION_FEATURE_UNSPECIFIED");

    /// Site-to-cloud spokes are supported in this location
    pub const SITE_TO_CLOUD_SPOKES: LocationFeature = LocationFeature::new("SITE_TO_CLOUD_SPOKES");

    /// Site-to-site spokes are supported in this location
    pub const SITE_TO_SITE_SPOKES: LocationFeature = LocationFeature::new("SITE_TO_SITE_SPOKES");
}

impl std::convert::From<std::string::String> for LocationFeature {
    fn from(value: std::string::String) -> Self {
        Self(std::borrow::Cow::Owned(value))
    }
}

/// The route's type
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct RouteType(std::borrow::Cow<'static, str>);

impl RouteType {
    /// Creates a new RouteType instance.
    pub const fn new(v: &'static str) -> Self {
        Self(std::borrow::Cow::Borrowed(v))
    }

    /// Gets the enum value.
    pub fn value(&self) -> &str {
        &self.0
    }
}

/// Useful constants to work with [RouteType](RouteType)
pub mod route_type {
    use super::RouteType;

    /// No route type information specified
    pub const ROUTE_TYPE_UNSPECIFIED: RouteType = RouteType::new("ROUTE_TYPE_UNSPECIFIED");

    /// The route leads to a destination within the primary address range of the
    /// VPC network's subnet.
    pub const VPC_PRIMARY_SUBNET: RouteType = RouteType::new("VPC_PRIMARY_SUBNET");

    /// The route leads to a destination within the secondary address range of the
    /// VPC network's subnet.
    pub const VPC_SECONDARY_SUBNET: RouteType = RouteType::new("VPC_SECONDARY_SUBNET");

    /// The route leads to a destination in a dynamic route. Dynamic routes are
    /// derived from Border Gateway Protocol (BGP) advertisements received from an
    /// NCC hybrid spoke.
    pub const DYNAMIC_ROUTE: RouteType = RouteType::new("DYNAMIC_ROUTE");
}

impl std::convert::From<std::string::String> for RouteType {
    fn from(value: std::string::String) -> Self {
        Self(std::borrow::Cow::Owned(value))
    }
}

/// The State enum represents the lifecycle stage of a Network Connectivity
/// Center resource.
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct State(std::borrow::Cow<'static, str>);

impl State {
    /// Creates a new State instance.
    pub const fn new(v: &'static str) -> Self {
        Self(std::borrow::Cow::Borrowed(v))
    }

    /// Gets the enum value.
    pub fn value(&self) -> &str {
        &self.0
    }
}

/// Useful constants to work with [State](State)
pub mod state {
    use super::State;

    /// No state information available
    pub const STATE_UNSPECIFIED: State = State::new("STATE_UNSPECIFIED");

    /// The resource's create operation is in progress.
    pub const CREATING: State = State::new("CREATING");

    /// The resource is active
    pub const ACTIVE: State = State::new("ACTIVE");

    /// The resource's delete operation is in progress.
    pub const DELETING: State = State::new("DELETING");

    /// The resource's accept operation is in progress.
    pub const ACCEPTING: State = State::new("ACCEPTING");

    /// The resource's reject operation is in progress.
    pub const REJECTING: State = State::new("REJECTING");

    /// The resource's update operation is in progress.
    pub const UPDATING: State = State::new("UPDATING");

    /// The resource is inactive.
    pub const INACTIVE: State = State::new("INACTIVE");

    /// The hub associated with this spoke resource has been deleted.
    /// This state applies to spoke resources only.
    pub const OBSOLETE: State = State::new("OBSOLETE");
}

impl std::convert::From<std::string::String> for State {
    fn from(value: std::string::String) -> Self {
        Self(std::borrow::Cow::Owned(value))
    }
}

/// The SpokeType enum represents the type of spoke. The type
/// reflects the kind of resource that a spoke is associated with.
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct SpokeType(std::borrow::Cow<'static, str>);

impl SpokeType {
    /// Creates a new SpokeType instance.
    pub const fn new(v: &'static str) -> Self {
        Self(std::borrow::Cow::Borrowed(v))
    }

    /// Gets the enum value.
    pub fn value(&self) -> &str {
        &self.0
    }
}

/// Useful constants to work with [SpokeType](SpokeType)
pub mod spoke_type {
    use super::SpokeType;

    /// Unspecified spoke type.
    pub const SPOKE_TYPE_UNSPECIFIED: SpokeType = SpokeType::new("SPOKE_TYPE_UNSPECIFIED");

    /// Spokes associated with VPN tunnels.
    pub const VPN_TUNNEL: SpokeType = SpokeType::new("VPN_TUNNEL");

    /// Spokes associated with VLAN attachments.
    pub const INTERCONNECT_ATTACHMENT: SpokeType = SpokeType::new("INTERCONNECT_ATTACHMENT");

    /// Spokes associated with router appliance instances.
    pub const ROUTER_APPLIANCE: SpokeType = SpokeType::new("ROUTER_APPLIANCE");

    /// Spokes associated with VPC networks.
    pub const VPC_NETWORK: SpokeType = SpokeType::new("VPC_NETWORK");

    /// Spokes that are backed by a producer VPC network.
    pub const PRODUCER_VPC_NETWORK: SpokeType = SpokeType::new("PRODUCER_VPC_NETWORK");
}

impl std::convert::From<std::string::String> for SpokeType {
    fn from(value: std::string::String) -> Self {
        Self(std::borrow::Cow::Owned(value))
    }
}

/// This enum controls the policy mode used in a hub.
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct PolicyMode(std::borrow::Cow<'static, str>);

impl PolicyMode {
    /// Creates a new PolicyMode instance.
    pub const fn new(v: &'static str) -> Self {
        Self(std::borrow::Cow::Borrowed(v))
    }

    /// Gets the enum value.
    pub fn value(&self) -> &str {
        &self.0
    }
}

/// Useful constants to work with [PolicyMode](PolicyMode)
pub mod policy_mode {
    use super::PolicyMode;

    /// Policy mode is unspecified. It defaults to PRESET
    /// with preset_topology = MESH.
    pub const POLICY_MODE_UNSPECIFIED: PolicyMode = PolicyMode::new("POLICY_MODE_UNSPECIFIED");

    /// Hub uses one of the preset topologies.
    pub const PRESET: PolicyMode = PolicyMode::new("PRESET");
}

impl std::convert::From<std::string::String> for PolicyMode {
    fn from(value: std::string::String) -> Self {
        Self(std::borrow::Cow::Owned(value))
    }
}

/// The list of available preset topologies.
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct PresetTopology(std::borrow::Cow<'static, str>);

impl PresetTopology {
    /// Creates a new PresetTopology instance.
    pub const fn new(v: &'static str) -> Self {
        Self(std::borrow::Cow::Borrowed(v))
    }

    /// Gets the enum value.
    pub fn value(&self) -> &str {
        &self.0
    }
}

/// Useful constants to work with [PresetTopology](PresetTopology)
pub mod preset_topology {
    use super::PresetTopology;

    /// Preset topology is unspecified. When policy_mode = PRESET,
    /// it defaults to MESH.
    pub const PRESET_TOPOLOGY_UNSPECIFIED: PresetTopology =
        PresetTopology::new("PRESET_TOPOLOGY_UNSPECIFIED");

    /// Mesh topology is implemented. Group `default` is automatically created.
    /// All spokes in the hub are added to group `default`.
    pub const MESH: PresetTopology = PresetTopology::new("MESH");

    /// Star topology is implemented. Two groups, `center` and `edge`, are
    /// automatically created along with hub creation. Spokes have to join one of
    /// the groups during creation.
    pub const STAR: PresetTopology = PresetTopology::new("STAR");
}

impl std::convert::From<std::string::String> for PresetTopology {
    fn from(value: std::string::String) -> Self {
        Self(std::borrow::Cow::Owned(value))
    }
}