#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_sync_delimited {
#[serde(rename = "id")]
pub id: i64,
}
impl crate::QgaCommand for guest_sync_delimited { }
impl ::qapi_spec::Command for guest_sync_delimited {
const NAME: &'static str = "guest-sync-delimited";
const ALLOW_OOB: bool = false;
type Ok = i64;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_sync {
#[serde(rename = "id")]
pub id: i64,
}
impl crate::QgaCommand for guest_sync { }
impl ::qapi_spec::Command for guest_sync {
const NAME: &'static str = "guest-sync";
const ALLOW_OOB: bool = false;
type Ok = i64;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_ping {
}
impl crate::QgaCommand for guest_ping { }
impl ::qapi_spec::Command for guest_ping {
const NAME: &'static str = "guest-ping";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_get_time {
}
impl crate::QgaCommand for guest_get_time { }
impl ::qapi_spec::Command for guest_get_time {
const NAME: &'static str = "guest-get-time";
const ALLOW_OOB: bool = false;
type Ok = i64;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_set_time {
#[serde(rename = "time", default, skip_serializing_if = "Option::is_none")]
pub time: Option<i64>,
}
impl crate::QgaCommand for guest_set_time { }
impl ::qapi_spec::Command for guest_set_time {
const NAME: &'static str = "guest-set-time";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_info {
}
impl crate::QgaCommand for guest_info { }
impl ::qapi_spec::Command for guest_info {
const NAME: &'static str = "guest-info";
const ALLOW_OOB: bool = false;
type Ok = GuestAgentInfo;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_shutdown {
#[serde(rename = "mode", default, skip_serializing_if = "Option::is_none")]
pub mode: Option<GuestShutdownMode>,
}
impl crate::QgaCommand for guest_shutdown { }
impl ::qapi_spec::Command for guest_shutdown {
const NAME: &'static str = "guest-shutdown";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_file_open {
#[serde(rename = "mode", default, skip_serializing_if = "Option::is_none")]
pub mode: Option<::std::string::String>,
#[serde(rename = "path")]
pub path: ::std::string::String,
}
impl crate::QgaCommand for guest_file_open { }
impl ::qapi_spec::Command for guest_file_open {
const NAME: &'static str = "guest-file-open";
const ALLOW_OOB: bool = false;
type Ok = i64;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_file_close {
#[serde(rename = "handle")]
pub handle: i64,
}
impl crate::QgaCommand for guest_file_close { }
impl ::qapi_spec::Command for guest_file_close {
const NAME: &'static str = "guest-file-close";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_file_read {
#[serde(rename = "count", default, skip_serializing_if = "Option::is_none")]
pub count: Option<i64>,
#[serde(rename = "handle")]
pub handle: i64,
}
impl crate::QgaCommand for guest_file_read { }
impl ::qapi_spec::Command for guest_file_read {
const NAME: &'static str = "guest-file-read";
const ALLOW_OOB: bool = false;
type Ok = GuestFileRead;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_file_write {
#[serde(rename = "count", default, skip_serializing_if = "Option::is_none")]
pub count: Option<i64>,
#[serde(rename = "buf-b64", with = "::qapi_spec::base64")]
pub buf_b64: Vec<u8>,
#[serde(rename = "handle")]
pub handle: i64,
}
impl crate::QgaCommand for guest_file_write { }
impl ::qapi_spec::Command for guest_file_write {
const NAME: &'static str = "guest-file-write";
const ALLOW_OOB: bool = false;
type Ok = GuestFileWrite;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum QGASeek {
#[serde(rename = "set")] set,
#[serde(rename = "cur")] cur,
#[serde(rename = "end")] end,
}
impl ::core::str::FromStr for QGASeek {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for QGASeek {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 3;
const VARIANTS: &'static [Self] = &[
QGASeek::set,
QGASeek::cur,
QGASeek::end,
];
const NAMES: &'static [&'static str] = &[
"set",
"cur",
"end",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GuestFileWhence {
#[serde(rename = "name")] name(QGASeek),
#[serde(rename = "value")] value(i64),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_file_seek {
#[serde(rename = "handle")]
pub handle: i64,
#[serde(rename = "offset")]
pub offset: i64,
#[serde(rename = "whence")]
pub whence: GuestFileWhence,
}
impl crate::QgaCommand for guest_file_seek { }
impl ::qapi_spec::Command for guest_file_seek {
const NAME: &'static str = "guest-file-seek";
const ALLOW_OOB: bool = false;
type Ok = GuestFileSeek;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_file_flush {
#[serde(rename = "handle")]
pub handle: i64,
}
impl crate::QgaCommand for guest_file_flush { }
impl ::qapi_spec::Command for guest_file_flush {
const NAME: &'static str = "guest-file-flush";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum GuestFsfreezeStatus {
#[serde(rename = "thawed")] thawed,
#[serde(rename = "frozen")] frozen,
}
impl ::core::str::FromStr for GuestFsfreezeStatus {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for GuestFsfreezeStatus {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
GuestFsfreezeStatus::thawed,
GuestFsfreezeStatus::frozen,
];
const NAMES: &'static [&'static str] = &[
"thawed",
"frozen",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_fsfreeze_status {
}
impl crate::QgaCommand for guest_fsfreeze_status { }
impl ::qapi_spec::Command for guest_fsfreeze_status {
const NAME: &'static str = "guest-fsfreeze-status";
const ALLOW_OOB: bool = false;
type Ok = GuestFsfreezeStatus;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_fsfreeze_freeze {
}
impl crate::QgaCommand for guest_fsfreeze_freeze { }
impl ::qapi_spec::Command for guest_fsfreeze_freeze {
const NAME: &'static str = "guest-fsfreeze-freeze";
const ALLOW_OOB: bool = false;
type Ok = i64;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_fsfreeze_freeze_list {
#[serde(rename = "mountpoints", default, skip_serializing_if = "Option::is_none")]
pub mountpoints: Option<Vec<::std::string::String>>,
}
impl crate::QgaCommand for guest_fsfreeze_freeze_list { }
impl ::qapi_spec::Command for guest_fsfreeze_freeze_list {
const NAME: &'static str = "guest-fsfreeze-freeze-list";
const ALLOW_OOB: bool = false;
type Ok = i64;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_fsfreeze_thaw {
}
impl crate::QgaCommand for guest_fsfreeze_thaw { }
impl ::qapi_spec::Command for guest_fsfreeze_thaw {
const NAME: &'static str = "guest-fsfreeze-thaw";
const ALLOW_OOB: bool = false;
type Ok = i64;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_fstrim {
#[serde(rename = "minimum", default, skip_serializing_if = "Option::is_none")]
pub minimum: Option<i64>,
}
impl crate::QgaCommand for guest_fstrim { }
impl ::qapi_spec::Command for guest_fstrim {
const NAME: &'static str = "guest-fstrim";
const ALLOW_OOB: bool = false;
type Ok = GuestFilesystemTrimResponse;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_suspend_disk {
}
impl crate::QgaCommand for guest_suspend_disk { }
impl ::qapi_spec::Command for guest_suspend_disk {
const NAME: &'static str = "guest-suspend-disk";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_suspend_ram {
}
impl crate::QgaCommand for guest_suspend_ram { }
impl ::qapi_spec::Command for guest_suspend_ram {
const NAME: &'static str = "guest-suspend-ram";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_suspend_hybrid {
}
impl crate::QgaCommand for guest_suspend_hybrid { }
impl ::qapi_spec::Command for guest_suspend_hybrid {
const NAME: &'static str = "guest-suspend-hybrid";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum GuestIpAddressType {
#[serde(rename = "ipv4")] ipv4,
#[serde(rename = "ipv6")] ipv6,
}
impl ::core::str::FromStr for GuestIpAddressType {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for GuestIpAddressType {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
GuestIpAddressType::ipv4,
GuestIpAddressType::ipv6,
];
const NAMES: &'static [&'static str] = &[
"ipv4",
"ipv6",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_network_get_interfaces {
}
impl crate::QgaCommand for guest_network_get_interfaces { }
impl ::qapi_spec::Command for guest_network_get_interfaces {
const NAME: &'static str = "guest-network-get-interfaces";
const ALLOW_OOB: bool = false;
type Ok = Vec<GuestNetworkInterface>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_get_vcpus {
}
impl crate::QgaCommand for guest_get_vcpus { }
impl ::qapi_spec::Command for guest_get_vcpus {
const NAME: &'static str = "guest-get-vcpus";
const ALLOW_OOB: bool = false;
type Ok = Vec<GuestLogicalProcessor>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_set_vcpus {
#[serde(rename = "vcpus")]
pub vcpus: Vec<GuestLogicalProcessor>,
}
impl crate::QgaCommand for guest_set_vcpus { }
impl ::qapi_spec::Command for guest_set_vcpus {
const NAME: &'static str = "guest-set-vcpus";
const ALLOW_OOB: bool = false;
type Ok = i64;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum GuestDiskBusType {
#[serde(rename = "ide")] ide,
#[serde(rename = "fdc")] fdc,
#[serde(rename = "scsi")] scsi,
#[serde(rename = "virtio")] virtio,
#[serde(rename = "xen")] xen,
#[serde(rename = "usb")] usb,
#[serde(rename = "uml")] uml,
#[serde(rename = "sata")] sata,
#[serde(rename = "sd")] sd,
#[serde(rename = "unknown")] unknown,
#[serde(rename = "ieee1394")] ieee1394,
#[serde(rename = "ssa")] ssa,
#[serde(rename = "fibre")] fibre,
#[serde(rename = "raid")] raid,
#[serde(rename = "iscsi")] iscsi,
#[serde(rename = "sas")] sas,
#[serde(rename = "mmc")] mmc,
#[serde(rename = "virtual")] virtual_,
#[serde(rename = "file-backed-virtual")] file_backed_virtual,
#[serde(rename = "nvme")] nvme,
}
impl ::core::str::FromStr for GuestDiskBusType {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for GuestDiskBusType {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 20;
const VARIANTS: &'static [Self] = &[
GuestDiskBusType::ide,
GuestDiskBusType::fdc,
GuestDiskBusType::scsi,
GuestDiskBusType::virtio,
GuestDiskBusType::xen,
GuestDiskBusType::usb,
GuestDiskBusType::uml,
GuestDiskBusType::sata,
GuestDiskBusType::sd,
GuestDiskBusType::unknown,
GuestDiskBusType::ieee1394,
GuestDiskBusType::ssa,
GuestDiskBusType::fibre,
GuestDiskBusType::raid,
GuestDiskBusType::iscsi,
GuestDiskBusType::sas,
GuestDiskBusType::mmc,
GuestDiskBusType::virtual_,
GuestDiskBusType::file_backed_virtual,
GuestDiskBusType::nvme,
];
const NAMES: &'static [&'static str] = &[
"ide",
"fdc",
"scsi",
"virtio",
"xen",
"usb",
"uml",
"sata",
"sd",
"unknown",
"ieee1394",
"ssa",
"fibre",
"raid",
"iscsi",
"sas",
"mmc",
"virtual",
"file-backed-virtual",
"nvme",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_get_disks {
}
impl crate::QgaCommand for guest_get_disks { }
impl ::qapi_spec::Command for guest_get_disks {
const NAME: &'static str = "guest-get-disks";
const ALLOW_OOB: bool = false;
type Ok = Vec<GuestDiskInfo>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_get_fsinfo {
}
impl crate::QgaCommand for guest_get_fsinfo { }
impl ::qapi_spec::Command for guest_get_fsinfo {
const NAME: &'static str = "guest-get-fsinfo";
const ALLOW_OOB: bool = false;
type Ok = Vec<GuestFilesystemInfo>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_set_user_password {
#[serde(rename = "crypted")]
pub crypted: bool,
#[serde(rename = "password", with = "::qapi_spec::base64")]
pub password: Vec<u8>,
#[serde(rename = "username")]
pub username: ::std::string::String,
}
impl crate::QgaCommand for guest_set_user_password { }
impl ::qapi_spec::Command for guest_set_user_password {
const NAME: &'static str = "guest-set-user-password";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_get_memory_blocks {
}
impl crate::QgaCommand for guest_get_memory_blocks { }
impl ::qapi_spec::Command for guest_get_memory_blocks {
const NAME: &'static str = "guest-get-memory-blocks";
const ALLOW_OOB: bool = false;
type Ok = Vec<GuestMemoryBlock>;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum GuestMemoryBlockResponseType {
#[serde(rename = "success")] success,
#[serde(rename = "not-found")] not_found,
#[serde(rename = "operation-not-supported")] operation_not_supported,
#[serde(rename = "operation-failed")] operation_failed,
}
impl ::core::str::FromStr for GuestMemoryBlockResponseType {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for GuestMemoryBlockResponseType {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 4;
const VARIANTS: &'static [Self] = &[
GuestMemoryBlockResponseType::success,
GuestMemoryBlockResponseType::not_found,
GuestMemoryBlockResponseType::operation_not_supported,
GuestMemoryBlockResponseType::operation_failed,
];
const NAMES: &'static [&'static str] = &[
"success",
"not-found",
"operation-not-supported",
"operation-failed",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_set_memory_blocks {
#[serde(rename = "mem-blks")]
pub mem_blks: Vec<GuestMemoryBlock>,
}
impl crate::QgaCommand for guest_set_memory_blocks { }
impl ::qapi_spec::Command for guest_set_memory_blocks {
const NAME: &'static str = "guest-set-memory-blocks";
const ALLOW_OOB: bool = false;
type Ok = Vec<GuestMemoryBlockResponse>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_get_memory_block_info {
}
impl crate::QgaCommand for guest_get_memory_block_info { }
impl ::qapi_spec::Command for guest_get_memory_block_info {
const NAME: &'static str = "guest-get-memory-block-info";
const ALLOW_OOB: bool = false;
type Ok = GuestMemoryBlockInfo;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_exec_status {
#[serde(rename = "pid")]
pub pid: i64,
}
impl crate::QgaCommand for guest_exec_status { }
impl ::qapi_spec::Command for guest_exec_status {
const NAME: &'static str = "guest-exec-status";
const ALLOW_OOB: bool = false;
type Ok = GuestExecStatus;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum GuestExecCaptureOutputMode {
#[serde(rename = "none")] none,
#[serde(rename = "stdout")] stdout,
#[serde(rename = "stderr")] stderr,
#[serde(rename = "separated")] separated,
#[serde(rename = "merged")] merged,
}
impl ::core::str::FromStr for GuestExecCaptureOutputMode {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for GuestExecCaptureOutputMode {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 5;
const VARIANTS: &'static [Self] = &[
GuestExecCaptureOutputMode::none,
GuestExecCaptureOutputMode::stdout,
GuestExecCaptureOutputMode::stderr,
GuestExecCaptureOutputMode::separated,
GuestExecCaptureOutputMode::merged,
];
const NAMES: &'static [&'static str] = &[
"none",
"stdout",
"stderr",
"separated",
"merged",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GuestExecCaptureOutput {
#[serde(rename = "flag")] flag(bool),
#[serde(rename = "mode")] mode(GuestExecCaptureOutputMode),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_exec {
#[serde(rename = "arg", default, skip_serializing_if = "Option::is_none")]
pub arg: Option<Vec<::std::string::String>>,
#[serde(rename = "capture-output", default, skip_serializing_if = "Option::is_none")]
pub capture_output: Option<GuestExecCaptureOutput>,
#[serde(rename = "env", default, skip_serializing_if = "Option::is_none")]
pub env: Option<Vec<::std::string::String>>,
#[serde(rename = "input-data", with = "::qapi_spec::base64_opt", default, skip_serializing_if = "Option::is_none")]
pub input_data: Option<Vec<u8>>,
#[serde(rename = "path")]
pub path: ::std::string::String,
}
impl crate::QgaCommand for guest_exec { }
impl ::qapi_spec::Command for guest_exec {
const NAME: &'static str = "guest-exec";
const ALLOW_OOB: bool = false;
type Ok = GuestExec;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_get_host_name {
}
impl crate::QgaCommand for guest_get_host_name { }
impl ::qapi_spec::Command for guest_get_host_name {
const NAME: &'static str = "guest-get-host-name";
const ALLOW_OOB: bool = false;
type Ok = GuestHostName;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_get_users {
}
impl crate::QgaCommand for guest_get_users { }
impl ::qapi_spec::Command for guest_get_users {
const NAME: &'static str = "guest-get-users";
const ALLOW_OOB: bool = false;
type Ok = Vec<GuestUser>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_get_timezone {
}
impl crate::QgaCommand for guest_get_timezone { }
impl ::qapi_spec::Command for guest_get_timezone {
const NAME: &'static str = "guest-get-timezone";
const ALLOW_OOB: bool = false;
type Ok = GuestTimezone;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_get_osinfo {
}
impl crate::QgaCommand for guest_get_osinfo { }
impl ::qapi_spec::Command for guest_get_osinfo {
const NAME: &'static str = "guest-get-osinfo";
const ALLOW_OOB: bool = false;
type Ok = GuestOSInfo;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum GuestDeviceType {
#[serde(rename = "pci")] pci,
}
impl ::core::str::FromStr for GuestDeviceType {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for GuestDeviceType {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 1;
const VARIANTS: &'static [Self] = &[
GuestDeviceType::pci,
];
const NAMES: &'static [&'static str] = &[
"pci",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_get_devices {
}
impl crate::QgaCommand for guest_get_devices { }
impl ::qapi_spec::Command for guest_get_devices {
const NAME: &'static str = "guest-get-devices";
const ALLOW_OOB: bool = false;
type Ok = Vec<GuestDeviceInfo>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_ssh_get_authorized_keys {
#[serde(rename = "username")]
pub username: ::std::string::String,
}
impl crate::QgaCommand for guest_ssh_get_authorized_keys { }
impl ::qapi_spec::Command for guest_ssh_get_authorized_keys {
const NAME: &'static str = "guest-ssh-get-authorized-keys";
const ALLOW_OOB: bool = false;
type Ok = GuestAuthorizedKeys;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_ssh_add_authorized_keys {
#[serde(rename = "reset", default, skip_serializing_if = "Option::is_none")]
pub reset: Option<bool>,
#[serde(rename = "keys")]
pub keys: Vec<::std::string::String>,
#[serde(rename = "username")]
pub username: ::std::string::String,
}
impl crate::QgaCommand for guest_ssh_add_authorized_keys { }
impl ::qapi_spec::Command for guest_ssh_add_authorized_keys {
const NAME: &'static str = "guest-ssh-add-authorized-keys";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_ssh_remove_authorized_keys {
#[serde(rename = "keys")]
pub keys: Vec<::std::string::String>,
#[serde(rename = "username")]
pub username: ::std::string::String,
}
impl crate::QgaCommand for guest_ssh_remove_authorized_keys { }
impl ::qapi_spec::Command for guest_ssh_remove_authorized_keys {
const NAME: &'static str = "guest-ssh-remove-authorized-keys";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_get_diskstats {
}
impl crate::QgaCommand for guest_get_diskstats { }
impl ::qapi_spec::Command for guest_get_diskstats {
const NAME: &'static str = "guest-get-diskstats";
const ALLOW_OOB: bool = false;
type Ok = Vec<GuestDiskStatsInfo>;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum GuestCpuStatsType {
#[serde(rename = "linux")] linux,
}
impl ::core::str::FromStr for GuestCpuStatsType {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for GuestCpuStatsType {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 1;
const VARIANTS: &'static [Self] = &[
GuestCpuStatsType::linux,
];
const NAMES: &'static [&'static str] = &[
"linux",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_get_cpustats {
}
impl crate::QgaCommand for guest_get_cpustats { }
impl ::qapi_spec::Command for guest_get_cpustats {
const NAME: &'static str = "guest-get-cpustats";
const ALLOW_OOB: bool = false;
type Ok = Vec<GuestCpuStats>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum GuestDiskSmart {
#[serde(rename = "nvme")]
nvme(GuestNVMeSmart),
#[serde(rename = "ide")]
ide,
#[serde(rename = "fdc")]
fdc,
#[serde(rename = "scsi")]
scsi,
#[serde(rename = "virtio")]
virtio,
#[serde(rename = "xen")]
xen,
#[serde(rename = "usb")]
usb,
#[serde(rename = "uml")]
uml,
#[serde(rename = "sata")]
sata,
#[serde(rename = "sd")]
sd,
#[serde(rename = "unknown")]
unknown,
#[serde(rename = "ieee1394")]
ieee1394,
#[serde(rename = "ssa")]
ssa,
#[serde(rename = "fibre")]
fibre,
#[serde(rename = "raid")]
raid,
#[serde(rename = "iscsi")]
iscsi,
#[serde(rename = "sas")]
sas,
#[serde(rename = "mmc")]
mmc,
#[serde(rename = "virtual")]
virtual_,
#[serde(rename = "file-backed-virtual")]
file_backed_virtual,
}
impl GuestDiskSmart {
pub fn type_(&self) -> GuestDiskBusType {
match *self {
GuestDiskSmart::nvme { .. } => GuestDiskBusType::nvme,
GuestDiskSmart::ide { .. } => GuestDiskBusType::ide,
GuestDiskSmart::fdc { .. } => GuestDiskBusType::fdc,
GuestDiskSmart::scsi { .. } => GuestDiskBusType::scsi,
GuestDiskSmart::virtio { .. } => GuestDiskBusType::virtio,
GuestDiskSmart::xen { .. } => GuestDiskBusType::xen,
GuestDiskSmart::usb { .. } => GuestDiskBusType::usb,
GuestDiskSmart::uml { .. } => GuestDiskBusType::uml,
GuestDiskSmart::sata { .. } => GuestDiskBusType::sata,
GuestDiskSmart::sd { .. } => GuestDiskBusType::sd,
GuestDiskSmart::unknown { .. } => GuestDiskBusType::unknown,
GuestDiskSmart::ieee1394 { .. } => GuestDiskBusType::ieee1394,
GuestDiskSmart::ssa { .. } => GuestDiskBusType::ssa,
GuestDiskSmart::fibre { .. } => GuestDiskBusType::fibre,
GuestDiskSmart::raid { .. } => GuestDiskBusType::raid,
GuestDiskSmart::iscsi { .. } => GuestDiskBusType::iscsi,
GuestDiskSmart::sas { .. } => GuestDiskBusType::sas,
GuestDiskSmart::mmc { .. } => GuestDiskBusType::mmc,
GuestDiskSmart::virtual_ { .. } => GuestDiskBusType::virtual_,
GuestDiskSmart::file_backed_virtual { .. } => GuestDiskBusType::file_backed_virtual,
}
}
}
impl From<GuestNVMeSmart> for GuestDiskSmart {
fn from(val: GuestNVMeSmart) -> Self {
Self::nvme(val)
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum GuestDeviceId {
#[serde(rename = "pci")]
pci(GuestDeviceIdPCI),
}
impl GuestDeviceId {
pub fn type_(&self) -> GuestDeviceType {
match *self {
GuestDeviceId::pci { .. } => GuestDeviceType::pci,
}
}
}
impl From<GuestDeviceIdPCI> for GuestDeviceId {
fn from(val: GuestDeviceIdPCI) -> Self {
Self::pci(val)
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum GuestCpuStats {
#[serde(rename = "linux")]
linux(GuestLinuxCpuStats),
}
impl GuestCpuStats {
pub fn type_(&self) -> GuestCpuStatsType {
match *self {
GuestCpuStats::linux { .. } => GuestCpuStatsType::linux,
}
}
}
impl From<GuestLinuxCpuStats> for GuestCpuStats {
fn from(val: GuestLinuxCpuStats) -> Self {
Self::linux(val)
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestAgentCommandInfo {
#[serde(rename = "enabled")]
pub enabled: bool,
#[serde(rename = "name")]
pub name: ::std::string::String,
#[serde(rename = "success-response")]
pub success_response: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestAgentInfo {
#[serde(rename = "supported_commands")]
pub supported_commands: Vec<GuestAgentCommandInfo>,
#[serde(rename = "version")]
pub version: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestAuthorizedKeys {
#[serde(rename = "keys")]
pub keys: Vec<::std::string::String>,
}
impl<T: Into<Vec<::std::string::String>>> From<T> for GuestAuthorizedKeys {
fn from(val: T) -> Self {
Self {
keys: val.into(),
}
}
}
impl AsRef<Vec<::std::string::String>> for GuestAuthorizedKeys {
fn as_ref(&self) -> &Vec<::std::string::String> {
&self.keys
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestCCWAddress {
#[serde(rename = "cssid")]
pub cssid: i64,
#[serde(rename = "devno")]
pub devno: i64,
#[serde(rename = "ssid")]
pub ssid: i64,
#[serde(rename = "subchno")]
pub subchno: i64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestDeviceIdPCI {
#[serde(rename = "device-id")]
pub device_id: u16,
#[serde(rename = "vendor-id")]
pub vendor_id: u16,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestDeviceInfo {
#[serde(rename = "driver-date", default, skip_serializing_if = "Option::is_none")]
pub driver_date: Option<i64>,
#[serde(rename = "driver-version", default, skip_serializing_if = "Option::is_none")]
pub driver_version: Option<::std::string::String>,
#[serde(rename = "id", default, skip_serializing_if = "Option::is_none")]
pub id: Option<GuestDeviceId>,
#[serde(rename = "driver-name")]
pub driver_name: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestDiskAddress {
#[serde(rename = "ccw-address", default, skip_serializing_if = "Option::is_none")]
pub ccw_address: Option<GuestCCWAddress>,
#[serde(rename = "dev", default, skip_serializing_if = "Option::is_none")]
pub dev: Option<::std::string::String>,
#[serde(rename = "serial", default, skip_serializing_if = "Option::is_none")]
pub serial: Option<::std::string::String>,
#[serde(rename = "bus")]
pub bus: i64,
#[serde(rename = "bus-type")]
pub bus_type: GuestDiskBusType,
#[serde(rename = "pci-controller")]
pub pci_controller: GuestPCIAddress,
#[serde(rename = "target")]
pub target: i64,
#[serde(rename = "unit")]
pub unit: i64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestDiskInfo {
#[serde(rename = "address", default, skip_serializing_if = "Option::is_none")]
pub address: Option<GuestDiskAddress>,
#[serde(rename = "alias", default, skip_serializing_if = "Option::is_none")]
pub alias: Option<::std::string::String>,
#[serde(rename = "dependencies", default, skip_serializing_if = "Option::is_none")]
pub dependencies: Option<Vec<::std::string::String>>,
#[serde(rename = "smart", default, skip_serializing_if = "Option::is_none")]
pub smart: Option<GuestDiskSmart>,
#[serde(rename = "name")]
pub name: ::std::string::String,
#[serde(rename = "partition")]
pub partition: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct GuestDiskStats {
#[serde(rename = "discard-ios", default, skip_serializing_if = "Option::is_none")]
pub discard_ios: Option<u64>,
#[serde(rename = "discard-merges", default, skip_serializing_if = "Option::is_none")]
pub discard_merges: Option<u64>,
#[serde(rename = "discard-sectors", default, skip_serializing_if = "Option::is_none")]
pub discard_sectors: Option<u64>,
#[serde(rename = "discard-ticks", default, skip_serializing_if = "Option::is_none")]
pub discard_ticks: Option<u64>,
#[serde(rename = "flush-ios", default, skip_serializing_if = "Option::is_none")]
pub flush_ios: Option<u64>,
#[serde(rename = "flush-ticks", default, skip_serializing_if = "Option::is_none")]
pub flush_ticks: Option<u64>,
#[serde(rename = "ios-pgr", default, skip_serializing_if = "Option::is_none")]
pub ios_pgr: Option<u64>,
#[serde(rename = "read-ios", default, skip_serializing_if = "Option::is_none")]
pub read_ios: Option<u64>,
#[serde(rename = "read-merges", default, skip_serializing_if = "Option::is_none")]
pub read_merges: Option<u64>,
#[serde(rename = "read-sectors", default, skip_serializing_if = "Option::is_none")]
pub read_sectors: Option<u64>,
#[serde(rename = "read-ticks", default, skip_serializing_if = "Option::is_none")]
pub read_ticks: Option<u64>,
#[serde(rename = "total-ticks", default, skip_serializing_if = "Option::is_none")]
pub total_ticks: Option<u64>,
#[serde(rename = "weight-ticks", default, skip_serializing_if = "Option::is_none")]
pub weight_ticks: Option<u64>,
#[serde(rename = "write-ios", default, skip_serializing_if = "Option::is_none")]
pub write_ios: Option<u64>,
#[serde(rename = "write-merges", default, skip_serializing_if = "Option::is_none")]
pub write_merges: Option<u64>,
#[serde(rename = "write-sectors", default, skip_serializing_if = "Option::is_none")]
pub write_sectors: Option<u64>,
#[serde(rename = "write-ticks", default, skip_serializing_if = "Option::is_none")]
pub write_ticks: Option<u64>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestDiskStatsInfo {
#[serde(rename = "major")]
pub major: u64,
#[serde(rename = "minor")]
pub minor: u64,
#[serde(rename = "name")]
pub name: ::std::string::String,
#[serde(rename = "stats")]
pub stats: GuestDiskStats,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestExec {
#[serde(rename = "pid")]
pub pid: i64,
}
impl<T: Into<i64>> From<T> for GuestExec {
fn from(val: T) -> Self {
Self {
pid: val.into(),
}
}
}
impl AsRef<i64> for GuestExec {
fn as_ref(&self) -> &i64 {
&self.pid
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestExecStatus {
#[serde(rename = "err-data", with = "::qapi_spec::base64_opt", default, skip_serializing_if = "Option::is_none")]
pub err_data: Option<Vec<u8>>,
#[serde(rename = "err-truncated", default, skip_serializing_if = "Option::is_none")]
pub err_truncated: Option<bool>,
#[serde(rename = "exitcode", default, skip_serializing_if = "Option::is_none")]
pub exitcode: Option<i64>,
#[serde(rename = "out-data", with = "::qapi_spec::base64_opt", default, skip_serializing_if = "Option::is_none")]
pub out_data: Option<Vec<u8>>,
#[serde(rename = "out-truncated", default, skip_serializing_if = "Option::is_none")]
pub out_truncated: Option<bool>,
#[serde(rename = "signal", default, skip_serializing_if = "Option::is_none")]
pub signal: Option<i64>,
#[serde(rename = "exited")]
pub exited: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestFileRead {
#[serde(rename = "buf-b64", with = "::qapi_spec::base64")]
pub buf_b64: Vec<u8>,
#[serde(rename = "count")]
pub count: i64,
#[serde(rename = "eof")]
pub eof: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestFileSeek {
#[serde(rename = "eof")]
pub eof: bool,
#[serde(rename = "position")]
pub position: i64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestFileWrite {
#[serde(rename = "count")]
pub count: i64,
#[serde(rename = "eof")]
pub eof: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestFilesystemInfo {
#[serde(rename = "total-bytes", default, skip_serializing_if = "Option::is_none")]
pub total_bytes: Option<u64>,
#[serde(rename = "used-bytes", default, skip_serializing_if = "Option::is_none")]
pub used_bytes: Option<u64>,
#[serde(rename = "disk")]
pub disk: Vec<GuestDiskAddress>,
#[serde(rename = "mountpoint")]
pub mountpoint: ::std::string::String,
#[serde(rename = "name")]
pub name: ::std::string::String,
#[serde(rename = "type")]
pub type_: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestFilesystemTrimResponse {
#[serde(rename = "paths")]
pub paths: Vec<GuestFilesystemTrimResult>,
}
impl<T: Into<Vec<GuestFilesystemTrimResult>>> From<T> for GuestFilesystemTrimResponse {
fn from(val: T) -> Self {
Self {
paths: val.into(),
}
}
}
impl AsRef<Vec<GuestFilesystemTrimResult>> for GuestFilesystemTrimResponse {
fn as_ref(&self) -> &Vec<GuestFilesystemTrimResult> {
&self.paths
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestFilesystemTrimResult {
#[serde(rename = "error", default, skip_serializing_if = "Option::is_none")]
pub error: Option<::std::string::String>,
#[serde(rename = "minimum", default, skip_serializing_if = "Option::is_none")]
pub minimum: Option<i64>,
#[serde(rename = "trimmed", default, skip_serializing_if = "Option::is_none")]
pub trimmed: Option<i64>,
#[serde(rename = "path")]
pub path: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestHostName {
#[serde(rename = "host-name")]
pub host_name: ::std::string::String,
}
impl<T: Into<::std::string::String>> From<T> for GuestHostName {
fn from(val: T) -> Self {
Self {
host_name: val.into(),
}
}
}
impl AsRef<::std::string::String> for GuestHostName {
fn as_ref(&self) -> &::std::string::String {
&self.host_name
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestIpAddress {
#[serde(rename = "ip-address")]
pub ip_address: ::std::string::String,
#[serde(rename = "ip-address-type")]
pub ip_address_type: GuestIpAddressType,
#[serde(rename = "prefix")]
pub prefix: i64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestLinuxCpuStats {
#[serde(rename = "guest", default, skip_serializing_if = "Option::is_none")]
pub guest: Option<u64>,
#[serde(rename = "guestnice", default, skip_serializing_if = "Option::is_none")]
pub guestnice: Option<u64>,
#[serde(rename = "iowait", default, skip_serializing_if = "Option::is_none")]
pub iowait: Option<u64>,
#[serde(rename = "irq", default, skip_serializing_if = "Option::is_none")]
pub irq: Option<u64>,
#[serde(rename = "softirq", default, skip_serializing_if = "Option::is_none")]
pub softirq: Option<u64>,
#[serde(rename = "steal", default, skip_serializing_if = "Option::is_none")]
pub steal: Option<u64>,
#[serde(rename = "cpu")]
pub cpu: i64,
#[serde(rename = "idle")]
pub idle: u64,
#[serde(rename = "nice")]
pub nice: u64,
#[serde(rename = "system")]
pub system: u64,
#[serde(rename = "user")]
pub user: u64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestLogicalProcessor {
#[serde(rename = "can-offline", default, skip_serializing_if = "Option::is_none")]
pub can_offline: Option<bool>,
#[serde(rename = "logical-id")]
pub logical_id: i64,
#[serde(rename = "online")]
pub online: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestMemoryBlock {
#[serde(rename = "can-offline", default, skip_serializing_if = "Option::is_none")]
pub can_offline: Option<bool>,
#[serde(rename = "online")]
pub online: bool,
#[serde(rename = "phys-index")]
pub phys_index: u64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestMemoryBlockInfo {
#[serde(rename = "size")]
pub size: u64,
}
impl<T: Into<u64>> From<T> for GuestMemoryBlockInfo {
fn from(val: T) -> Self {
Self {
size: val.into(),
}
}
}
impl AsRef<u64> for GuestMemoryBlockInfo {
fn as_ref(&self) -> &u64 {
&self.size
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestMemoryBlockResponse {
#[serde(rename = "error-code", default, skip_serializing_if = "Option::is_none")]
pub error_code: Option<i64>,
#[serde(rename = "phys-index")]
pub phys_index: u64,
#[serde(rename = "response")]
pub response: GuestMemoryBlockResponseType,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestNVMeSmart {
#[serde(rename = "available-spare")]
pub available_spare: i64,
#[serde(rename = "available-spare-threshold")]
pub available_spare_threshold: i64,
#[serde(rename = "controller-busy-time-hi")]
pub controller_busy_time_hi: u64,
#[serde(rename = "controller-busy-time-lo")]
pub controller_busy_time_lo: u64,
#[serde(rename = "critical-warning")]
pub critical_warning: i64,
#[serde(rename = "data-units-read-hi")]
pub data_units_read_hi: u64,
#[serde(rename = "data-units-read-lo")]
pub data_units_read_lo: u64,
#[serde(rename = "data-units-written-hi")]
pub data_units_written_hi: u64,
#[serde(rename = "data-units-written-lo")]
pub data_units_written_lo: u64,
#[serde(rename = "host-read-commands-hi")]
pub host_read_commands_hi: u64,
#[serde(rename = "host-read-commands-lo")]
pub host_read_commands_lo: u64,
#[serde(rename = "host-write-commands-hi")]
pub host_write_commands_hi: u64,
#[serde(rename = "host-write-commands-lo")]
pub host_write_commands_lo: u64,
#[serde(rename = "media-errors-hi")]
pub media_errors_hi: u64,
#[serde(rename = "media-errors-lo")]
pub media_errors_lo: u64,
#[serde(rename = "number-of-error-log-entries-hi")]
pub number_of_error_log_entries_hi: u64,
#[serde(rename = "number-of-error-log-entries-lo")]
pub number_of_error_log_entries_lo: u64,
#[serde(rename = "percentage-used")]
pub percentage_used: i64,
#[serde(rename = "power-cycles-hi")]
pub power_cycles_hi: u64,
#[serde(rename = "power-cycles-lo")]
pub power_cycles_lo: u64,
#[serde(rename = "power-on-hours-hi")]
pub power_on_hours_hi: u64,
#[serde(rename = "power-on-hours-lo")]
pub power_on_hours_lo: u64,
#[serde(rename = "temperature")]
pub temperature: i64,
#[serde(rename = "unsafe-shutdowns-hi")]
pub unsafe_shutdowns_hi: u64,
#[serde(rename = "unsafe-shutdowns-lo")]
pub unsafe_shutdowns_lo: u64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestNetworkInterface {
#[serde(rename = "hardware-address", default, skip_serializing_if = "Option::is_none")]
pub hardware_address: Option<::std::string::String>,
#[serde(rename = "ip-addresses", default, skip_serializing_if = "Option::is_none")]
pub ip_addresses: Option<Vec<GuestIpAddress>>,
#[serde(rename = "statistics", default, skip_serializing_if = "Option::is_none")]
pub statistics: Option<GuestNetworkInterfaceStat>,
#[serde(rename = "name")]
pub name: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestNetworkInterfaceStat {
#[serde(rename = "rx-bytes")]
pub rx_bytes: u64,
#[serde(rename = "rx-dropped")]
pub rx_dropped: u64,
#[serde(rename = "rx-errs")]
pub rx_errs: u64,
#[serde(rename = "rx-packets")]
pub rx_packets: u64,
#[serde(rename = "tx-bytes")]
pub tx_bytes: u64,
#[serde(rename = "tx-dropped")]
pub tx_dropped: u64,
#[serde(rename = "tx-errs")]
pub tx_errs: u64,
#[serde(rename = "tx-packets")]
pub tx_packets: u64,
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct GuestOSInfo {
#[serde(rename = "id", default, skip_serializing_if = "Option::is_none")]
pub id: Option<::std::string::String>,
#[serde(rename = "kernel-release", default, skip_serializing_if = "Option::is_none")]
pub kernel_release: Option<::std::string::String>,
#[serde(rename = "kernel-version", default, skip_serializing_if = "Option::is_none")]
pub kernel_version: Option<::std::string::String>,
#[serde(rename = "machine", default, skip_serializing_if = "Option::is_none")]
pub machine: Option<::std::string::String>,
#[serde(rename = "name", default, skip_serializing_if = "Option::is_none")]
pub name: Option<::std::string::String>,
#[serde(rename = "pretty-name", default, skip_serializing_if = "Option::is_none")]
pub pretty_name: Option<::std::string::String>,
#[serde(rename = "variant", default, skip_serializing_if = "Option::is_none")]
pub variant: Option<::std::string::String>,
#[serde(rename = "variant-id", default, skip_serializing_if = "Option::is_none")]
pub variant_id: Option<::std::string::String>,
#[serde(rename = "version", default, skip_serializing_if = "Option::is_none")]
pub version: Option<::std::string::String>,
#[serde(rename = "version-id", default, skip_serializing_if = "Option::is_none")]
pub version_id: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestPCIAddress {
#[serde(rename = "bus")]
pub bus: i64,
#[serde(rename = "domain")]
pub domain: i64,
#[serde(rename = "function")]
pub function: i64,
#[serde(rename = "slot")]
pub slot: i64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestTimezone {
#[serde(rename = "zone", default, skip_serializing_if = "Option::is_none")]
pub zone: Option<::std::string::String>,
#[serde(rename = "offset")]
pub offset: i64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestUser {
#[serde(rename = "domain", default, skip_serializing_if = "Option::is_none")]
pub domain: Option<::std::string::String>,
#[serde(rename = "login-time")]
pub login_time: f64,
#[serde(rename = "user")]
pub user: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "event")]
pub enum Event {
}
impl Event {
pub fn timestamp(&self) -> ::qapi_spec::Timestamp {
match *self {
}
}
}