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, Serialize, Deserialize)]
pub struct PveQemuScsiConfig {

    /// AIO type to use.
    #[serde(rename = "aio", skip_serializing_if = "Option::is_none")]
    pub aio: Option<models::PveAioEnum>,

    /// Whether the drive should be included when making backups.
    #[serde(rename = "backup", skip_serializing_if = "Option::is_none")]
    pub backup: Option<models::PveBoolean>,

    /// Maximum r/w speed in bytes per second.
    #[serde(rename = "bps", skip_serializing_if = "Option::is_none")]
    pub bps: Option<i64>,

    /// Maximum length of I/O bursts in seconds.
    #[serde(rename = "bps_max_length", skip_serializing_if = "Option::is_none")]
    pub bps_max_length: Option<i64>,

    /// Maximum read speed in bytes per second.
    #[serde(rename = "bps_rd", skip_serializing_if = "Option::is_none")]
    pub bps_rd: Option<i64>,

    #[serde(rename = "bps_rd_length", skip_serializing_if = "Option::is_none")]
    pub bps_rd_length: Option<String>,

    /// Maximum length of read I/O bursts in seconds.
    #[serde(rename = "bps_rd_max_length", skip_serializing_if = "Option::is_none")]
    pub bps_rd_max_length: Option<i64>,

    /// Maximum write speed in bytes per second.
    #[serde(rename = "bps_wr", skip_serializing_if = "Option::is_none")]
    pub bps_wr: Option<i64>,

    #[serde(rename = "bps_wr_length", skip_serializing_if = "Option::is_none")]
    pub bps_wr_length: Option<String>,

    /// Maximum length of write I/O bursts in seconds.
    #[serde(rename = "bps_wr_max_length", skip_serializing_if = "Option::is_none")]
    pub bps_wr_max_length: Option<i64>,

    /// The drive's cache mode
    #[serde(rename = "cache", skip_serializing_if = "Option::is_none")]
    pub cache: Option<models::PveCacheEnum>,

    /// Controls whether to detect and try to optimize writes of zeroes.
    #[serde(rename = "detect_zeroes", skip_serializing_if = "Option::is_none")]
    pub detect_zeroes: Option<models::PveBoolean>,

    /// Controls whether to pass discard/trim requests to the underlying storage.
    #[serde(rename = "discard", skip_serializing_if = "Option::is_none")]
    pub discard: Option<models::PveDiscardEnum>,

    /// The drive's backing volume.
    #[serde(rename = "file")]
    pub file: String,

    /// The drive's backing file's data format.
    #[serde(rename = "format", skip_serializing_if = "Option::is_none")]
    pub format: Option<models::PveFormatEnum>,

    /// Maximum r/w I/O in operations per second.
    #[serde(rename = "iops", skip_serializing_if = "Option::is_none")]
    pub iops: Option<i64>,

    /// Maximum unthrottled r/w I/O pool in operations per second.
    #[serde(rename = "iops_max", skip_serializing_if = "Option::is_none")]
    pub iops_max: Option<i64>,

    /// Maximum length of I/O bursts in seconds.
    #[serde(rename = "iops_max_length", skip_serializing_if = "Option::is_none")]
    pub iops_max_length: Option<i64>,

    /// Maximum read I/O in operations per second.
    #[serde(rename = "iops_rd", skip_serializing_if = "Option::is_none")]
    pub iops_rd: Option<i64>,

    #[serde(rename = "iops_rd_length", skip_serializing_if = "Option::is_none")]
    pub iops_rd_length: Option<String>,

    /// Maximum unthrottled read I/O pool in operations per second.
    #[serde(rename = "iops_rd_max", skip_serializing_if = "Option::is_none")]
    pub iops_rd_max: Option<i64>,

    /// Maximum length of read I/O bursts in seconds.
    #[serde(rename = "iops_rd_max_length", skip_serializing_if = "Option::is_none")]
    pub iops_rd_max_length: Option<i64>,

    /// Maximum write I/O in operations per second.
    #[serde(rename = "iops_wr", skip_serializing_if = "Option::is_none")]
    pub iops_wr: Option<i64>,

    #[serde(rename = "iops_wr_length", skip_serializing_if = "Option::is_none")]
    pub iops_wr_length: Option<String>,

