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 ClusterConfigJoinRequest {


    /// Certificate SHA 256 fingerprint.
    pub fingerprint: String,

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

    /// Hostname (or IP) of an existing cluster member.
    pub hostname: String,

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

    /// Superuser (root) password of peer node.
    pub password: String,

    /// 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 ClusterConfigJoinRequest {
    pub fn new(fingerprint: String, hostname: String, password: String) -> ClusterConfigJoinRequest {
        ClusterConfigJoinRequest {
            
            fingerprint,
            
            force: None,
            
            hostname,
            
            nodeid: None,
            
            password,
            
            votes: None,
            
            links: None,
        }
    }
}


// Flattens indexed-family maps to/from `<base><idx>` wire keys.
impl serde::Serialize for ClusterConfigJoinRequest {
    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.fingerprint).map_err(Error::custom)?;
            if !_v.is_null() {
                map.insert("fingerprint".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.hostname).map_err(Error::custom)?;
            if !_v.is_null() {
                map.insert("hostname".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.password).map_err(Error::custom)?;
            if !_v.is_null() {
                map.insert("password".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 ClusterConfigJoinRequest {
    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(ClusterConfigJoinRequest {
            
            fingerprint: serde_json::from_value(raw.remove("fingerprint").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)?,
            
            hostname: serde_json::from_value(raw.remove("hostname").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)?,
            
            password: serde_json::from_value(raw.remove("password").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) },
        })
    }
}