clientapi-pve 2026.5.24

/*
 * Proxmox Virtual Environment API
 *
 * Generated from apidoc.js. NOT an official Proxmox specification. See https://pve.proxmox.com/pve-docs/api-viewer/ for the upstream documentation.
 *
 * The version of the OpenAPI document: 9.x
 * 
 * Generated by: https://openapi-generator.tech
 */

use crate::models;
use serde::{Deserialize, Serialize};

#[derive(Clone, Default, Debug, PartialEq)]
pub struct ClusterConfigAddnodeRequest {


    /// The JOIN_API_VERSION of the new node.
    pub apiversion: Option<i64>,

    /// Do not throw error if node already exists.
    pub force: Option<models::PveBoolean>,

    /// IP Address of node to add. Used as fallback if no links are given.
    pub new_node_ip: Option<String>,

    /// Node id for this node.
    pub nodeid: Option<i64>,

    /// Number of votes for this node
    pub votes: Option<i64>,

    /// Links family. Wire form: `link0..link7`. Serialised by the manual impls below.
    pub links: Option<std::collections::HashMap<u32, models::PveLinkField>>,
}

impl ClusterConfigAddnodeRequest {
    pub fn new() -> ClusterConfigAddnodeRequest {
        ClusterConfigAddnodeRequest {
            
            apiversion: None,
            
            force: None,
            
            new_node_ip: None,
            
            nodeid: None,
            
            votes: None,
            
            links: None,
        }
    }
}


// Flattens indexed-family maps to/from `<base><idx>` wire keys.
impl serde::Serialize for ClusterConfigAddnodeRequest {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        use serde::ser::Error;
        let mut map = serde_json::Map::new();
        
        {
            let _v = serde_json::to_value(&self.apiversion).map_err(Error::custom)?;
            if !_v.is_null() {
                map.insert("apiversion".to_string(), _v);
            }
        }
        
        {
            let _v = serde_json::to_value(&self.force).map_err(Error::custom)?;
            if !_v.is_null() {
                map.insert("force".to_string(), _v);
            }
        }
        
        {
            let _v = serde_json::to_value(&self.new_node_ip).map_err(Error::custom)?;
            if !_v.is_null() {
                map.insert("new_node_ip".to_string(), _v);
            }
        }
        
        {
            let _v = serde_json::to_value(&self.nodeid).map_err(Error::custom)?;
            if !_v.is_null() {
                map.insert("nodeid".to_string(), _v);
            }
        }
        
        {
            let _v = serde_json::to_value(&self.votes).map_err(Error::custom)?;
            if !_v.is_null() {
                map.insert("votes".to_string(), _v);
            }
        }
        
        if let Some(ref _m) = self.links {
            for (_idx, _val) in _m.iter() {
                map.insert(format!("link{}", _idx), serde_json::to_value(_val).map_err(Error::custom)?);
            }
        }
        serde_json::Value::Object(map).serialize(serializer)
    }
}

impl<'de> serde::Deserialize<'de> for ClusterConfigAddnodeRequest {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        use serde::de::Error;
        let mut raw: serde_json::Map<String, serde_json::Value> =
            serde::Deserialize::deserialize(deserializer)?;
        let mut __links: std::collections::HashMap<u32, models::PveLinkField> = std::collections::HashMap::new();
        {
            let _prefix = "link";
            let _keys: Vec<String> = raw.keys()
                .filter(|k| {
                    if let Some(_suffix) = k.strip_prefix(_prefix) {
                        !_suffix.is_empty() && _suffix.chars().all(|c| c.is_ascii_digit())
                    } else {
                        false
                    }
                })
                .cloned()
                .collect();
            for _key in _keys {
                let _suffix = _key.strip_prefix(_prefix).unwrap();
                let _idx: u32 = _suffix.parse().map_err(Error::custom)?;
                let _value = raw.remove(&_key).unwrap();
                let _item: models::PveLinkField = serde_json::from_value(_value).map_err(Error::custom)?;
                __links.insert(_idx, _item);
            }
        }
        Ok(ClusterConfigAddnodeRequest {
            
            apiversion: serde_json::from_value(raw.remove("apiversion").unwrap_or(serde_json::Value::Null)).map_err(Error::custom)?,
            
            force: serde_json::from_value(raw.remove("force").unwrap_or(serde_json::Value::Null)).map_err(Error::custom)?,
            
            new_node_ip: serde_json::from_value(raw.remove("new_node_ip").unwrap_or(serde_json::Value::Null)).map_err(Error::custom)?,
            
            nodeid: serde_json::from_value(raw.remove("nodeid").unwrap_or(serde_json::Value::Null)).map_err(Error::custom)?,
            
            votes: serde_json::from_value(raw.remove("votes").unwrap_or(serde_json::Value::Null)).map_err(Error::custom)?,
            
            links: if __links.is_empty() { None } else { Some(__links) },
        })
    }
}