    /// Maximum unthrottled write I/O pool in operations per second.
    #[serde(rename = "iops_wr_max", skip_serializing_if = "Option::is_none")]
    pub iops_wr_max: Option<i64>,

    /// Maximum length of write I/O bursts in seconds.
    #[serde(rename = "iops_wr_max_length", skip_serializing_if = "Option::is_none")]
    pub iops_wr_max_length: Option<i64>,

    /// Whether to use iothreads for this drive
    #[serde(rename = "iothread", skip_serializing_if = "Option::is_none")]
    pub iothread: Option<models::PveBoolean>,

    /// Maximum r/w speed in megabytes per second.
    #[serde(rename = "mbps", skip_serializing_if = "Option::is_none")]
    pub mbps: Option<f64>,

    /// Maximum unthrottled r/w pool in megabytes per second.
    #[serde(rename = "mbps_max", skip_serializing_if = "Option::is_none")]
    pub mbps_max: Option<f64>,

    /// Maximum read speed in megabytes per second.
    #[serde(rename = "mbps_rd", skip_serializing_if = "Option::is_none")]
    pub mbps_rd: Option<f64>,

    /// Maximum unthrottled read pool in megabytes per second.
    #[serde(rename = "mbps_rd_max", skip_serializing_if = "Option::is_none")]
    pub mbps_rd_max: Option<f64>,

    /// Maximum write speed in megabytes per second.
    #[serde(rename = "mbps_wr", skip_serializing_if = "Option::is_none")]
    pub mbps_wr: Option<f64>,

    /// Maximum unthrottled write pool in megabytes per second.
    #[serde(rename = "mbps_wr_max", skip_serializing_if = "Option::is_none")]
    pub mbps_wr_max: Option<f64>,

    /// The drive's media type.
    #[serde(rename = "media", skip_serializing_if = "Option::is_none")]
    pub media: Option<models::PveMediaEnum>,

    /// The drive's product name, up to 16 bytes long.
    #[serde(rename = "product", skip_serializing_if = "Option::is_none")]
    pub product: Option<String>,

    /// Number of queues.
    #[serde(rename = "queues", skip_serializing_if = "Option::is_none")]
    pub queues: Option<i64>,

    /// Whether the drive should considered for replication jobs.
    #[serde(rename = "replicate", skip_serializing_if = "Option::is_none")]
    pub replicate: Option<models::PveBoolean>,

    /// Read error action.
    #[serde(rename = "rerror", skip_serializing_if = "Option::is_none")]
    pub rerror: Option<models::PveRerrorEnum>,

    /// Whether the drive is read-only.
    #[serde(rename = "ro", skip_serializing_if = "Option::is_none")]
    pub ro: Option<models::PveBoolean>,

    /// whether to use scsi-block for full passthrough of host block device  WARNING: can lead to I/O errors in combination with low memory or high memory fragmentation on host
    #[serde(rename = "scsiblock", skip_serializing_if = "Option::is_none")]
    pub scsiblock: Option<models::PveBoolean>,

    /// The drive's reported serial number, url-encoded, up to 20 bytes long.
    #[serde(rename = "serial", skip_serializing_if = "Option::is_none")]
    pub serial: Option<String>,

    /// Mark this locally-managed volume as available on all nodes.  WARNING: This option does not share the volume automatically, it assumes it is shared already!
    #[serde(rename = "shared", skip_serializing_if = "Option::is_none")]
    pub shared: Option<models::PveBoolean>,

    /// Disk size. This is purely informational and has no effect.
    #[serde(rename = "size", skip_serializing_if = "Option::is_none")]
    pub size: Option<String>,

    /// Controls qemu's snapshot mode feature. If activated, changes made to the disk are temporary and will be discarded when the VM is shutdown.
    #[serde(rename = "snapshot", skip_serializing_if = "Option::is_none")]
    pub snapshot: Option<models::PveBoolean>,

    /// Whether to expose this drive as an SSD, rather than a rotational hard disk.
    #[serde(rename = "ssd", skip_serializing_if = "Option::is_none")]
    pub ssd: Option<models::PveBoolean>,

