#[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 = "buf-b64", with = "::qapi_spec::base64")]
pub buf_b64: Vec<u8>,
	#[serde(rename = "handle")]
pub handle: isize,
}

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 = "crypted")]
pub crypted: bool,
	#[serde(rename = "username")]
pub username: ::std::string::String,
	#[serde(rename = "password", with = "::qapi_spec::base64")]
pub password: Vec<u8>,
}

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 = "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<bool>,
	#[serde(rename = "path")]
pub path: ::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 = "env", default, skip_serializing_if = "Option::is_none")]
pub env: 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 = "username")]
pub username: ::std::string::String,
	#[serde(rename = "reset", default, skip_serializing_if = "Option::is_none")]
pub reset: Option<bool>,
	#[serde(rename = "keys")]
pub keys: Vec<::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 = "username")]
pub username: ::std::string::String,
	#[serde(rename = "keys")]
pub keys: Vec<::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 GuestMemoryBlock {
#[serde(rename = "can-offline", default, skip_serializing_if = "Option::is_none")]
pub can_offline: Option<bool>,
#[serde(rename = "phys-index")]
pub phys_index: u64,
#[serde(rename = "online")]
pub online: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestExec {
#[serde(rename = "pid")]
pub pid: isize,
}

#[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 GuestLogicalProcessor {
#[serde(rename = "logical-id")]
pub logical_id: isize,
#[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 GuestDiskInfo {
#[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 = "partition")]
pub partition: bool,
#[serde(rename = "name")]
pub name: ::std::string::String,
#[serde(rename = "alias", default, skip_serializing_if = "Option::is_none")]
pub alias: Option<::std::string::String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestFilesystemInfo {
#[serde(rename = "mountpoint")]
pub mountpoint: ::std::string::String,
#[serde(rename = "used-bytes", default, skip_serializing_if = "Option::is_none")]
pub used_bytes: Option<u64>,
#[serde(rename = "name")]
pub name: ::std::string::String,
#[serde(rename = "disk")]
pub disk: Vec<GuestDiskAddress>,
#[serde(rename = "type")]
pub type_: ::std::string::String,
#[serde(rename = "total-bytes", default, skip_serializing_if = "Option::is_none")]
pub total_bytes: Option<u64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestMemoryBlockInfo {
#[serde(rename = "size")]
pub size: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestNetworkInterfaceStat {
#[serde(rename = "tx-packets")]
pub tx_packets: u64,
#[serde(rename = "rx-errs")]
pub rx_errs: u64,
#[serde(rename = "rx-bytes")]
pub rx_bytes: u64,
#[serde(rename = "rx-packets")]
pub rx_packets: u64,
#[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 = "tx-dropped")]
pub tx_dropped: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestDiskAddress {
#[serde(rename = "serial", default, skip_serializing_if = "Option::is_none")]
pub serial: Option<::std::string::String>,
#[serde(rename = "dev", default, skip_serializing_if = "Option::is_none")]
pub dev: Option<::std::string::String>,
#[serde(rename = "bus")]
pub bus: isize,
#[serde(rename = "target")]
pub target: isize,
#[serde(rename = "unit")]
pub unit: isize,
#[serde(rename = "pci-controller")]
pub pci_controller: GuestPCIAddress,
#[serde(rename = "bus-type")]
pub bus_type: GuestDiskBusType,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestFilesystemTrimResponse {
#[serde(rename = "paths")]
pub paths: Vec<GuestFilesystemTrimResult>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestOSInfo {
#[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 = "version", default, skip_serializing_if = "Option::is_none")]
pub version: Option<::std::string::String>,
#[serde(rename = "kernel-version", default, skip_serializing_if = "Option::is_none")]
pub kernel_version: Option<::std::string::String>,
#[serde(rename = "kernel-release", default, skip_serializing_if = "Option::is_none")]
pub kernel_release: Option<::std::string::String>,
#[serde(rename = "version-id", default, skip_serializing_if = "Option::is_none")]
pub version_id: Option<::std::string::String>,
#[serde(rename = "id", default, skip_serializing_if = "Option::is_none")]
pub id: 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 = "machine", default, skip_serializing_if = "Option::is_none")]
pub machine: 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 GuestAuthorizedKeys {
#[serde(rename = "keys")]
pub keys: Vec<::std::string::String>,
}

#[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 GuestFileWrite {
#[serde(rename = "count")]
pub count: isize,
#[serde(rename = "eof")]
pub eof: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestPCIAddress {
#[serde(rename = "bus")]
pub bus: isize,
#[serde(rename = "function")]
pub function: isize,
#[serde(rename = "slot")]
pub slot: isize,
#[serde(rename = "domain")]
pub domain: isize,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestFileRead {
#[serde(rename = "count")]
pub count: isize,
#[serde(rename = "eof")]
pub eof: bool,
#[serde(rename = "buf-b64", with = "::qapi_spec::base64")]
pub buf_b64: Vec<u8>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestIpAddress {
#[serde(rename = "prefix")]
pub prefix: isize,
#[serde(rename = "ip-address")]
pub ip_address: ::std::string::String,
#[serde(rename = "ip-address-type")]
pub ip_address_type: GuestIpAddressType,
}

#[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 = "exitcode", default, skip_serializing_if = "Option::is_none")]
pub exitcode: Option<isize>,
#[serde(rename = "signal", default, skip_serializing_if = "Option::is_none")]
pub signal: Option<isize>,
#[serde(rename = "out-truncated", default, skip_serializing_if = "Option::is_none")]
pub out_truncated: Option<bool>,
#[serde(rename = "err-truncated", default, skip_serializing_if = "Option::is_none")]
pub err_truncated: Option<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 = "exited")]
pub exited: bool,
}

#[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 GuestUser {
#[serde(rename = "user")]
pub user: ::std::string::String,
#[serde(rename = "domain", default, skip_serializing_if = "Option::is_none")]
pub domain: Option<::std::string::String>,
#[serde(rename = "login-time")]
pub login_time: f64,
}

#[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 GuestFileSeek {
#[serde(rename = "position")]
pub position: isize,
#[serde(rename = "eof")]
pub eof: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestDeviceInfo {
#[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>,
#[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>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestMemoryBlockResponse {
#[serde(rename = "error-code", default, skip_serializing_if = "Option::is_none")]
pub error_code: Option<isize>,
#[serde(rename = "response")]
pub response: GuestMemoryBlockResponseType,
#[serde(rename = "phys-index")]
pub phys_index: u64,
}

#[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 = "path")]
pub path: ::std::string::String,
#[serde(rename = "minimum", default, skip_serializing_if = "Option::is_none")]
pub minimum: Option<isize>,
#[serde(rename = "trimmed", default, skip_serializing_if = "Option::is_none")]
pub trimmed: Option<isize>,
}

#[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)]
#[serde(tag = "event")]
pub enum Event {
}

impl Event {
    pub fn timestamp(&self) -> ::qapi_spec::Timestamp {
        match *self {

        }
    }
}