proxmox-api 0.2.0

pub mod iface;
#[derive(Debug, Clone)]
pub struct NetworkClient<T> {
    client: T,
    path: String,
}
impl<T> NetworkClient<T>
where
    T: crate::client::Client,
{
    pub fn new(client: T, parent_path: &str) -> Self {
        Self {
            client,
            path: format!("{}{}", parent_path, "/network"),
        }
    }
}
impl<T> NetworkClient<T>
where
    T: crate::client::Client,
{
    #[doc = "Revert network configuration changes."]
    #[doc = ""]
    #[doc = "Permission check: perm(\"/nodes/{node}\", [\"Sys.Modify\"])"]
    pub async fn delete(&self) -> Result<(), T::Error> {
        let path = self.path.to_string();
        self.client.delete(&path, &()).await
    }
}
impl<T> NetworkClient<T>
where
    T: crate::client::Client,
{
    #[doc = "List available networks"]
    #[doc = ""]
    pub async fn get(&self, params: GetParams) -> Result<Vec<GetOutputItems>, T::Error> {
        let path = self.path.to_string();
        let optional_vec: Option<Vec<GetOutputItems>> = self.client.get(&path, &params).await?;
        Ok(optional_vec.unwrap_or_default())
    }
}
impl<T> NetworkClient<T>
where
    T: crate::client::Client,
{
    #[doc = "Create network device configuration"]
    #[doc = ""]
    #[doc = "Permission check: perm(\"/nodes/{node}\", [\"Sys.Modify\"])"]
    pub async fn post(&self, params: PostParams) -> Result<(), T::Error> {
        let path = self.path.to_string();
        self.client.post(&path, &params).await
    }
}
impl<T> NetworkClient<T>
where
    T: crate::client::Client,
{
    #[doc = "Reload network configuration"]
    #[doc = ""]
    #[doc = "Permission check: perm(\"/nodes/{node}\", [\"Sys.Modify\"])"]
    pub async fn put(&self, params: PutParams) -> Result<String, T::Error> {
        let path = self.path.to_string();
        self.client.put(&path, &params).await
    }
}
impl GetOutputItems {
    pub fn new(iface: IfaceStr, ty: Type2) -> Self {
        Self {
            iface,
            ty,
            active: ::std::default::Default::default(),
            address: ::std::default::Default::default(),
            address6: ::std::default::Default::default(),
            autostart: ::std::default::Default::default(),
            bond_primary: ::std::default::Default::default(),
            bond_mode: ::std::default::Default::default(),
            bond_xmit_hash_policy: ::std::default::Default::default(),
            bridge_access: ::std::default::Default::default(),
            bridge_arp_nd_suppress: ::std::default::Default::default(),
            bridge_learning: ::std::default::Default::default(),
            bridge_multicast_flood: ::std::default::Default::default(),
            bridge_unicast_flood: ::std::default::Default::default(),
            bridge_ports: ::std::default::Default::default(),
            bridge_vids: ::std::default::Default::default(),
            bridge_vlan_aware: ::std::default::Default::default(),
            cidr: ::std::default::Default::default(),
            cidr6: ::std::default::Default::default(),
            comments: ::std::default::Default::default(),
            comments6: ::std::default::Default::default(),
            exists: ::std::default::Default::default(),
            families: ::std::default::Default::default(),
            gateway: ::std::default::Default::default(),
            gateway6: ::std::default::Default::default(),
            link_type: ::std::default::Default::default(),
            method: ::std::default::Default::default(),
            method6: ::std::default::Default::default(),
            mtu: ::std::default::Default::default(),
            netmask: ::std::default::Default::default(),
            netmask6: ::std::default::Default::default(),
            options: ::std::default::Default::default(),
            options6: ::std::default::Default::default(),
            ovs_bonds: ::std::default::Default::default(),
            ovs_bridge: ::std::default::Default::default(),
            ovs_options: ::std::default::Default::default(),
            ovs_ports: ::std::default::Default::default(),
            ovs_tag: ::std::default::Default::default(),
            priority: ::std::default::Default::default(),
            slaves: ::std::default::Default::default(),
            uplink_id: ::std::default::Default::default(),
            vlan_id: ::std::default::Default::default(),
            vlan_protocol: ::std::default::Default::default(),
            vlan_raw_device: ::std::default::Default::default(),
            vxlan_id: ::std::default::Default::default(),
            vxlan_local_tunnelip: ::std::default::Default::default(),
            vxlan_physdev: ::std::default::Default::default(),
            vxlan_svcnodeip: ::std::default::Default::default(),
            additional_properties: ::std::default::Default::default(),
        }
    }
}
#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize)]
pub struct GetOutputItems {
    #[serde(
        serialize_with = "crate::types::serialize_bool_optional",
        deserialize_with = "crate::types::deserialize_bool_optional"
    )]
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Set to true if the interface is active."]
    #[doc = ""]
    pub active: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "IP address."]
    #[doc = ""]
    pub address: Option<::std::net::Ipv4Addr>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "IP address."]
    #[doc = ""]
    pub address6: Option<::std::net::Ipv6Addr>,
    #[serde(
        serialize_with = "crate::types::serialize_bool_optional",
        deserialize_with = "crate::types::deserialize_bool_optional"
    )]
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Automatically start interface on boot."]
    #[doc = ""]
    pub autostart: Option<bool>,
    #[serde(rename = "bond-primary")]
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Specify the primary interface for active-backup bond."]
    #[doc = ""]
    pub bond_primary: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Bonding mode."]
    #[doc = ""]
    pub bond_mode: Option<BondMode>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Selects the transmit hash policy to use for slave selection in balance-xor and 802.3ad modes."]
    #[doc = ""]
    pub bond_xmit_hash_policy: Option<BondXmitHashPolicy>,
    #[serde(rename = "bridge-access")]
    #[serde(
        serialize_with = "crate::types::serialize_int_optional",
        deserialize_with = "crate::types::deserialize_int_optional"
    )]
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "The bridge port access VLAN."]
    #[doc = ""]
    pub bridge_access: Option<i64>,
    #[serde(rename = "bridge-arp-nd-suppress")]
    #[serde(
        serialize_with = "crate::types::serialize_bool_optional",
        deserialize_with = "crate::types::deserialize_bool_optional"
    )]
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Bridge port ARP/ND suppress flag."]
    #[doc = ""]
    pub bridge_arp_nd_suppress: Option<bool>,
    #[serde(rename = "bridge-learning")]
    #[serde(
        serialize_with = "crate::types::serialize_bool_optional",
        deserialize_with = "crate::types::deserialize_bool_optional"
    )]
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Bridge port learning flag."]
    #[doc = ""]
    pub bridge_learning: Option<bool>,
    #[serde(rename = "bridge-multicast-flood")]
    #[serde(
        serialize_with = "crate::types::serialize_bool_optional",
        deserialize_with = "crate::types::deserialize_bool_optional"
    )]
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Bridge port multicast flood flag."]
    #[doc = ""]
    pub bridge_multicast_flood: Option<bool>,
    #[serde(rename = "bridge-unicast-flood")]
    #[serde(
        serialize_with = "crate::types::serialize_bool_optional",
        deserialize_with = "crate::types::deserialize_bool_optional"
    )]
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Bridge port unicast flood flag."]
    #[doc = ""]
    pub bridge_unicast_flood: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Specify the interfaces you want to add to your bridge."]
    #[doc = ""]
    pub bridge_ports: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Specify the allowed VLANs. For example: '2 4 100-200'. Only used if the bridge is VLAN aware."]
    #[doc = ""]
    pub bridge_vids: Option<String>,
    #[serde(
        serialize_with = "crate::types::serialize_bool_optional",
        deserialize_with = "crate::types::deserialize_bool_optional"
    )]
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Enable bridge vlan support."]
    #[doc = ""]
    pub bridge_vlan_aware: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "IPv4 CIDR."]
    #[doc = ""]
    pub cidr: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "IPv6 CIDR."]
    #[doc = ""]
    pub cidr6: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Comments"]
    #[doc = ""]
    pub comments: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Comments"]
    #[doc = ""]
    pub comments6: Option<String>,
    #[serde(
        serialize_with = "crate::types::serialize_bool_optional",
        deserialize_with = "crate::types::deserialize_bool_optional"
    )]
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Set to true if the interface physically exists."]
    #[doc = ""]
    pub exists: Option<bool>,
    #[serde(skip_serializing_if = "::std::vec::Vec::is_empty", default)]
    #[doc = "The network families."]
    #[doc = ""]
    pub families: Vec<Families>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Default gateway address."]
    #[doc = ""]
    pub gateway: Option<::std::net::Ipv4Addr>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Default ipv6 gateway address."]
    #[doc = ""]
    pub gateway6: Option<::std::net::Ipv6Addr>,
    #[doc = "Network interface name."]
    #[doc = ""]
    pub iface: IfaceStr,
    #[serde(rename = "link-type")]
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "The link type."]
    #[doc = ""]
    pub link_type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "The network configuration method for IPv4."]
    #[doc = ""]
    pub method: Option<Method>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "The network configuration method for IPv6."]
    #[doc = ""]
    pub method6: Option<Method6>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "MTU."]
    #[doc = ""]
    pub mtu: Option<MtuInt>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Network mask."]
    #[doc = ""]
    pub netmask: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Network mask."]
    #[doc = ""]
    pub netmask6: Option<Netmask6Int>,
    #[serde(skip_serializing_if = "::std::vec::Vec::is_empty", default)]
    #[doc = "A list of additional interface options for IPv4."]
    #[doc = ""]
    pub options: Vec<String>,
    #[serde(skip_serializing_if = "::std::vec::Vec::is_empty", default)]
    #[doc = "A list of additional interface options for IPv6."]
    #[doc = ""]
    pub options6: Vec<String>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Specify the interfaces used by the bonding device."]
    #[doc = ""]
    pub ovs_bonds: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "The OVS bridge associated with a OVS port. This is required when you create an OVS port."]
    #[doc = ""]
    pub ovs_bridge: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "OVS interface options."]
    #[doc = ""]
    pub ovs_options: Option<OvsOptionsStr>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Specify the interfaces you want to add to your bridge."]
    #[doc = ""]
    pub ovs_ports: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Specify a VLan tag (used by OVSPort, OVSIntPort, OVSBond)"]
    #[doc = ""]
    pub ovs_tag: Option<OvsTagInt>,
    #[serde(
        serialize_with = "crate::types::serialize_int_optional",
        deserialize_with = "crate::types::deserialize_int_optional"
    )]
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "The order of the interface."]
    #[doc = ""]
    pub priority: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Specify the interfaces used by the bonding device."]
    #[doc = ""]
    pub slaves: Option<String>,
    #[serde(rename = "type")]
    #[doc = "Network interface type"]
    #[doc = ""]
    pub ty: Type2,
    #[serde(rename = "uplink-id")]
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "The uplink ID."]
    #[doc = ""]
    pub uplink_id: Option<String>,
    #[serde(rename = "vlan-id")]
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "vlan-id for a custom named vlan interface (ifupdown2 only)."]
    #[doc = ""]
    pub vlan_id: Option<VlanIdInt>,
    #[serde(rename = "vlan-protocol")]
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "The VLAN protocol."]
    #[doc = ""]
    pub vlan_protocol: Option<VlanProtocol>,
    #[serde(rename = "vlan-raw-device")]
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Specify the raw interface for the vlan interface."]
    #[doc = ""]
    pub vlan_raw_device: Option<String>,
    #[serde(rename = "vxlan-id")]
    #[serde(
        serialize_with = "crate::types::serialize_int_optional",
        deserialize_with = "crate::types::deserialize_int_optional"
    )]
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "The VXLAN ID."]
    #[doc = ""]
    pub vxlan_id: Option<i64>,
    #[serde(rename = "vxlan-local-tunnelip")]
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "The VXLAN local tunnel IP."]
    #[doc = ""]
    pub vxlan_local_tunnelip: Option<String>,
    #[serde(rename = "vxlan-physdev")]
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "The physical device for the VXLAN tunnel."]
    #[doc = ""]
    pub vxlan_physdev: Option<String>,
    #[serde(rename = "vxlan-svcnodeip")]
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "The VXLAN SVC node IP."]
    #[doc = ""]
    pub vxlan_svcnodeip: Option<String>,
    #[serde(
        flatten,
        default,
        skip_serializing_if = "::std::collections::HashMap::is_empty"
    )]
    pub additional_properties: ::std::collections::HashMap<String, ::serde_json::Value>,
}
#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, Default)]
pub struct GetParams {
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Only list specific interface types."]
    #[doc = ""]
    pub ty: Option<Type>,
    #[serde(
        flatten,
        default,
        skip_serializing_if = "::std::collections::HashMap::is_empty"
    )]
    pub additional_properties: ::std::collections::HashMap<String, ::serde_json::Value>,
}
impl PostParams {
    pub fn new(iface: IfaceStr, ty: Type3) -> Self {
        Self {
            iface,
            ty,
            address: ::std::default::Default::default(),
            address6: ::std::default::Default::default(),
            autostart: ::std::default::Default::default(),
            bond_primary: ::std::default::Default::default(),
            bond_mode: ::std::default::Default::default(),
            bond_xmit_hash_policy: ::std::default::Default::default(),
            bridge_ports: ::std::default::Default::default(),
            bridge_vids: ::std::default::Default::default(),
            bridge_vlan_aware: ::std::default::Default::default(),
            cidr: ::std::default::Default::default(),
            cidr6: ::std::default::Default::default(),
            comments: ::std::default::Default::default(),
            comments6: ::std::default::Default::default(),
            gateway: ::std::default::Default::default(),
            gateway6: ::std::default::Default::default(),
            mtu: ::std::default::Default::default(),
            netmask: ::std::default::Default::default(),
            netmask6: ::std::default::Default::default(),
            ovs_bonds: ::std::default::Default::default(),
            ovs_bridge: ::std::default::Default::default(),
            ovs_options: ::std::default::Default::default(),
            ovs_ports: ::std::default::Default::default(),
            ovs_tag: ::std::default::Default::default(),
            slaves: ::std::default::Default::default(),
            vlan_id: ::std::default::Default::default(),
            vlan_raw_device: ::std::default::Default::default(),
            additional_properties: ::std::default::Default::default(),
        }
    }
}
#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize)]
pub struct PostParams {
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "IP address."]
    #[doc = ""]
    pub address: Option<::std::net::Ipv4Addr>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "IP address."]
    #[doc = ""]
    pub address6: Option<::std::net::Ipv6Addr>,
    #[serde(
        serialize_with = "crate::types::serialize_bool_optional",
        deserialize_with = "crate::types::deserialize_bool_optional"
    )]
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Automatically start interface on boot."]
    #[doc = ""]
    pub autostart: Option<bool>,
    #[serde(rename = "bond-primary")]
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Specify the primary interface for active-backup bond."]
    #[doc = ""]
    pub bond_primary: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Bonding mode."]
    #[doc = ""]
    pub bond_mode: Option<BondMode>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Selects the transmit hash policy to use for slave selection in balance-xor and 802.3ad modes."]
    #[doc = ""]
    pub bond_xmit_hash_policy: Option<BondXmitHashPolicy>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Specify the interfaces you want to add to your bridge."]
    #[doc = ""]
    pub bridge_ports: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Specify the allowed VLANs. For example: '2 4 100-200'. Only used if the bridge is VLAN aware."]
    #[doc = ""]
    pub bridge_vids: Option<String>,
    #[serde(
        serialize_with = "crate::types::serialize_bool_optional",
        deserialize_with = "crate::types::deserialize_bool_optional"
    )]
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Enable bridge vlan support."]
    #[doc = ""]
    pub bridge_vlan_aware: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "IPv4 CIDR."]
    #[doc = ""]
    pub cidr: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "IPv6 CIDR."]
    #[doc = ""]
    pub cidr6: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Comments"]
    #[doc = ""]
    pub comments: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Comments"]
    #[doc = ""]
    pub comments6: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Default gateway address."]
    #[doc = ""]
    pub gateway: Option<::std::net::Ipv4Addr>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Default ipv6 gateway address."]
    #[doc = ""]
    pub gateway6: Option<::std::net::Ipv6Addr>,
    #[doc = "Network interface name."]
    #[doc = ""]
    pub iface: IfaceStr,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "MTU."]
    #[doc = ""]
    pub mtu: Option<MtuInt>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Network mask."]
    #[doc = ""]
    pub netmask: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Network mask."]
    #[doc = ""]
    pub netmask6: Option<Netmask6Int>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Specify the interfaces used by the bonding device."]
    #[doc = ""]
    pub ovs_bonds: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "The OVS bridge associated with a OVS port. This is required when you create an OVS port."]
    #[doc = ""]
    pub ovs_bridge: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "OVS interface options."]
    #[doc = ""]
    pub ovs_options: Option<OvsOptionsStr>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Specify the interfaces you want to add to your bridge."]
    #[doc = ""]
    pub ovs_ports: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Specify a VLan tag (used by OVSPort, OVSIntPort, OVSBond)"]
    #[doc = ""]
    pub ovs_tag: Option<OvsTagInt>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Specify the interfaces used by the bonding device."]
    #[doc = ""]
    pub slaves: Option<String>,
    #[serde(rename = "type")]
    #[doc = "Network interface type"]
    #[doc = ""]
    pub ty: Type3,
    #[serde(rename = "vlan-id")]
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "vlan-id for a custom named vlan interface (ifupdown2 only)."]
    #[doc = ""]
    pub vlan_id: Option<VlanIdInt>,
    #[serde(rename = "vlan-raw-device")]
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Specify the raw interface for the vlan interface."]
    #[doc = ""]
    pub vlan_raw_device: Option<String>,
    #[serde(
        flatten,
        default,
        skip_serializing_if = "::std::collections::HashMap::is_empty"
    )]
    pub additional_properties: ::std::collections::HashMap<String, ::serde_json::Value>,
}
#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, Default)]
pub struct PutParams {
    #[serde(rename = "regenerate-frr")]
    #[serde(
        serialize_with = "crate::types::serialize_bool_optional",
        deserialize_with = "crate::types::deserialize_bool_optional"
    )]
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[doc = "Whether FRR config generation should get skipped or not."]
    #[doc = ""]
    pub regenerate_frr: Option<bool>,
    #[serde(
        flatten,
        default,
        skip_serializing_if = "::std::collections::HashMap::is_empty"
    )]
    pub additional_properties: ::std::collections::HashMap<String, ::serde_json::Value>,
}
#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq)]
#[doc = "Bonding mode."]
#[doc = ""]
pub enum BondMode {
    #[serde(rename = "802.3ad")]
    _8023ad,
    #[serde(rename = "active-backup")]
    ActiveBackup,
    #[serde(rename = "balance-alb")]
    BalanceAlb,
    #[serde(rename = "balance-rr")]
    BalanceRr,
    #[serde(rename = "balance-slb")]
    BalanceSlb,
    #[serde(rename = "balance-tlb")]
    BalanceTlb,
    #[serde(rename = "balance-xor")]
    BalanceXor,
    #[serde(rename = "broadcast")]
    Broadcast,
    #[serde(rename = "lacp-balance-slb")]
    LacpBalanceSlb,
    #[serde(rename = "lacp-balance-tcp")]
    LacpBalanceTcp,
}
impl TryFrom<&str> for BondMode {
    type Error = String;
    fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
        match value {
            "802.3ad" => Ok(Self::_8023ad),
            "active-backup" => Ok(Self::ActiveBackup),
            "balance-alb" => Ok(Self::BalanceAlb),
            "balance-rr" => Ok(Self::BalanceRr),
            "balance-slb" => Ok(Self::BalanceSlb),
            "balance-tlb" => Ok(Self::BalanceTlb),
            "balance-xor" => Ok(Self::BalanceXor),
            "broadcast" => Ok(Self::Broadcast),
            "lacp-balance-slb" => Ok(Self::LacpBalanceSlb),
            "lacp-balance-tcp" => Ok(Self::LacpBalanceTcp),
            v => Err(format!("Unknown variant {v}")),
        }
    }
}
#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq)]
#[doc = "Selects the transmit hash policy to use for slave selection in balance-xor and 802.3ad modes."]
#[doc = ""]
pub enum BondXmitHashPolicy {
    #[serde(rename = "layer2")]
    Layer2,
    #[serde(rename = "layer2+3")]
    Layer23,
    #[serde(rename = "layer3+4")]
    Layer34,
}
impl TryFrom<&str> for BondXmitHashPolicy {
    type Error = String;
    fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
        match value {
            "layer2" => Ok(Self::Layer2),
            "layer2+3" => Ok(Self::Layer23),
            "layer3+4" => Ok(Self::Layer34),
            v => Err(format!("Unknown variant {v}")),
        }
    }
}
#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq)]
#[doc = "A network family."]
#[doc = ""]
pub enum Families {
    #[serde(rename = "inet")]
    Inet,
    #[serde(rename = "inet6")]
    Inet6,
}
impl TryFrom<&str> for Families {
    type Error = String;
    fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
        match value {
            "inet" => Ok(Self::Inet),
            "inet6" => Ok(Self::Inet6),
            v => Err(format!("Unknown variant {v}")),
        }
    }
}
#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq)]
#[doc = "The network configuration method for IPv4."]
#[doc = ""]
pub enum Method {
    #[serde(rename = "auto")]
    Auto,
    #[serde(rename = "dhcp")]
    Dhcp,
    #[serde(rename = "loopback")]
    Loopback,
    #[serde(rename = "manual")]
    Manual,
    #[serde(rename = "static")]
    Static,
}
impl TryFrom<&str> for Method {
    type Error = String;
    fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
        match value {
            "auto" => Ok(Self::Auto),
            "dhcp" => Ok(Self::Dhcp),
            "loopback" => Ok(Self::Loopback),
            "manual" => Ok(Self::Manual),
            "static" => Ok(Self::Static),
            v => Err(format!("Unknown variant {v}")),
        }
    }
}
#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq)]
#[doc = "The network configuration method for IPv6."]
#[doc = ""]
pub enum Method6 {
    #[serde(rename = "auto")]
    Auto,
    #[serde(rename = "dhcp")]
    Dhcp,
    #[serde(rename = "loopback")]
    Loopback,
    #[serde(rename = "manual")]
    Manual,
    #[serde(rename = "static")]
    Static,
}
impl TryFrom<&str> for Method6 {
    type Error = String;
    fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
        match value {
            "auto" => Ok(Self::Auto),
            "dhcp" => Ok(Self::Dhcp),
            "loopback" => Ok(Self::Loopback),
            "manual" => Ok(Self::Manual),
            "static" => Ok(Self::Static),
            v => Err(format!("Unknown variant {v}")),
        }
    }
}
#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq)]
#[doc = "Only list specific interface types."]
#[doc = ""]
pub enum Type {
    OVSBond,
    OVSBridge,
    OVSIntPort,
    OVSPort,
    #[serde(rename = "alias")]
    Alias,
    #[serde(rename = "any_bridge")]
    AnyBridge,
    #[serde(rename = "any_local_bridge")]
    AnyLocalBridge,
    #[serde(rename = "bond")]
    Bond,
    #[serde(rename = "bridge")]
    Bridge,
    #[serde(rename = "eth")]
    Eth,
    #[serde(rename = "fabric")]
    Fabric,
    #[serde(rename = "include_sdn")]
    IncludeSdn,
    #[serde(rename = "vlan")]
    Vlan,
    #[serde(rename = "vnet")]
    Vnet,
}
impl TryFrom<&str> for Type {
    type Error = String;
    fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
        match value {
            "OVSBond" => Ok(Self::OVSBond),
            "OVSBridge" => Ok(Self::OVSBridge),
            "OVSIntPort" => Ok(Self::OVSIntPort),
            "OVSPort" => Ok(Self::OVSPort),
            "alias" => Ok(Self::Alias),
            "any_bridge" => Ok(Self::AnyBridge),
            "any_local_bridge" => Ok(Self::AnyLocalBridge),
            "bond" => Ok(Self::Bond),
            "bridge" => Ok(Self::Bridge),
            "eth" => Ok(Self::Eth),
            "fabric" => Ok(Self::Fabric),
            "include_sdn" => Ok(Self::IncludeSdn),
            "vlan" => Ok(Self::Vlan),
            "vnet" => Ok(Self::Vnet),
            v => Err(format!("Unknown variant {v}")),
        }
    }
}
#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq)]
#[doc = "Network interface type"]
#[doc = ""]
pub enum Type2 {
    OVSBond,
    OVSBridge,
    OVSIntPort,
    OVSPort,
    #[serde(rename = "alias")]
    Alias,
    #[serde(rename = "bond")]
    Bond,
    #[serde(rename = "bridge")]
    Bridge,
    #[serde(rename = "eth")]
    Eth,
    #[serde(rename = "fabric")]
    Fabric,
    #[serde(rename = "unknown")]
    Unknown,
    #[serde(rename = "vlan")]
    Vlan,
    #[serde(rename = "vnet")]
    Vnet,
}
impl TryFrom<&str> for Type2 {
    type Error = String;
    fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
        match value {
            "OVSBond" => Ok(Self::OVSBond),
            "OVSBridge" => Ok(Self::OVSBridge),
            "OVSIntPort" => Ok(Self::OVSIntPort),
            "OVSPort" => Ok(Self::OVSPort),
            "alias" => Ok(Self::Alias),
            "bond" => Ok(Self::Bond),
            "bridge" => Ok(Self::Bridge),
            "eth" => Ok(Self::Eth),
            "fabric" => Ok(Self::Fabric),
            "unknown" => Ok(Self::Unknown),
            "vlan" => Ok(Self::Vlan),
            "vnet" => Ok(Self::Vnet),
            v => Err(format!("Unknown variant {v}")),
        }
    }
}
#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq)]
#[doc = "Network interface type"]
#[doc = ""]
pub enum Type3 {
    OVSBond,
    OVSBridge,
    OVSIntPort,
    OVSPort,
    #[serde(rename = "alias")]
    Alias,
    #[serde(rename = "bond")]
    Bond,
    #[serde(rename = "bridge")]
    Bridge,
    #[serde(rename = "eth")]
    Eth,
    #[serde(rename = "fabric")]
    Fabric,
    #[serde(rename = "unknown")]
    Unknown,
    #[serde(rename = "vlan")]
    Vlan,
    #[serde(rename = "vnet")]
    Vnet,
}
impl TryFrom<&str> for Type3 {
    type Error = String;
    fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
        match value {
            "OVSBond" => Ok(Self::OVSBond),
            "OVSBridge" => Ok(Self::OVSBridge),
            "OVSIntPort" => Ok(Self::OVSIntPort),
            "OVSPort" => Ok(Self::OVSPort),
            "alias" => Ok(Self::Alias),
            "bond" => Ok(Self::Bond),
            "bridge" => Ok(Self::Bridge),
            "eth" => Ok(Self::Eth),
            "fabric" => Ok(Self::Fabric),
            "unknown" => Ok(Self::Unknown),
            "vlan" => Ok(Self::Vlan),
            "vnet" => Ok(Self::Vnet),
            v => Err(format!("Unknown variant {v}")),
        }
    }
}
#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq)]
#[doc = "The VLAN protocol."]
#[doc = ""]
pub enum VlanProtocol {
    #[serde(rename = "802.1ad")]
    _8021ad,
    #[serde(rename = "802.1q")]
    _8021q,
}
impl TryFrom<&str> for VlanProtocol {
    type Error = String;
    fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
        match value {
            "802.1ad" => Ok(Self::_8021ad),
            "802.1q" => Ok(Self::_8021q),
            v => Err(format!("Unknown variant {v}")),
        }
    }
}
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
pub struct MtuInt(i128);
impl crate::types::bounded_integer::BoundedInteger for MtuInt {
    const MIN: Option<i128> = Some(1280i128);
    const MAX: Option<i128> = Some(65520i128);
    const DEFAULT: Option<i128> = None::<i128>;
    const TYPE_DESCRIPTION: &'static str = "an integer between 1280 and 65520";
    fn get(&self) -> i128 {
        self.0
    }
    fn new(value: i128) -> Result<Self, crate::types::bounded_integer::BoundedIntegerError> {
        Self::validate(value)?;
        Ok(Self(value))
    }
}
impl std::convert::TryFrom<i128> for MtuInt {
    type Error = crate::types::bounded_integer::BoundedIntegerError;
    fn try_from(value: i128) -> Result<Self, Self::Error> {
        crate::types::bounded_integer::BoundedInteger::new(value)
    }
}
impl ::serde::Serialize for MtuInt {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: ::serde::Serializer,
    {
        crate::types::bounded_integer::serialize_bounded_integer(self, serializer)
    }
}
impl<'de> ::serde::Deserialize<'de> for MtuInt {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        crate::types::bounded_integer::deserialize_bounded_integer(deserializer)
    }
}
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
pub struct Netmask6Int(i128);
impl crate::types::bounded_integer::BoundedInteger for Netmask6Int {
    const MIN: Option<i128> = Some(0i128);
    const MAX: Option<i128> = Some(128i128);
    const DEFAULT: Option<i128> = None::<i128>;
    const TYPE_DESCRIPTION: &'static str = "an integer between 0 and 128";
    fn get(&self) -> i128 {
        self.0
    }
    fn new(value: i128) -> Result<Self, crate::types::bounded_integer::BoundedIntegerError> {
        Self::validate(value)?;
        Ok(Self(value))
    }
}
impl std::convert::TryFrom<i128> for Netmask6Int {
    type Error = crate::types::bounded_integer::BoundedIntegerError;
    fn try_from(value: i128) -> Result<Self, Self::Error> {
        crate::types::bounded_integer::BoundedInteger::new(value)
    }
}
impl ::serde::Serialize for Netmask6Int {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: ::serde::Serializer,
    {
        crate::types::bounded_integer::serialize_bounded_integer(self, serializer)
    }
}
impl<'de> ::serde::Deserialize<'de> for Netmask6Int {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        crate::types::bounded_integer::deserialize_bounded_integer(deserializer)
    }
}
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
pub struct OvsTagInt(i128);
impl crate::types::bounded_integer::BoundedInteger for OvsTagInt {
    const MIN: Option<i128> = Some(1i128);
    const MAX: Option<i128> = Some(4094i128);
    const DEFAULT: Option<i128> = None::<i128>;
    const TYPE_DESCRIPTION: &'static str = "an integer between 1 and 4094";
    fn get(&self) -> i128 {
        self.0
    }
    fn new(value: i128) -> Result<Self, crate::types::bounded_integer::BoundedIntegerError> {
        Self::validate(value)?;
        Ok(Self(value))
    }
}
impl std::convert::TryFrom<i128> for OvsTagInt {
    type Error = crate::types::bounded_integer::BoundedIntegerError;
    fn try_from(value: i128) -> Result<Self, Self::Error> {
        crate::types::bounded_integer::BoundedInteger::new(value)
    }
}
impl ::serde::Serialize for OvsTagInt {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: ::serde::Serializer,
    {
        crate::types::bounded_integer::serialize_bounded_integer(self, serializer)
    }
}
impl<'de> ::serde::Deserialize<'de> for OvsTagInt {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        crate::types::bounded_integer::deserialize_bounded_integer(deserializer)
    }
}
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
pub struct VlanIdInt(i128);
impl crate::types::bounded_integer::BoundedInteger for VlanIdInt {
    const MIN: Option<i128> = Some(1i128);
    const MAX: Option<i128> = Some(4094i128);
    const DEFAULT: Option<i128> = None::<i128>;
    const TYPE_DESCRIPTION: &'static str = "an integer between 1 and 4094";
    fn get(&self) -> i128 {
        self.0
    }
    fn new(value: i128) -> Result<Self, crate::types::bounded_integer::BoundedIntegerError> {
        Self::validate(value)?;
        Ok(Self(value))
    }
}
impl std::convert::TryFrom<i128> for VlanIdInt {
    type Error = crate::types::bounded_integer::BoundedIntegerError;
    fn try_from(value: i128) -> Result<Self, Self::Error> {
        crate::types::bounded_integer::BoundedInteger::new(value)
    }
}
impl ::serde::Serialize for VlanIdInt {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: ::serde::Serializer,
    {
        crate::types::bounded_integer::serialize_bounded_integer(self, serializer)
    }
}
impl<'de> ::serde::Deserialize<'de> for VlanIdInt {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        crate::types::bounded_integer::deserialize_bounded_integer(deserializer)
    }
}
#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct IfaceStr {
    value: String,
}
impl crate::types::bounded_string::BoundedString for IfaceStr {
    const MIN_LENGTH: Option<usize> = Some(2usize);
    const MAX_LENGTH: Option<usize> = Some(20usize);
    const DEFAULT: Option<&'static str> = None::<&'static str>;
    const PATTERN: Option<&'static str> = None::<&'static str>;
    const TYPE_DESCRIPTION: &'static str = "a string with length between 2 and 20";
    fn get_value(&self) -> &str {
        &self.value
    }
    fn new(value: String) -> Result<Self, crate::types::bounded_string::BoundedStringError> {
        Self::validate(&value)?;
        Ok(Self { value })
    }
}
impl std::convert::TryFrom<String> for IfaceStr {
    type Error = crate::types::bounded_string::BoundedStringError;
    fn try_from(value: String) -> Result<Self, Self::Error> {
        crate::types::bounded_string::BoundedString::new(value)
    }
}
impl ::serde::Serialize for IfaceStr {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: ::serde::Serializer,
    {
        crate::types::bounded_string::serialize_bounded_string(self, serializer)
    }
}
impl<'de> ::serde::Deserialize<'de> for IfaceStr {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        crate::types::bounded_string::deserialize_bounded_string(deserializer)
    }
}
#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct OvsOptionsStr {
    value: String,
}
impl crate::types::bounded_string::BoundedString for OvsOptionsStr {
    const MIN_LENGTH: Option<usize> = None::<usize>;
    const MAX_LENGTH: Option<usize> = Some(1024usize);
    const DEFAULT: Option<&'static str> = None::<&'static str>;
    const PATTERN: Option<&'static str> = None::<&'static str>;
    const TYPE_DESCRIPTION: &'static str = "a string with length at most 1024";
    fn get_value(&self) -> &str {
        &self.value
    }
    fn new(value: String) -> Result<Self, crate::types::bounded_string::BoundedStringError> {
        Self::validate(&value)?;
        Ok(Self { value })
    }
}
impl std::convert::TryFrom<String> for OvsOptionsStr {
    type Error = crate::types::bounded_string::BoundedStringError;
    fn try_from(value: String) -> Result<Self, Self::Error> {
        crate::types::bounded_string::BoundedString::new(value)
    }
}
impl ::serde::Serialize for OvsOptionsStr {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: ::serde::Serializer,
    {
        crate::types::bounded_string::serialize_bounded_string(self, serializer)
    }
}
impl<'de> ::serde::Deserialize<'de> for OvsOptionsStr {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        crate::types::bounded_string::deserialize_bounded_string(deserializer)
    }
}
impl<T> NetworkClient<T>
where
    T: crate::client::Client,
{
    pub fn iface(&self, iface: &str) -> iface::IfaceClient<T> {
        iface::IfaceClient::<T>::new(self.client.clone(), &self.path, iface)
    }
}