    /// The drive's vendor name, up to 8 bytes long.
    #[serde(rename = "vendor", skip_serializing_if = "Option::is_none")]
    pub vendor: Option<String>,

    #[serde(rename = "volume", skip_serializing_if = "Option::is_none")]
    pub volume: Option<String>,

    /// Write error action.
    #[serde(rename = "werror", skip_serializing_if = "Option::is_none")]
    pub werror: Option<models::PveWerrorEnum>,

    /// The drive's worldwide name, encoded as 16 bytes hex string, prefixed by '0x'.
    #[serde(rename = "wwn", skip_serializing_if = "Option::is_none")]
    pub wwn: Option<String>,


}

impl PveQemuScsiConfig {
    pub fn new(file: String) -> PveQemuScsiConfig {
        PveQemuScsiConfig {
            
            aio: None,
            
            backup: None,
            
            bps: None,
            
            bps_max_length: None,
            
            bps_rd: None,
            
            bps_rd_length: None,
            
            bps_rd_max_length: None,
            
            bps_wr: None,
            
            bps_wr_length: None,
            
            bps_wr_max_length: None,
            
            cache: None,
            
            detect_zeroes: None,
            
            discard: None,
            
            file,
            
            format: None,
            
            iops: None,
            
            iops_max: None,
            
            iops_max_length: None,
            
            iops_rd: None,
            
            iops_rd_length: None,
            
            iops_rd_max: None,
            
            iops_rd_max_length: None,
            
            iops_wr: None,
            
            iops_wr_length: None,
            
            iops_wr_max: None,
            
            iops_wr_max_length: None,
            
            iothread: None,
            
            mbps: None,
            
            mbps_max: None,
            
            mbps_rd: None,
            
            mbps_rd_max: None,
            
            mbps_wr: None,
            
            mbps_wr_max: None,
            
            media: None,
            
            product: None,
            
            queues: None,
            
            replicate: None,
            
            rerror: None,
            
            ro: None,
            
            scsiblock: None,
            
            serial: None,
            
            shared: None,
            
            size: None,
            
            snapshot: None,
            
            ssd: None,
            
            vendor: None,
            
            volume: None,
            
            werror: None,
            
            wwn: None,
            
        }
    }
}


