#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_sync_delimited {
#[serde(rename = "id")]
pub id: isize,
}
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 = isize;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_sync {
#[serde(rename = "id")]
pub id: isize,
}
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 = isize;
}
#[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 = isize;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_set_time {
#[serde(rename = "time", default, skip_serializing_if = "Option::is_none")]
pub time: Option<isize>,
}
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 = isize;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_file_close {
#[serde(rename = "handle")]
pub handle: isize,
}
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 = "handle")]
pub handle: isize,
#[serde(rename = "count", default, skip_serializing_if = "Option::is_none")]
pub count: Option<isize>,
}
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<isize>,
#[serde(rename = "handle")]
pub handle: isize,
#[serde(rename = "buf-b64", with = "::qapi_spec::base64")]
pub buf_b64: Vec<u8>,
}
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(isize),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_file_seek {
#[serde(rename = "whence")]
pub whence: GuestFileWhence,
#[serde(rename = "handle")]
pub handle: isize,
#[serde(rename = "offset")]
pub offset: isize,
}
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: isize,
}
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 = isize;
}
#[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 = isize;
}
#[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 = isize;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct guest_fstrim {
#[serde(rename = "minimum", default, skip_serializing_if = "Option::is_none")]
pub minimum: Option<isize>,
}
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 = isize;
}
#[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,
}
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 = 19;
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,
];
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",
];
}
#[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 = "password", with = "::qapi_spec::base64")]
pub password: Vec<u8>,
#[serde(rename = "username")]
pub username: ::std::string::String,
#[serde(rename = "crypted")]
pub crypted: bool,
}
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: isize,
}
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, Clone, Serialize, Deserialize)]
pub struct guest_exec {
#[serde(rename = "input-data", with = "::qapi_spec::base64_opt", default, skip_serializing_if = "Option::is_none")]
pub input_data: Option<Vec<u8>>,
#[serde(rename = "env", default, skip_serializing_if = "Option::is_none")]
pub env: Option<Vec<::std::string::String>>,
#[serde(rename = "path")]
pub path: ::std::string::String,
#[serde(rename = "capture-output", default, skip_serializing_if = "Option::is_none")]
pub capture_output: Option<bool>,
#[serde(rename = "arg", default, skip_serializing_if = "Option::is_none")]
pub arg: Option<Vec<::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)]
#[serde(tag = "type")]
pub enum GuestDeviceId {
#[serde(rename = "pci")]
pci {
#[serde(flatten)] #[serde(rename = "pci")]
pci: GuestDeviceIdPCI,
},
}
impl GuestDeviceId {
pub fn type_(&self) -> GuestDeviceType {
match *self {
GuestDeviceId::pci { .. } => GuestDeviceType::pci,
}
}
}
#[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: isize,
#[serde(rename = "eof")]
pub eof: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestTimezone {
#[serde(rename = "offset")]
pub offset: isize,
#[serde(rename = "zone", default, skip_serializing_if = "Option::is_none")]
pub zone: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestAuthorizedKeys {
#[serde(rename = "keys")]
pub keys: Vec<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestExec {
#[serde(rename = "pid")]
pub pid: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestNetworkInterfaceStat {
#[serde(rename = "rx-dropped")]
pub rx_dropped: u64,
#[serde(rename = "tx-bytes")]
pub tx_bytes: u64,
#[serde(rename = "tx-errs")]
pub tx_errs: u64,
#[serde(rename = "rx-bytes")]
pub rx_bytes: u64,
#[serde(rename = "rx-packets")]
pub rx_packets: u64,
#[serde(rename = "rx-errs")]
pub rx_errs: u64,
#[serde(rename = "tx-dropped")]
pub tx_dropped: u64,
#[serde(rename = "tx-packets")]
pub tx_packets: u64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestFileWrite {
#[serde(rename = "eof")]
pub eof: bool,
#[serde(rename = "count")]
pub count: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestNetworkInterface {
#[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,
#[serde(rename = "hardware-address", default, skip_serializing_if = "Option::is_none")]
pub hardware_address: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestFilesystemInfo {
#[serde(rename = "name")]
pub name: ::std::string::String,
#[serde(rename = "type")]
pub type_: ::std::string::String,
#[serde(rename = "used-bytes", default, skip_serializing_if = "Option::is_none")]
pub used_bytes: Option<u64>,
#[serde(rename = "mountpoint")]
pub mountpoint: ::std::string::String,
#[serde(rename = "total-bytes", default, skip_serializing_if = "Option::is_none")]
pub total_bytes: Option<u64>,
#[serde(rename = "disk")]
pub disk: Vec<GuestDiskAddress>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestAgentCommandInfo {
#[serde(rename = "name")]
pub name: ::std::string::String,
#[serde(rename = "success-response")]
pub success_response: bool,
#[serde(rename = "enabled")]
pub enabled: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestUser {
#[serde(rename = "user")]
pub user: ::std::string::String,
#[serde(rename = "login-time")]
pub login_time: f64,
#[serde(rename = "domain", default, skip_serializing_if = "Option::is_none")]
pub domain: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestDiskAddress {
#[serde(rename = "bus-type")]
pub bus_type: GuestDiskBusType,
#[serde(rename = "dev", default, skip_serializing_if = "Option::is_none")]
pub dev: Option<::std::string::String>,
#[serde(rename = "pci-controller")]
pub pci_controller: GuestPCIAddress,
#[serde(rename = "bus")]
pub bus: isize,
#[serde(rename = "target")]
pub target: isize,
#[serde(rename = "unit")]
pub unit: isize,
#[serde(rename = "serial", default, skip_serializing_if = "Option::is_none")]
pub serial: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestLogicalProcessor {
#[serde(rename = "online")]
pub online: bool,
#[serde(rename = "logical-id")]
pub logical_id: isize,
#[serde(rename = "can-offline", default, skip_serializing_if = "Option::is_none")]
pub can_offline: Option<bool>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestFilesystemTrimResponse {
#[serde(rename = "paths")]
pub paths: Vec<GuestFilesystemTrimResult>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestDiskInfo {
#[serde(rename = "partition")]
pub partition: bool,
#[serde(rename = "name")]
pub name: ::std::string::String,
#[serde(rename = "dependencies", default, skip_serializing_if = "Option::is_none")]
pub dependencies: Option<Vec<::std::string::String>>,
#[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>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestMemoryBlock {
#[serde(rename = "phys-index")]
pub phys_index: u64,
#[serde(rename = "online")]
pub online: bool,
#[serde(rename = "can-offline", default, skip_serializing_if = "Option::is_none")]
pub can_offline: Option<bool>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestMemoryBlockResponse {
#[serde(rename = "phys-index")]
pub phys_index: u64,
#[serde(rename = "response")]
pub response: GuestMemoryBlockResponseType,
#[serde(rename = "error-code", default, skip_serializing_if = "Option::is_none")]
pub error_code: Option<isize>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestExecStatus {
#[serde(rename = "exited")]
pub exited: bool,
#[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<isize>,
#[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<isize>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestHostName {
#[serde(rename = "host-name")]
pub host_name: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestFileSeek {
#[serde(rename = "eof")]
pub eof: bool,
#[serde(rename = "position")]
pub position: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestIpAddress {
#[serde(rename = "ip-address-type")]
pub ip_address_type: GuestIpAddressType,
#[serde(rename = "prefix")]
pub prefix: isize,
#[serde(rename = "ip-address")]
pub ip_address: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestPCIAddress {
#[serde(rename = "slot")]
pub slot: isize,
#[serde(rename = "domain")]
pub domain: isize,
#[serde(rename = "function")]
pub function: isize,
#[serde(rename = "bus")]
pub bus: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestMemoryBlockInfo {
#[serde(rename = "size")]
pub size: u64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestAgentInfo {
#[serde(rename = "version")]
pub version: ::std::string::String,
#[serde(rename = "supported_commands")]
pub supported_commands: Vec<GuestAgentCommandInfo>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
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 = "name", default, skip_serializing_if = "Option::is_none")]
pub name: Option<::std::string::String>,
#[serde(rename = "variant-id", default, skip_serializing_if = "Option::is_none")]
pub variant_id: Option<::std::string::String>,
#[serde(rename = "machine", default, skip_serializing_if = "Option::is_none")]
pub machine: Option<::std::string::String>,
#[serde(rename = "pretty-name", default, skip_serializing_if = "Option::is_none")]
pub pretty_name: Option<::std::string::String>,
#[serde(rename = "version-id", default, skip_serializing_if = "Option::is_none")]
pub version_id: Option<::std::string::String>,
#[serde(rename = "version", default, skip_serializing_if = "Option::is_none")]
pub version: Option<::std::string::String>,
#[serde(rename = "variant", default, skip_serializing_if = "Option::is_none")]
pub variant: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestDeviceIdPCI {
#[serde(rename = "vendor-id")]
pub vendor_id: u16,
#[serde(rename = "device-id")]
pub device_id: u16,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestFilesystemTrimResult {
#[serde(rename = "path")]
pub path: ::std::string::String,
#[serde(rename = "error", default, skip_serializing_if = "Option::is_none")]
pub error: Option<::std::string::String>,
#[serde(rename = "trimmed", default, skip_serializing_if = "Option::is_none")]
pub trimmed: Option<isize>,
#[serde(rename = "minimum", default, skip_serializing_if = "Option::is_none")]
pub minimum: Option<isize>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestDeviceInfo {
#[serde(rename = "driver-name")]
pub driver_name: ::std::string::String,
#[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-date", default, skip_serializing_if = "Option::is_none")]
pub driver_date: Option<isize>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "event")]
pub enum Event {
}
impl Event {
pub fn timestamp(&self) -> ::qapi_spec::Timestamp {
match *self {
}
}
}