impl PveQemuScsiConfig {
    /// Serialise this PveQemuScsiConfig into Proxmox's CLI-style shorthand
    /// string (`key=value,…`). The property marked `x-pve-default-key`
    /// is emitted positionally without a `key=` prefix; aliases collapse
    /// multiple property names to the same wire key.
    ///
    /// Example: `PveQemuScsiConfig `
    /// → `"virtio,bridge=vmbr0"`
    pub fn to_shorthand(&self) -> String {
        let mut parts: Vec<String> = Vec::new();
        
        
        parts.push(format!("{}", self.file));
        
        
        
        
        if let Some(ref v) = self.aio {
            parts.push(format!("aio={}", v));
        }
        
        
        if let Some(ref v) = self.backup {
            parts.push(format!("backup={}", v));
        }
        
        
        if let Some(ref v) = self.bps {
            parts.push(format!("bps={}", v));
        }
        
        
        if let Some(ref v) = self.bps_max_length {
            parts.push(format!("bps_max_length={}", v));
        }
        
        
        if let Some(ref v) = self.bps_rd {
            parts.push(format!("bps_rd={}", v));
        }
        
        
        if let Some(ref v) = self.bps_rd_length {
            parts.push(format!("bps_rd_max_length={}", v));
        }
        
        
        if let Some(ref v) = self.bps_rd_max_length {
            parts.push(format!("bps_rd_max_length={}", v));
        }
        
        
        if let Some(ref v) = self.bps_wr {
            parts.push(format!("bps_wr={}", v));
        }
        
        
        if let Some(ref v) = self.bps_wr_length {
            parts.push(format!("bps_wr_max_length={}", v));
        }
        
        
        if let Some(ref v) = self.bps_wr_max_length {
            parts.push(format!("bps_wr_max_length={}", v));
        }
        
        
        if let Some(ref v) = self.cache {
            parts.push(format!("cache={}", v));
        }
        
        
        if let Some(ref v) = self.detect_zeroes {
            parts.push(format!("detect_zeroes={}", v));
        }
        
        
        if let Some(ref v) = self.discard {
            parts.push(format!("discard={}", v));
        }
        
        
        if let Some(ref v) = self.format {
            parts.push(format!("format={}", v));
        }
        
        
        if let Some(ref v) = self.iops {
            parts.push(format!("iops={}", v));
        }
        
        
        if let Some(ref v) = self.iops_max {
            parts.push(format!("iops_max={}", v));
        }
        
        
        if let Some(ref v) = self.iops_max_length {
            parts.push(format!("iops_max_length={}", v));
        }
        
        
        if let Some(ref v) = self.iops_rd {
            parts.push(format!("iops_rd={}", v));
        }
        
        
        if let Some(ref v) = self.iops_rd_length {
            parts.push(format!("iops_rd_max_length={}", v));
        }
        
        
        if let Some(ref v) = self.iops_rd_max {
            parts.push(format!("iops_rd_max={}", v));
        }
        
        
        if let Some(ref v) = self.iops_rd_max_length {
            parts.push(format!("iops_rd_max_length={}", v));
        }
        
        
        if let Some(ref v) = self.iops_wr {
            parts.push(format!("iops_wr={}", v));
        }
        
        
        if let Some(ref v) = self.iops_wr_length {
            parts.push(format!("iops_wr_max_length={}", v));
        }
        
        
        if let Some(ref v) = self.iops_wr_max {
            parts.push(format!("iops_wr_max={}", v));
        }
        
        
        if let Some(ref v) = self.iops_wr_max_length {
            parts.push(format!("iops_wr_max_length={}", v));
        }
        
        
        if let Some(ref v) = self.iothread {
            parts.push(format!("iothread={}", v));
        }
        
        
        if let Some(ref v) = self.mbps {
            parts.push(format!("mbps={}", v));
        }
        
        
        if let Some(ref v) = self.mbps_max {
            parts.push(format!("mbps_max={}", v));
        }
        
        
        if let Some(ref v) = self.mbps_rd {
            parts.push(format!("mbps_rd={}", v));
        }
        
        
        if let Some(ref v) = self.mbps_rd_max {
            parts.push(format!("mbps_rd_max={}", v));
        }
        
        
        if let Some(ref v) = self.mbps_wr {
            parts.push(format!("mbps_wr={}", v));
        }
        
        
        if let Some(ref v) = self.mbps_wr_max {
            parts.push(format!("mbps_wr_max={}", v));
        }
        
        
        if let Some(ref v) = self.media {
            parts.push(format!("media={}", v));
        }
        
        
        if let Some(ref v) = self.product {
            parts.push(format!("product={}", v));
        }
        
        
        if let Some(ref v) = self.queues {
            parts.push(format!("queues={}", v));
        }
        
        
        if let Some(ref v) = self.replicate {
            parts.push(format!("replicate={}", v));
        }
        
        
        if let Some(ref v) = self.rerror {
            parts.push(format!("rerror={}", v));
        }
        
        
        if let Some(ref v) = self.ro {
            parts.push(format!("ro={}", v));
        }
        
        
        if let Some(ref v) = self.scsiblock {
            parts.push(format!("scsiblock={}", v));
        }
        
        
        if let Some(ref v) = self.serial {
            parts.push(format!("serial={}", v));
        }
        
        
        if let Some(ref v) = self.shared {
            parts.push(format!("shared={}", v));
        }
        
        
        if let Some(ref v) = self.size {
            parts.push(format!("size={}", v));
        }
        
        
        if let Some(ref v) = self.snapshot {
            parts.push(format!("snapshot={}", v));
        }
        
        
        if let Some(ref v) = self.ssd {
            parts.push(format!("ssd={}", v));
        }
        
        
        if let Some(ref v) = self.vendor {
            parts.push(format!("vendor={}", v));
        }
        
        
        if let Some(ref v) = self.volume {
            parts.push(format!("file={}", v));
        }
        
        
        if let Some(ref v) = self.werror {
            parts.push(format!("werror={}", v));
        }
        
        
        if let Some(ref v) = self.wwn {
            parts.push(format!("wwn={}", v));
        }
        
        parts.join(",")
    }
}