vim_rs 0.4.4

use std::sync::Arc;
use crate::core::client::{VimClient, Result};
/// The VsanIscsiTargetSystem exposes interfaces from vCenter to perform
/// vSAN iSCSI target service related operations.
/// 
/// To access these APIs from vCenter, user should possess correct privileges of
/// the target cluster: cluster edit privilege is required for the adding,
/// editing and removal of target, LUN, initiator and initiator group, while
/// system read/view privilege is required for the view of these entities.
/// The Managed Entity can be accessed through MOID of
/// vsan-cluster-iscsi-target-system, through vSAN service at both vCenter
/// server and ESXi host side.
#[derive(Clone)]
pub struct VsanIscsiTargetSystem {
    client: Arc<dyn VimClient>,
    mo_id: String,
}
impl VsanIscsiTargetSystem {
    pub fn new(client: Arc<dyn VimClient>, mo_id: &str) -> Self {
        Self {
            client,
            mo_id: mo_id.to_string(),
        }
    }
    /// Adds iSCSI initiator group to one cluster.  
    /// If the initiator group already exists, a VsanFault will be raised.
    /// 
    /// Some unhealthy status of the vSAN iSCSI service can also lead to this
    /// VsanFault exception, e.g., the unavailability of the home object.
    ///
    /// ## Parameters:
    ///
    /// ### cluster
    /// : reference to cluster resource.
    /// 
    /// ***Required privileges:*** Host.Inventory.EditCluster
    /// 
    /// Refers instance of *ClusterComputeResource*.
    ///
    /// ### initiator_group_name
    /// : the iSCSI initiator group name.
    ///
    /// ## Errors:
    ///
    /// Failure
    pub async fn vsan_vit_add_iscsi_initiator_group(&self, cluster: &crate::types::structs::ManagedObjectReference, initiator_group_name: &str) -> Result<()> {
        let input = VsanVitAddIscsiInitiatorGroupRequestType {cluster, initiator_group_name, };
        self.client.invoke_void("vsan", "VsanIscsiTargetSystem", &self.mo_id, "VsanVitAddIscsiInitiatorGroup", Some(&input)).await
    }
    /// Adds iSCSI initiators to one initiator group.  
    /// If the
    /// initiator group doesn't exist, or some of the initiators
    /// are already in the specified initiator
    /// group, a VsanFault will be raised.
    /// 
    /// Some unhealthy status of the vSAN iSCSI service can also lead to this
    /// VsanFault exception, e.g., the unavailability of the home object.
    ///
    /// ## Parameters:
    ///
    /// ### cluster
    /// : reference to cluster resource.
    /// 
    /// ***Required privileges:*** Host.Inventory.EditCluster
    /// 
    /// Refers instance of *ClusterComputeResource*.
    ///
    /// ### initiator_group_name
    /// : the initiator group name.
    ///
    /// ### initiator_names
    /// : the iSCSI initiator name list.
    ///
    /// ## Errors:
    ///
    /// Failure
    pub async fn vsan_vit_add_iscsi_initiators_to_group(&self, cluster: &crate::types::structs::ManagedObjectReference, initiator_group_name: &str, initiator_names: &[String]) -> Result<()> {
        let input = VsanVitAddIscsiInitiatorsToGroupRequestType {cluster, initiator_group_name, initiator_names, };
        self.client.invoke_void("vsan", "VsanIscsiTargetSystem", &self.mo_id, "VsanVitAddIscsiInitiatorsToGroup", Some(&input)).await
    }
    /// Adds iSCSI initiators or initiator groups to one target.  
    ///   
    /// If the target cannot be found or if there are
    /// initiators or initiator groups in the
    /// initiatorNames parameter are already associated with the specified target, a
    /// VsanFault will be raised.
    /// 
    /// Some unhealthy status of the vSAN iSCSI service can also lead to this
    /// VsanFault exception, e.g., the unavailability of the home object.
    ///
    /// ## Parameters:
    ///
    /// ### cluster
    /// : reference to cluster resource.
    /// 
    /// ***Required privileges:*** Host.Inventory.EditCluster
    /// 
    /// Refers instance of *ClusterComputeResource*.
    ///
    /// ### target_alias
    /// : target alias.
    ///
    /// ### initiator_names
    /// : initiator or initiator group name list.
    ///
    /// ## Errors:
    ///
    /// Failure
    pub async fn vsan_vit_add_iscsi_initiators_to_target(&self, cluster: &crate::types::structs::ManagedObjectReference, target_alias: &str, initiator_names: &[String]) -> Result<()> {
        let input = VsanVitAddIscsiInitiatorsToTargetRequestType {cluster, target_alias, initiator_names, };
        self.client.invoke_void("vsan", "VsanIscsiTargetSystem", &self.mo_id, "VsanVitAddIscsiInitiatorsToTarget", Some(&input)).await
    }
    /// Adds iSCSI LUN to specified target.  
    /// If the target
    /// cannot be found, a VsanFault exception is raised.
    /// 
    /// If the LUN
    /// id is provided, it should be in
    /// range \[0, 255\] and be unique in the specified target. The LUN size should be
    /// provided, its minimum size is 1MB, the maximum size is 62TB. If either of
    /// them is not met, a VsanFault will be raised.
    /// Some unhealthy status of the vSAN iSCSI service can also lead to this
    /// VsanFault exception, e.g., the unavailability of the home object.
    ///
    /// ## Parameters:
    ///
    /// ### cluster
    /// : reference to cluster resource.
    /// 
    /// ***Required privileges:*** Host.Inventory.EditCluster
    /// 
    /// Refers instance of *ClusterComputeResource*.
    ///
    /// ### target_alias
    /// : target alias
    ///
    /// ### lun_spec
    /// : reference to iSCSI LUN specification.
    ///
    /// ## Returns:
    ///
    /// The related task.
    /// 
    /// Refers instance of *Task*.
    ///
    /// ## Errors:
    ///
    /// Failure
    pub async fn vsan_vit_add_iscsi_lun(&self, cluster: &crate::types::structs::ManagedObjectReference, target_alias: &str, lun_spec: &crate::types::structs::VsanIscsiLunSpec) -> Result<Option<crate::types::structs::ManagedObjectReference>> {
        let input = VsanVitAddIscsiLunRequestType {cluster, target_alias, lun_spec, };
        let bytes_opt = self.client.invoke_optional("vsan", "VsanIscsiTargetSystem", &self.mo_id, "VsanVitAddIscsiLUN", Some(&input)).await?;
        match bytes_opt {
            Some(ref b) => Ok(Some(crate::core::client::unmarshal(self.client.transport(), b)?)),
            None => Ok(None),
        }
    }
    /// Adds iSCSI target to this cluster.  
    /// The alias in VsanIscsiTargetSpec
    /// must be provided and unique.
    /// 
    /// If iqn provided, it should be unique, if either
    /// of them is not met, a VsanFault will be raised.
    /// Some unhealthy status of the vSAN iSCSI service can also lead to this
    /// VsanFault exception, e.g., the unavailability of the home object.
    ///
    /// ## Parameters:
    ///
    /// ### cluster
    /// : reference to cluster resource.
    /// 
    /// ***Required privileges:*** Host.Inventory.EditCluster
    /// 
    /// Refers instance of *ClusterComputeResource*.
    ///
    /// ### target_spec
    /// : reference to iSCSI target specification.
    ///
    /// ## Returns:
    ///
    /// The related task.
    /// 
    /// Refers instance of *Task*.
    ///
    /// ## Errors:
    ///
    /// Failure
    pub async fn vsan_vit_add_iscsi_target(&self, cluster: &crate::types::structs::ManagedObjectReference, target_spec: &crate::types::structs::VsanIscsiTargetSpec) -> Result<Option<crate::types::structs::ManagedObjectReference>> {
        let input = VsanVitAddIscsiTargetRequestType {cluster, target_spec, };
        let bytes_opt = self.client.invoke_optional("vsan", "VsanIscsiTargetSystem", &self.mo_id, "VsanVitAddIscsiTarget", Some(&input)).await?;
        match bytes_opt {
            Some(ref b) => Ok(Some(crate::core::client::unmarshal(self.client.transport(), b)?)),
            None => Ok(None),
        }
    }
    /// Adds the iSCSI target to the specified initiator group.  
    /// If the initiator group is not found or the target is already in the
    /// accessible targets of the group, a VsanFault will be raised.
    /// 
    /// Some unhealthy status of the vSAN iSCSI service can also lead to this
    /// VsanFault exception, e.g., the unavailability of the home object.
    ///
    /// ## Parameters:
    ///
    /// ### cluster
    /// : reference to cluster resource.
    /// 
    /// ***Required privileges:*** Host.Inventory.EditCluster
    /// 
    /// Refers instance of *ClusterComputeResource*.
    ///
    /// ### initiator_group_name
    /// : the initiator group name.
    ///
    /// ### target_alias
    /// : the iSCSI target alias.
    ///
    /// ## Errors:
    ///
    /// Failure
    pub async fn vsan_vit_add_iscsi_target_to_group(&self, cluster: &crate::types::structs::ManagedObjectReference, initiator_group_name: &str, target_alias: &str) -> Result<()> {
        let input = VsanVitAddIscsiTargetToGroupRequestType {cluster, initiator_group_name, target_alias, };
        self.client.invoke_void("vsan", "VsanIscsiTargetSystem", &self.mo_id, "VsanVitAddIscsiTargetToGroup", Some(&input)).await
    }
    /// Edits iSCSI LUN in specified target.  
    /// All properties in
    /// <code>VsanIscsiLUNSpec</code> can be changed.
    /// 
    /// If new LUN id is provided, it
    /// should be in range \[0, 255\] and be unique in the specified target, if lunSize
    /// is provided, it should be greater than existing size, i.e., LUNs are only
    /// allowed to grow, if either of them are not met, a VsanFault exception will be
    /// raised. If storagePolicy is provided, it is set by calling
    /// <code>SetVsanObjectPolicy</code> in <code>VsanObjectSystem</code>.
    /// Some unhealthy status of the vSAN iSCSI service can also lead to this
    /// VsanFault exception, e.g., the unavailability of the home object.
    ///
    /// ## Parameters:
    ///
    /// ### cluster
    /// : reference to cluster resource.
    /// 
    /// ***Required privileges:*** Host.Inventory.EditCluster
    /// 
    /// Refers instance of *ClusterComputeResource*.
    ///
    /// ### target_alias
    /// : iSCSI target alias.
    ///
    /// ### lun_spec
    /// : reference to iSCSI LUN specification.
    ///
    /// ## Returns:
    ///
    /// The related task.
    /// 
    /// Refers instance of *Task*.
    ///
    /// ## Errors:
    ///
    /// Failure
    pub async fn vsan_vit_edit_iscsi_lun(&self, cluster: &crate::types::structs::ManagedObjectReference, target_alias: &str, lun_spec: &crate::types::structs::VsanIscsiLunSpec) -> Result<Option<crate::types::structs::ManagedObjectReference>> {
        let input = VsanVitEditIscsiLunRequestType {cluster, target_alias, lun_spec, };
        let bytes_opt = self.client.invoke_optional("vsan", "VsanIscsiTargetSystem", &self.mo_id, "VsanVitEditIscsiLUN", Some(&input)).await?;
        match bytes_opt {
            Some(ref b) => Ok(Some(crate::core::client::unmarshal(self.client.transport(), b)?)),
            None => Ok(None),
        }
    }
    /// Edits iSCSI target in this cluster.  
    /// All properties in
    /// VsanIscsiTargetSpec can be changed.
    /// 
    /// If authType changed, all existing
    /// connections are not effected, but the new connection to this target need to
    /// use the new authentication type, if port or network interface changed, it has
    /// the same impact to connection as authType change. If IQN or alias provided,
    /// it should be unique.  
    /// If IQN or alias is not unique, a VsanFault will be raised.
    /// Some unhealthy status of the vSAN iSCSI service can also lead to this
    /// VsanFault exception, e.g., the unavailability of the home object.
    ///
    /// ## Parameters:
    ///
    /// ### cluster
    /// : reference to cluster resource.
    /// 
    /// ***Required privileges:*** Host.Inventory.EditCluster
    /// 
    /// Refers instance of *ClusterComputeResource*.
    ///
    /// ### target_spec
    /// : reference to iSCSI target specification.
    ///
    /// ## Returns:
    ///
    /// The related task.
    /// 
    /// Refers instance of *Task*.
    ///
    /// ## Errors:
    ///
    /// Failure
    pub async fn vsan_vit_edit_iscsi_target(&self, cluster: &crate::types::structs::ManagedObjectReference, target_spec: &crate::types::structs::VsanIscsiTargetSpec) -> Result<Option<crate::types::structs::ManagedObjectReference>> {
        let input = VsanVitEditIscsiTargetRequestType {cluster, target_spec, };
        let bytes_opt = self.client.invoke_optional("vsan", "VsanIscsiTargetSystem", &self.mo_id, "VsanVitEditIscsiTarget", Some(&input)).await?;
        match bytes_opt {
            Some(ref b) => Ok(Some(crate::core::client::unmarshal(self.client.transport(), b)?)),
            None => Ok(None),
        }
    }
    /// Gets the home object which stores the metadata for
    /// vSAN iSCSI target service.
    /// 
    /// If the home object is not
    /// found, a VsanFault will be raised.  
    /// Please don't rely on this function to decide whether need
    /// to create the home object or not, because the home object
    /// may be in creation process.
    ///
    /// ## Parameters:
    ///
    /// ### cluster
    /// : reference to cluster resource.
    /// 
    /// ***Required privileges:*** System.Read
    /// 
    /// Refers instance of *ClusterComputeResource*.
    ///
    /// ## Returns:
    ///
    /// VsanObjectInformation for the home object.
    ///
    /// ## Errors:
    ///
    /// Failure
    pub async fn vsan_vit_get_home_object(&self, cluster: &crate::types::structs::ManagedObjectReference) -> Result<crate::types::structs::VsanObjectInformation> {
        let input = VsanVitGetHomeObjectRequestType {cluster, };
        let bytes = self.client.invoke("vsan", "VsanIscsiTargetSystem", &self.mo_id, "VsanVitGetHomeObject", Some(&input)).await?;
        let result: crate::types::structs::VsanObjectInformation = crate::core::client::unmarshal(self.client.transport(), &bytes)?;
        Ok(result)
    }
    /// Gets one iSCSI initiator group.  
    /// If the initiator group doesn't exists, a VsanFault will be raised.
    /// 
    /// Some unhealthy status of the vSAN iSCSI service can also lead to this
    /// VsanFault exception, e.g., the unavailability of the home object.
    ///
    /// ## Parameters:
    ///
    /// ### cluster
    /// : reference to cluster resource.
    /// 
    /// ***Required privileges:*** System.Read
    /// 
    /// Refers instance of *ClusterComputeResource*.
    ///
    /// ### initiator_group_name
    /// : the initiator group name.
    ///
    /// ## Returns:
    ///
    /// iSCSI initiator group.
    ///
    /// ## Errors:
    ///
    /// Failure
    pub async fn vsan_vit_get_iscsi_initiator_group(&self, cluster: &crate::types::structs::ManagedObjectReference, initiator_group_name: &str) -> Result<Option<crate::types::structs::VsanIscsiInitiatorGroup>> {
        let input = VsanVitGetIscsiInitiatorGroupRequestType {cluster, initiator_group_name, };
        let bytes_opt = self.client.invoke_optional("vsan", "VsanIscsiTargetSystem", &self.mo_id, "VsanVitGetIscsiInitiatorGroup", Some(&input)).await?;
        match bytes_opt {
            Some(ref b) => Ok(Some(crate::core::client::unmarshal(self.client.transport(), b)?)),
            None => Ok(None),
        }
    }
    /// Gets iSCSI initiator group list for one cluster.  
    /// If the operation fails, a VsanFault will be raised.
    ///
    /// ## Parameters:
    ///
    /// ### cluster
    /// : reference to cluster resource.
    /// 
    /// ***Required privileges:*** System.Read
    /// 
    /// Refers instance of *ClusterComputeResource*.
    ///
    /// ## Returns:
    ///
    /// iSCSI initiator group list.
    ///
    /// ## Errors:
    ///
    /// Failure
    pub async fn vsan_vit_get_iscsi_initiator_groups(&self, cluster: &crate::types::structs::ManagedObjectReference) -> Result<Option<Vec<crate::types::structs::VsanIscsiInitiatorGroup>>> {
        let input = VsanVitGetIscsiInitiatorGroupsRequestType {cluster, };
        let bytes_opt = self.client.invoke_optional("vsan", "VsanIscsiTargetSystem", &self.mo_id, "VsanVitGetIscsiInitiatorGroups", Some(&input)).await?;
        match bytes_opt {
            Some(ref b) => Ok(Some(crate::core::client::unmarshal_array(self.client.transport(), b)?)),
            None => Ok(None),
        }
    }
    /// Gets one iSCSI LUN for specified target.  
    /// If the target or the LUN cannot be found, a VsanFault will be raised.
    /// 
    /// Some unhealthy status of the vSAN iSCSI service can also lead to this
    /// VsanFault exception, e.g., the unavailability of the home object.
    ///
    /// ## Parameters:
    ///
    /// ### cluster
    /// : reference to cluster resource.
    /// 
    /// ***Required privileges:*** System.Read
    /// 
    /// Refers instance of *ClusterComputeResource*.
    ///
    /// ### target_alias
    /// : the target alias.
    ///
    /// ### lun_id
    /// : the LUN id.
    ///
    /// ## Returns:
    ///
    /// iSCSI LUN.
    ///
    /// ## Errors:
    ///
    /// Failure
    pub async fn vsan_vit_get_iscsi_lun(&self, cluster: &crate::types::structs::ManagedObjectReference, target_alias: &str, lun_id: i32) -> Result<Option<crate::types::structs::VsanIscsiLun>> {
        let input = VsanVitGetIscsiLunRequestType {cluster, target_alias, lun_id, };
        let bytes_opt = self.client.invoke_optional("vsan", "VsanIscsiTargetSystem", &self.mo_id, "VsanVitGetIscsiLUN", Some(&input)).await?;
        match bytes_opt {
            Some(ref b) => Ok(Some(crate::core::client::unmarshal(self.client.transport(), b)?)),
            None => Ok(None),
        }
    }
    /// Gets iSCSI LUN list for specified target list.  
    /// If some targets cannot be found, a VsanFault will be raised.
    /// 
    /// Some unhealthy status of the vSAN iSCSI service can also lead to this
    /// VsanFault exception, e.g., the unavailability of the home object.
    ///
    /// ## Parameters:
    ///
    /// ### cluster
    /// : reference to cluster resource.
    /// 
    /// ***Required privileges:*** System.Read
    /// 
    /// Refers instance of *ClusterComputeResource*.
    ///
    /// ### target_aliases
    /// : target alias list, if not specified, all targets are
    /// used here.
    ///
    /// ## Returns:
    ///
    /// iSCSI LUN list, it may be empty.
    ///
    /// ## Errors:
    ///
    /// Failure
    pub async fn vsan_vit_get_iscsi_lu_ns(&self, cluster: &crate::types::structs::ManagedObjectReference, target_aliases: Option<&[String]>) -> Result<Option<Vec<crate::types::structs::VsanIscsiLun>>> {
        let input = VsanVitGetIscsiLuNsRequestType {cluster, target_aliases, };
        let bytes_opt = self.client.invoke_optional("vsan", "VsanIscsiTargetSystem", &self.mo_id, "VsanVitGetIscsiLUNs", Some(&input)).await?;
        match bytes_opt {
            Some(ref b) => Ok(Some(crate::core::client::unmarshal_array(self.client.transport(), b)?)),
            None => Ok(None),
        }
    }
    /// Gets one iSCSI target.
    /// 
    ///   
    /// If the target cannot be found, a VsanFault will be raised.
    /// Some unhealthy status of the vSAN iSCSI service can also lead to this
    /// VsanFault exception, e.g., the unavailability of the home object.
    ///
    /// ## Parameters:
    ///
    /// ### cluster
    /// : reference to cluster resource.
    /// 
    /// ***Required privileges:*** System.Read
    /// 
    /// Refers instance of *ClusterComputeResource*.
    ///
    /// ### target_alias
    /// : target alias.
    ///
    /// ## Returns:
    ///
    /// iSCSI target detail.
    ///
    /// ## Errors:
    ///
    /// Failure
    pub async fn vsan_vit_get_iscsi_target(&self, cluster: &crate::types::structs::ManagedObjectReference, target_alias: &str) -> Result<Option<crate::types::structs::VsanIscsiTarget>> {
        let input = VsanVitGetIscsiTargetRequestType {cluster, target_alias, };
        let bytes_opt = self.client.invoke_optional("vsan", "VsanIscsiTargetSystem", &self.mo_id, "VsanVitGetIscsiTarget", Some(&input)).await?;
        match bytes_opt {
            Some(ref b) => Ok(Some(crate::core::client::unmarshal(self.client.transport(), b)?)),
            None => Ok(None),
        }
    }
    /// Gets iSCSI target list for one cluster.
    /// 
    ///   
    /// If the operation fails, a VsanFault will be raised.
    ///
    /// ## Parameters:
    ///
    /// ### cluster
    /// : reference to cluster resource.
    /// 
    /// ***Required privileges:*** System.Read
    /// 
    /// Refers instance of *ClusterComputeResource*.
    ///
    /// ## Returns:
    ///
    /// iSCSI target list, it may be empty.
    ///
    /// ## Errors:
    ///
    /// Failure
    pub async fn vsan_vit_get_iscsi_targets(&self, cluster: &crate::types::structs::ManagedObjectReference) -> Result<Option<Vec<crate::types::structs::VsanIscsiTarget>>> {
        let input = VsanVitGetIscsiTargetsRequestType {cluster, };
        let bytes_opt = self.client.invoke_optional("vsan", "VsanIscsiTargetSystem", &self.mo_id, "VsanVitGetIscsiTargets", Some(&input)).await?;
        match bytes_opt {
            Some(ref b) => Ok(Some(crate::core::client::unmarshal_array(self.client.transport(), b)?)),
            None => Ok(None),
        }
    }
    /// Queries iSCSI service version, if version file is not found, a NotFound
    /// exception is raised.
    /// 
    /// When it is invoked from an ESXi host on MO
    /// 'vsan-cluster-iscsi-target-system', it just returns the iSCSI version on
    /// this host.
    /// 
    /// ***Required privileges:*** System.Read
    ///
    /// ## Errors:
    ///
    /// Failure
    pub async fn vsan_vit_query_iscsi_target_service_version(&self) -> Result<String> {
        let bytes = self.client.invoke("vsan", "VsanIscsiTargetSystem", &self.mo_id, "VsanVitQueryIscsiTargetServiceVersion", None).await?;
        let result: String = crate::core::client::unmarshal(self.client.transport(), &bytes)?;
        Ok(result)
    }
    /// Remediates the iSCSI LUNs which runtime status are not consistent
    /// with configuration.  
    /// The remediation result will be returned after the task is finished.  
    /// Only if the remediation succeed for all LUNs, the task state will be
    /// "success".
    /// 
    /// If the remediation fails with no exception raised, the task state will
    /// be "failure".
    /// If hit internal vSAN error, the task state will be "error" with error
    /// message in the fault field.
    /// Unhealthy status of the vSAN iSCSI service can lead to this
    /// vim.fault.VsanFault exception, e.g., the unavailability of the home object.
    /// Multiple entry of this function at the same time is not allowed.
    ///
    /// ## Parameters:
    ///
    /// ### cluster
    /// , reference to cluster resource.
    /// 
    /// ***Required privileges:*** Host.Inventory.EditCluster
    /// 
    /// Refers instance of *ClusterComputeResource*.
    ///
    /// ## Returns:
    ///
    /// task.
    /// 
    /// Refers instance of *Task*.
    ///
    /// ## Errors:
    ///
    /// Failure
    pub async fn vsan_remediate_iscsi_luns_runtime_status(&self, cluster: &crate::types::structs::ManagedObjectReference) -> Result<crate::types::structs::ManagedObjectReference> {
        let input = VsanRemediateIscsiLunsRuntimeStatusRequestType {cluster, };
        let bytes = self.client.invoke("vsan", "VsanIscsiTargetSystem", &self.mo_id, "VsanRemediateIscsiLunsRuntimeStatus", Some(&input)).await?;
        let result: crate::types::structs::ManagedObjectReference = crate::core::client::unmarshal(self.client.transport(), &bytes)?;
        Ok(result)
    }
    /// Removes iSCSI initiator group from one cluster.  
    /// If there are initiators in the group, the initiators will be
    /// removed at the same time.
    /// 
    /// If the initiator
    /// group doesn't exist, a VsanFault will be raised.
    /// Some unhealthy status of the vSAN iSCSI service can also lead to this
    /// VsanFault exception, e.g., the unavailability of the home object.
    ///
    /// ## Parameters:
    ///
    /// ### cluster
    /// : reference to cluster resource.
    /// 
    /// ***Required privileges:*** Host.Inventory.EditCluster
    /// 
    /// Refers instance of *ClusterComputeResource*.
    ///
    /// ### initiator_group_name
    /// : the initiator group name.
    ///
    /// ## Errors:
    ///
    /// Failure
    pub async fn vsan_vit_remove_iscsi_initiator_group(&self, cluster: &crate::types::structs::ManagedObjectReference, initiator_group_name: &str) -> Result<()> {
        let input = VsanVitRemoveIscsiInitiatorGroupRequestType {cluster, initiator_group_name, };
        self.client.invoke_void("vsan", "VsanIscsiTargetSystem", &self.mo_id, "VsanVitRemoveIscsiInitiatorGroup", Some(&input)).await
    }
    /// Removes iSCSI initiators from one initiator group.  
    /// If the initiator group does not exist, or some of the initiators
    /// are not in the specified initiator group, a VsanFault will be raised.
    /// 
    /// Some unhealthy status of the vSAN iSCSI service can also lead to this
    /// VsanFault exception, e.g., the unavailability of the home object.
    ///
    /// ## Parameters:
    ///
    /// ### cluster
    /// : reference to cluster resource.
    /// 
    /// ***Required privileges:*** Host.Inventory.EditCluster
    /// 
    /// Refers instance of *ClusterComputeResource*.
    ///
    /// ### initiator_group_name
    /// : the initiator group name.
    ///
    /// ### initiator_names
    /// : the initiator name list.
    ///
    /// ## Errors:
    ///
    /// Failure
    pub async fn vsan_vit_remove_iscsi_initiators_from_group(&self, cluster: &crate::types::structs::ManagedObjectReference, initiator_group_name: &str, initiator_names: &[String]) -> Result<()> {
        let input = VsanVitRemoveIscsiInitiatorsFromGroupRequestType {cluster, initiator_group_name, initiator_names, };
        self.client.invoke_void("vsan", "VsanIscsiTargetSystem", &self.mo_id, "VsanVitRemoveIscsiInitiatorsFromGroup", Some(&input)).await
    }
    /// Removes iSCSI initiator or initiator groups from one target.  
    /// If the specified target cannot be found or if the initiators or initiator
    /// groups specified by the initiatorNames cannot be associated with the
    /// specified target, a VsanFault will be raised.
    /// 
    /// Some unhealthy status of the vSAN iSCSI service can also lead to this
    /// VsanFault exception, e.g., the unavailability of the home object.
    ///
    /// ## Parameters:
    ///
    /// ### cluster
    /// : reference to cluster resource.
    /// 
    /// ***Required privileges:*** Host.Inventory.EditCluster
    /// 
    /// Refers instance of *ClusterComputeResource*.
    ///
    /// ### target_alias
    /// : target alias.
    ///
    /// ### initiator_names
    /// : initiator or initiator group name list.
    ///
    /// ## Errors:
    ///
    /// Failure
    pub async fn vsan_vit_remove_iscsi_initiators_from_target(&self, cluster: &crate::types::structs::ManagedObjectReference, target_alias: &str, initiator_names: &[String]) -> Result<()> {
        let input = VsanVitRemoveIscsiInitiatorsFromTargetRequestType {cluster, target_alias, initiator_names, };
        self.client.invoke_void("vsan", "VsanIscsiTargetSystem", &self.mo_id, "VsanVitRemoveIscsiInitiatorsFromTarget", Some(&input)).await
    }
    /// Removes iSCSI LUN from this target.  
    /// If
    /// the target or the LUN cannot be
    /// found, a VsanFault will be raised.
    /// 
    /// Some unhealthy status of the vSAN iSCSI service can also lead to this
    /// VsanFault exception, e.g., the unavailability of the home object.
    ///
    /// ## Parameters:
    ///
    /// ### cluster
    /// : reference to cluster resource.
    /// 
    /// ***Required privileges:*** Host.Inventory.EditCluster
    /// 
    /// Refers instance of *ClusterComputeResource*.
    ///
    /// ### target_alias
    /// : iSCSI target alias.
    ///
    /// ### lun_id
    /// : iSCSI LUN id.
    ///
    /// ## Returns:
    ///
    /// The related task.
    /// 
    /// Refers instance of *Task*.
    ///
    /// ## Errors:
    ///
    /// Failure
    pub async fn vsan_vit_remove_iscsi_lun(&self, cluster: &crate::types::structs::ManagedObjectReference, target_alias: &str, lun_id: i32) -> Result<Option<crate::types::structs::ManagedObjectReference>> {
        let input = VsanVitRemoveIscsiLunRequestType {cluster, target_alias, lun_id, };
        let bytes_opt = self.client.invoke_optional("vsan", "VsanIscsiTargetSystem", &self.mo_id, "VsanVitRemoveIscsiLUN", Some(&input)).await?;
        match bytes_opt {
            Some(ref b) => Ok(Some(crate::core::client::unmarshal(self.client.transport(), b)?)),
            None => Ok(None),
        }
    }
    /// Removes iSCSI target from this cluster.  
    /// If the target cannot be found, a VsanFault will be raised.
    /// 
    /// Some unhealthy status of the vSAN iSCSI service can also lead to this
    /// VsanFault exception, e.g., the unavailability of the home object.
    ///
    /// ## Parameters:
    ///
    /// ### cluster
    /// : reference to cluster resource.
    /// 
    /// ***Required privileges:*** Host.Inventory.EditCluster
    /// 
    /// Refers instance of *ClusterComputeResource*.
    ///
    /// ### target_alias
    /// : the target alias
    ///
    /// ## Returns:
    ///
    /// The related task.
    /// 
    /// Refers instance of *Task*.
    ///
    /// ## Errors:
    ///
    /// Failure
    pub async fn vsan_vit_remove_iscsi_target(&self, cluster: &crate::types::structs::ManagedObjectReference, target_alias: &str) -> Result<Option<crate::types::structs::ManagedObjectReference>> {
        let input = VsanVitRemoveIscsiTargetRequestType {cluster, target_alias, };
        let bytes_opt = self.client.invoke_optional("vsan", "VsanIscsiTargetSystem", &self.mo_id, "VsanVitRemoveIscsiTarget", Some(&input)).await?;
        match bytes_opt {
            Some(ref b) => Ok(Some(crate::core::client::unmarshal(self.client.transport(), b)?)),
            None => Ok(None),
        }
    }
    /// Removes accessible iSCSI target from one initiator group.  
    /// If the initiator group is not found or the target is not in the accessible
    /// targets of the group, a VsanFault will be raised.
    /// 
    /// Some unhealthy status of the vSAN iSCSI service can also lead to this
    /// VsanFault exception, e.g., the unavailability of the home object.
    ///
    /// ## Parameters:
    ///
    /// ### cluster
    /// : reference to cluster resource.
    /// 
    /// ***Required privileges:*** Host.Inventory.EditCluster
    /// 
    /// Refers instance of *ClusterComputeResource*.
    ///
    /// ### initiator_group_name
    /// : the initiator group name.
    ///
    /// ### target_alias
    /// : the iSCSI target alias.
    ///
    /// ## Errors:
    ///
    /// Failure
    pub async fn vsan_vit_remove_iscsi_target_from_group(&self, cluster: &crate::types::structs::ManagedObjectReference, initiator_group_name: &str, target_alias: &str) -> Result<()> {
        let input = VsanVitRemoveIscsiTargetFromGroupRequestType {cluster, initiator_group_name, target_alias, };
        self.client.invoke_void("vsan", "VsanIscsiTargetSystem", &self.mo_id, "VsanVitRemoveIscsiTargetFromGroup", Some(&input)).await
    }
}
struct VsanVitAddIscsiInitiatorGroupRequestType<'a> {
    cluster: &'a crate::types::structs::ManagedObjectReference,
    initiator_group_name: &'a str,
}

impl<'a> miniserde::Serialize for VsanVitAddIscsiInitiatorGroupRequestType<'a> {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Map(Box::new(VsanVitAddIscsiInitiatorGroupRequestTypeSer { data: self, seq: 0 }))
    }
}

struct VsanVitAddIscsiInitiatorGroupRequestTypeSer<'b, 'a> {
    data: &'b VsanVitAddIscsiInitiatorGroupRequestType<'a>,
    seq: usize,
}

impl<'b, 'a> miniserde::ser::Map for VsanVitAddIscsiInitiatorGroupRequestTypeSer<'b, 'a> {
    fn next(&mut self) -> Option<(std::borrow::Cow<'_, str>, &dyn miniserde::Serialize)> {
        let seq = self.seq;
        self.seq += 1;
        match seq {
            0 => return Some((std::borrow::Cow::Borrowed("_typeName"), &"VsanVitAddIscsiInitiatorGroupRequestType")),
            1 => return Some((std::borrow::Cow::Borrowed("cluster"), &self.data.cluster as &dyn miniserde::Serialize)),
            2 => return Some((std::borrow::Cow::Borrowed("initiatorGroupName"), &self.data.initiator_group_name as &dyn miniserde::Serialize)),
            _ => return None,
        }
    }
}
struct VsanVitAddIscsiInitiatorsToGroupRequestType<'a> {
    cluster: &'a crate::types::structs::ManagedObjectReference,
    initiator_group_name: &'a str,
    initiator_names: &'a [String],
}

impl<'a> miniserde::Serialize for VsanVitAddIscsiInitiatorsToGroupRequestType<'a> {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Map(Box::new(VsanVitAddIscsiInitiatorsToGroupRequestTypeSer { data: self, seq: 0 }))
    }
}

struct VsanVitAddIscsiInitiatorsToGroupRequestTypeSer<'b, 'a> {
    data: &'b VsanVitAddIscsiInitiatorsToGroupRequestType<'a>,
    seq: usize,
}

impl<'b, 'a> miniserde::ser::Map for VsanVitAddIscsiInitiatorsToGroupRequestTypeSer<'b, 'a> {
    fn next(&mut self) -> Option<(std::borrow::Cow<'_, str>, &dyn miniserde::Serialize)> {
        let seq = self.seq;
        self.seq += 1;
        match seq {
            0 => return Some((std::borrow::Cow::Borrowed("_typeName"), &"VsanVitAddIscsiInitiatorsToGroupRequestType")),
            1 => return Some((std::borrow::Cow::Borrowed("cluster"), &self.data.cluster as &dyn miniserde::Serialize)),
            2 => return Some((std::borrow::Cow::Borrowed("initiatorGroupName"), &self.data.initiator_group_name as &dyn miniserde::Serialize)),
            3 => return Some((std::borrow::Cow::Borrowed("initiatorNames"), &self.data.initiator_names as &dyn miniserde::Serialize)),
            _ => return None,
        }
    }
}
struct VsanVitAddIscsiInitiatorsToTargetRequestType<'a> {
    cluster: &'a crate::types::structs::ManagedObjectReference,
    target_alias: &'a str,
    initiator_names: &'a [String],
}

impl<'a> miniserde::Serialize for VsanVitAddIscsiInitiatorsToTargetRequestType<'a> {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Map(Box::new(VsanVitAddIscsiInitiatorsToTargetRequestTypeSer { data: self, seq: 0 }))
    }
}

struct VsanVitAddIscsiInitiatorsToTargetRequestTypeSer<'b, 'a> {
    data: &'b VsanVitAddIscsiInitiatorsToTargetRequestType<'a>,
    seq: usize,
}

impl<'b, 'a> miniserde::ser::Map for VsanVitAddIscsiInitiatorsToTargetRequestTypeSer<'b, 'a> {
    fn next(&mut self) -> Option<(std::borrow::Cow<'_, str>, &dyn miniserde::Serialize)> {
        let seq = self.seq;
        self.seq += 1;
        match seq {
            0 => return Some((std::borrow::Cow::Borrowed("_typeName"), &"VsanVitAddIscsiInitiatorsToTargetRequestType")),
            1 => return Some((std::borrow::Cow::Borrowed("cluster"), &self.data.cluster as &dyn miniserde::Serialize)),
            2 => return Some((std::borrow::Cow::Borrowed("targetAlias"), &self.data.target_alias as &dyn miniserde::Serialize)),
            3 => return Some((std::borrow::Cow::Borrowed("initiatorNames"), &self.data.initiator_names as &dyn miniserde::Serialize)),
            _ => return None,
        }
    }
}
struct VsanVitAddIscsiLunRequestType<'a> {
    cluster: &'a crate::types::structs::ManagedObjectReference,
    target_alias: &'a str,
    lun_spec: &'a crate::types::structs::VsanIscsiLunSpec,
}

impl<'a> miniserde::Serialize for VsanVitAddIscsiLunRequestType<'a> {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Map(Box::new(VsanVitAddIscsiLunRequestTypeSer { data: self, seq: 0 }))
    }
}

struct VsanVitAddIscsiLunRequestTypeSer<'b, 'a> {
    data: &'b VsanVitAddIscsiLunRequestType<'a>,
    seq: usize,
}

impl<'b, 'a> miniserde::ser::Map for VsanVitAddIscsiLunRequestTypeSer<'b, 'a> {
    fn next(&mut self) -> Option<(std::borrow::Cow<'_, str>, &dyn miniserde::Serialize)> {
        let seq = self.seq;
        self.seq += 1;
        match seq {
            0 => return Some((std::borrow::Cow::Borrowed("_typeName"), &"VsanVitAddIscsiLUNRequestType")),
            1 => return Some((std::borrow::Cow::Borrowed("cluster"), &self.data.cluster as &dyn miniserde::Serialize)),
            2 => return Some((std::borrow::Cow::Borrowed("targetAlias"), &self.data.target_alias as &dyn miniserde::Serialize)),
            3 => return Some((std::borrow::Cow::Borrowed("lunSpec"), &self.data.lun_spec as &dyn miniserde::Serialize)),
            _ => return None,
        }
    }
}
struct VsanVitAddIscsiTargetRequestType<'a> {
    cluster: &'a crate::types::structs::ManagedObjectReference,
    target_spec: &'a crate::types::structs::VsanIscsiTargetSpec,
}

impl<'a> miniserde::Serialize for VsanVitAddIscsiTargetRequestType<'a> {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Map(Box::new(VsanVitAddIscsiTargetRequestTypeSer { data: self, seq: 0 }))
    }
}

struct VsanVitAddIscsiTargetRequestTypeSer<'b, 'a> {
    data: &'b VsanVitAddIscsiTargetRequestType<'a>,
    seq: usize,
}

impl<'b, 'a> miniserde::ser::Map for VsanVitAddIscsiTargetRequestTypeSer<'b, 'a> {
    fn next(&mut self) -> Option<(std::borrow::Cow<'_, str>, &dyn miniserde::Serialize)> {
        let seq = self.seq;
        self.seq += 1;
        match seq {
            0 => return Some((std::borrow::Cow::Borrowed("_typeName"), &"VsanVitAddIscsiTargetRequestType")),
            1 => return Some((std::borrow::Cow::Borrowed("cluster"), &self.data.cluster as &dyn miniserde::Serialize)),
            2 => return Some((std::borrow::Cow::Borrowed("targetSpec"), &self.data.target_spec as &dyn miniserde::Serialize)),
            _ => return None,
        }
    }
}
struct VsanVitAddIscsiTargetToGroupRequestType<'a> {
    cluster: &'a crate::types::structs::ManagedObjectReference,
    initiator_group_name: &'a str,
    target_alias: &'a str,
}

impl<'a> miniserde::Serialize for VsanVitAddIscsiTargetToGroupRequestType<'a> {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Map(Box::new(VsanVitAddIscsiTargetToGroupRequestTypeSer { data: self, seq: 0 }))
    }
}

struct VsanVitAddIscsiTargetToGroupRequestTypeSer<'b, 'a> {
    data: &'b VsanVitAddIscsiTargetToGroupRequestType<'a>,
    seq: usize,
}

impl<'b, 'a> miniserde::ser::Map for VsanVitAddIscsiTargetToGroupRequestTypeSer<'b, 'a> {
    fn next(&mut self) -> Option<(std::borrow::Cow<'_, str>, &dyn miniserde::Serialize)> {
        let seq = self.seq;
        self.seq += 1;
        match seq {
            0 => return Some((std::borrow::Cow::Borrowed("_typeName"), &"VsanVitAddIscsiTargetToGroupRequestType")),
            1 => return Some((std::borrow::Cow::Borrowed("cluster"), &self.data.cluster as &dyn miniserde::Serialize)),
            2 => return Some((std::borrow::Cow::Borrowed("initiatorGroupName"), &self.data.initiator_group_name as &dyn miniserde::Serialize)),
            3 => return Some((std::borrow::Cow::Borrowed("targetAlias"), &self.data.target_alias as &dyn miniserde::Serialize)),
            _ => return None,
        }
    }
}
struct VsanVitEditIscsiLunRequestType<'a> {
    cluster: &'a crate::types::structs::ManagedObjectReference,
    target_alias: &'a str,
    lun_spec: &'a crate::types::structs::VsanIscsiLunSpec,
}

impl<'a> miniserde::Serialize for VsanVitEditIscsiLunRequestType<'a> {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Map(Box::new(VsanVitEditIscsiLunRequestTypeSer { data: self, seq: 0 }))
    }
}

struct VsanVitEditIscsiLunRequestTypeSer<'b, 'a> {
    data: &'b VsanVitEditIscsiLunRequestType<'a>,
    seq: usize,
}

impl<'b, 'a> miniserde::ser::Map for VsanVitEditIscsiLunRequestTypeSer<'b, 'a> {
    fn next(&mut self) -> Option<(std::borrow::Cow<'_, str>, &dyn miniserde::Serialize)> {
        let seq = self.seq;
        self.seq += 1;
        match seq {
            0 => return Some((std::borrow::Cow::Borrowed("_typeName"), &"VsanVitEditIscsiLUNRequestType")),
            1 => return Some((std::borrow::Cow::Borrowed("cluster"), &self.data.cluster as &dyn miniserde::Serialize)),
            2 => return Some((std::borrow::Cow::Borrowed("targetAlias"), &self.data.target_alias as &dyn miniserde::Serialize)),
            3 => return Some((std::borrow::Cow::Borrowed("lunSpec"), &self.data.lun_spec as &dyn miniserde::Serialize)),
            _ => return None,
        }
    }
}
struct VsanVitEditIscsiTargetRequestType<'a> {
    cluster: &'a crate::types::structs::ManagedObjectReference,
    target_spec: &'a crate::types::structs::VsanIscsiTargetSpec,
}

impl<'a> miniserde::Serialize for VsanVitEditIscsiTargetRequestType<'a> {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Map(Box::new(VsanVitEditIscsiTargetRequestTypeSer { data: self, seq: 0 }))
    }
}

struct VsanVitEditIscsiTargetRequestTypeSer<'b, 'a> {
    data: &'b VsanVitEditIscsiTargetRequestType<'a>,
    seq: usize,
}

impl<'b, 'a> miniserde::ser::Map for VsanVitEditIscsiTargetRequestTypeSer<'b, 'a> {
    fn next(&mut self) -> Option<(std::borrow::Cow<'_, str>, &dyn miniserde::Serialize)> {
        let seq = self.seq;
        self.seq += 1;
        match seq {
            0 => return Some((std::borrow::Cow::Borrowed("_typeName"), &"VsanVitEditIscsiTargetRequestType")),
            1 => return Some((std::borrow::Cow::Borrowed("cluster"), &self.data.cluster as &dyn miniserde::Serialize)),
            2 => return Some((std::borrow::Cow::Borrowed("targetSpec"), &self.data.target_spec as &dyn miniserde::Serialize)),
            _ => return None,
        }
    }
}
struct VsanVitGetHomeObjectRequestType<'a> {
    cluster: &'a crate::types::structs::ManagedObjectReference,
}

impl<'a> miniserde::Serialize for VsanVitGetHomeObjectRequestType<'a> {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Map(Box::new(VsanVitGetHomeObjectRequestTypeSer { data: self, seq: 0 }))
    }
}

struct VsanVitGetHomeObjectRequestTypeSer<'b, 'a> {
    data: &'b VsanVitGetHomeObjectRequestType<'a>,
    seq: usize,
}

impl<'b, 'a> miniserde::ser::Map for VsanVitGetHomeObjectRequestTypeSer<'b, 'a> {
    fn next(&mut self) -> Option<(std::borrow::Cow<'_, str>, &dyn miniserde::Serialize)> {
        let seq = self.seq;
        self.seq += 1;
        match seq {
            0 => return Some((std::borrow::Cow::Borrowed("_typeName"), &"VsanVitGetHomeObjectRequestType")),
            1 => return Some((std::borrow::Cow::Borrowed("cluster"), &self.data.cluster as &dyn miniserde::Serialize)),
            _ => return None,
        }
    }
}
struct VsanVitGetIscsiInitiatorGroupRequestType<'a> {
    cluster: &'a crate::types::structs::ManagedObjectReference,
    initiator_group_name: &'a str,
}

impl<'a> miniserde::Serialize for VsanVitGetIscsiInitiatorGroupRequestType<'a> {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Map(Box::new(VsanVitGetIscsiInitiatorGroupRequestTypeSer { data: self, seq: 0 }))
    }
}

struct VsanVitGetIscsiInitiatorGroupRequestTypeSer<'b, 'a> {
    data: &'b VsanVitGetIscsiInitiatorGroupRequestType<'a>,
    seq: usize,
}

impl<'b, 'a> miniserde::ser::Map for VsanVitGetIscsiInitiatorGroupRequestTypeSer<'b, 'a> {
    fn next(&mut self) -> Option<(std::borrow::Cow<'_, str>, &dyn miniserde::Serialize)> {
        let seq = self.seq;
        self.seq += 1;
        match seq {
            0 => return Some((std::borrow::Cow::Borrowed("_typeName"), &"VsanVitGetIscsiInitiatorGroupRequestType")),
            1 => return Some((std::borrow::Cow::Borrowed("cluster"), &self.data.cluster as &dyn miniserde::Serialize)),
            2 => return Some((std::borrow::Cow::Borrowed("initiatorGroupName"), &self.data.initiator_group_name as &dyn miniserde::Serialize)),
            _ => return None,
        }
    }
}
struct VsanVitGetIscsiInitiatorGroupsRequestType<'a> {
    cluster: &'a crate::types::structs::ManagedObjectReference,
}

impl<'a> miniserde::Serialize for VsanVitGetIscsiInitiatorGroupsRequestType<'a> {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Map(Box::new(VsanVitGetIscsiInitiatorGroupsRequestTypeSer { data: self, seq: 0 }))
    }
}

struct VsanVitGetIscsiInitiatorGroupsRequestTypeSer<'b, 'a> {
    data: &'b VsanVitGetIscsiInitiatorGroupsRequestType<'a>,
    seq: usize,
}

impl<'b, 'a> miniserde::ser::Map for VsanVitGetIscsiInitiatorGroupsRequestTypeSer<'b, 'a> {
    fn next(&mut self) -> Option<(std::borrow::Cow<'_, str>, &dyn miniserde::Serialize)> {
        let seq = self.seq;
        self.seq += 1;
        match seq {
            0 => return Some((std::borrow::Cow::Borrowed("_typeName"), &"VsanVitGetIscsiInitiatorGroupsRequestType")),
            1 => return Some((std::borrow::Cow::Borrowed("cluster"), &self.data.cluster as &dyn miniserde::Serialize)),
            _ => return None,
        }
    }
}
struct VsanVitGetIscsiLunRequestType<'a> {
    cluster: &'a crate::types::structs::ManagedObjectReference,
    target_alias: &'a str,
    lun_id: i32,
}

impl<'a> miniserde::Serialize for VsanVitGetIscsiLunRequestType<'a> {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Map(Box::new(VsanVitGetIscsiLunRequestTypeSer { data: self, seq: 0 }))
    }
}

struct VsanVitGetIscsiLunRequestTypeSer<'b, 'a> {
    data: &'b VsanVitGetIscsiLunRequestType<'a>,
    seq: usize,
}

impl<'b, 'a> miniserde::ser::Map for VsanVitGetIscsiLunRequestTypeSer<'b, 'a> {
    fn next(&mut self) -> Option<(std::borrow::Cow<'_, str>, &dyn miniserde::Serialize)> {
        let seq = self.seq;
        self.seq += 1;
        match seq {
            0 => return Some((std::borrow::Cow::Borrowed("_typeName"), &"VsanVitGetIscsiLUNRequestType")),
            1 => return Some((std::borrow::Cow::Borrowed("cluster"), &self.data.cluster as &dyn miniserde::Serialize)),
            2 => return Some((std::borrow::Cow::Borrowed("targetAlias"), &self.data.target_alias as &dyn miniserde::Serialize)),
            3 => return Some((std::borrow::Cow::Borrowed("lunId"), &self.data.lun_id as &dyn miniserde::Serialize)),
            _ => return None,
        }
    }
}
struct VsanVitGetIscsiLuNsRequestType<'a> {
    cluster: &'a crate::types::structs::ManagedObjectReference,
    target_aliases: Option<&'a [String]>,
}

impl<'a> miniserde::Serialize for VsanVitGetIscsiLuNsRequestType<'a> {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Map(Box::new(VsanVitGetIscsiLuNsRequestTypeSer { data: self, seq: 0 }))
    }
}

struct VsanVitGetIscsiLuNsRequestTypeSer<'b, 'a> {
    data: &'b VsanVitGetIscsiLuNsRequestType<'a>,
    seq: usize,
}

impl<'b, 'a> miniserde::ser::Map for VsanVitGetIscsiLuNsRequestTypeSer<'b, 'a> {
    fn next(&mut self) -> Option<(std::borrow::Cow<'_, str>, &dyn miniserde::Serialize)> {
        loop {
            let seq = self.seq;
            self.seq += 1;
            match seq {
                0 => return Some((std::borrow::Cow::Borrowed("_typeName"), &"VsanVitGetIscsiLUNsRequestType")),
                1 => return Some((std::borrow::Cow::Borrowed("cluster"), &self.data.cluster as &dyn miniserde::Serialize)),
                2 => {
                    let Some(ref val) = self.data.target_aliases else { continue; };
                    return Some((std::borrow::Cow::Borrowed("targetAliases"), val as &dyn miniserde::Serialize));
                }
                _ => return None,
            }
        }
    }
}
struct VsanVitGetIscsiTargetRequestType<'a> {
    cluster: &'a crate::types::structs::ManagedObjectReference,
    target_alias: &'a str,
}

impl<'a> miniserde::Serialize for VsanVitGetIscsiTargetRequestType<'a> {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Map(Box::new(VsanVitGetIscsiTargetRequestTypeSer { data: self, seq: 0 }))
    }
}

struct VsanVitGetIscsiTargetRequestTypeSer<'b, 'a> {
    data: &'b VsanVitGetIscsiTargetRequestType<'a>,
    seq: usize,
}

impl<'b, 'a> miniserde::ser::Map for VsanVitGetIscsiTargetRequestTypeSer<'b, 'a> {
    fn next(&mut self) -> Option<(std::borrow::Cow<'_, str>, &dyn miniserde::Serialize)> {
        let seq = self.seq;
        self.seq += 1;
        match seq {
            0 => return Some((std::borrow::Cow::Borrowed("_typeName"), &"VsanVitGetIscsiTargetRequestType")),
            1 => return Some((std::borrow::Cow::Borrowed("cluster"), &self.data.cluster as &dyn miniserde::Serialize)),
            2 => return Some((std::borrow::Cow::Borrowed("targetAlias"), &self.data.target_alias as &dyn miniserde::Serialize)),
            _ => return None,
        }
    }
}
struct VsanVitGetIscsiTargetsRequestType<'a> {
    cluster: &'a crate::types::structs::ManagedObjectReference,
}

impl<'a> miniserde::Serialize for VsanVitGetIscsiTargetsRequestType<'a> {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Map(Box::new(VsanVitGetIscsiTargetsRequestTypeSer { data: self, seq: 0 }))
    }
}

struct VsanVitGetIscsiTargetsRequestTypeSer<'b, 'a> {
    data: &'b VsanVitGetIscsiTargetsRequestType<'a>,
    seq: usize,
}

impl<'b, 'a> miniserde::ser::Map for VsanVitGetIscsiTargetsRequestTypeSer<'b, 'a> {
    fn next(&mut self) -> Option<(std::borrow::Cow<'_, str>, &dyn miniserde::Serialize)> {
        let seq = self.seq;
        self.seq += 1;
        match seq {
            0 => return Some((std::borrow::Cow::Borrowed("_typeName"), &"VsanVitGetIscsiTargetsRequestType")),
            1 => return Some((std::borrow::Cow::Borrowed("cluster"), &self.data.cluster as &dyn miniserde::Serialize)),
            _ => return None,
        }
    }
}
struct VsanRemediateIscsiLunsRuntimeStatusRequestType<'a> {
    cluster: &'a crate::types::structs::ManagedObjectReference,
}

impl<'a> miniserde::Serialize for VsanRemediateIscsiLunsRuntimeStatusRequestType<'a> {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Map(Box::new(VsanRemediateIscsiLunsRuntimeStatusRequestTypeSer { data: self, seq: 0 }))
    }
}

struct VsanRemediateIscsiLunsRuntimeStatusRequestTypeSer<'b, 'a> {
    data: &'b VsanRemediateIscsiLunsRuntimeStatusRequestType<'a>,
    seq: usize,
}

impl<'b, 'a> miniserde::ser::Map for VsanRemediateIscsiLunsRuntimeStatusRequestTypeSer<'b, 'a> {
    fn next(&mut self) -> Option<(std::borrow::Cow<'_, str>, &dyn miniserde::Serialize)> {
        let seq = self.seq;
        self.seq += 1;
        match seq {
            0 => return Some((std::borrow::Cow::Borrowed("_typeName"), &"VsanRemediateIscsiLunsRuntimeStatusRequestType")),
            1 => return Some((std::borrow::Cow::Borrowed("cluster"), &self.data.cluster as &dyn miniserde::Serialize)),
            _ => return None,
        }
    }
}
struct VsanVitRemoveIscsiInitiatorGroupRequestType<'a> {
    cluster: &'a crate::types::structs::ManagedObjectReference,
    initiator_group_name: &'a str,
}

impl<'a> miniserde::Serialize for VsanVitRemoveIscsiInitiatorGroupRequestType<'a> {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Map(Box::new(VsanVitRemoveIscsiInitiatorGroupRequestTypeSer { data: self, seq: 0 }))
    }
}

struct VsanVitRemoveIscsiInitiatorGroupRequestTypeSer<'b, 'a> {
    data: &'b VsanVitRemoveIscsiInitiatorGroupRequestType<'a>,
    seq: usize,
}

impl<'b, 'a> miniserde::ser::Map for VsanVitRemoveIscsiInitiatorGroupRequestTypeSer<'b, 'a> {
    fn next(&mut self) -> Option<(std::borrow::Cow<'_, str>, &dyn miniserde::Serialize)> {
        let seq = self.seq;
        self.seq += 1;
        match seq {
            0 => return Some((std::borrow::Cow::Borrowed("_typeName"), &"VsanVitRemoveIscsiInitiatorGroupRequestType")),
            1 => return Some((std::borrow::Cow::Borrowed("cluster"), &self.data.cluster as &dyn miniserde::Serialize)),
            2 => return Some((std::borrow::Cow::Borrowed("initiatorGroupName"), &self.data.initiator_group_name as &dyn miniserde::Serialize)),
            _ => return None,
        }
    }
}
struct VsanVitRemoveIscsiInitiatorsFromGroupRequestType<'a> {
    cluster: &'a crate::types::structs::ManagedObjectReference,
    initiator_group_name: &'a str,
    initiator_names: &'a [String],
}

impl<'a> miniserde::Serialize for VsanVitRemoveIscsiInitiatorsFromGroupRequestType<'a> {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Map(Box::new(VsanVitRemoveIscsiInitiatorsFromGroupRequestTypeSer { data: self, seq: 0 }))
    }
}

struct VsanVitRemoveIscsiInitiatorsFromGroupRequestTypeSer<'b, 'a> {
    data: &'b VsanVitRemoveIscsiInitiatorsFromGroupRequestType<'a>,
    seq: usize,
}

impl<'b, 'a> miniserde::ser::Map for VsanVitRemoveIscsiInitiatorsFromGroupRequestTypeSer<'b, 'a> {
    fn next(&mut self) -> Option<(std::borrow::Cow<'_, str>, &dyn miniserde::Serialize)> {
        let seq = self.seq;
        self.seq += 1;
        match seq {
            0 => return Some((std::borrow::Cow::Borrowed("_typeName"), &"VsanVitRemoveIscsiInitiatorsFromGroupRequestType")),
            1 => return Some((std::borrow::Cow::Borrowed("cluster"), &self.data.cluster as &dyn miniserde::Serialize)),
            2 => return Some((std::borrow::Cow::Borrowed("initiatorGroupName"), &self.data.initiator_group_name as &dyn miniserde::Serialize)),
            3 => return Some((std::borrow::Cow::Borrowed("initiatorNames"), &self.data.initiator_names as &dyn miniserde::Serialize)),
            _ => return None,
        }
    }
}
struct VsanVitRemoveIscsiInitiatorsFromTargetRequestType<'a> {
    cluster: &'a crate::types::structs::ManagedObjectReference,
    target_alias: &'a str,
    initiator_names: &'a [String],
}

impl<'a> miniserde::Serialize for VsanVitRemoveIscsiInitiatorsFromTargetRequestType<'a> {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Map(Box::new(VsanVitRemoveIscsiInitiatorsFromTargetRequestTypeSer { data: self, seq: 0 }))
    }
}

struct VsanVitRemoveIscsiInitiatorsFromTargetRequestTypeSer<'b, 'a> {
    data: &'b VsanVitRemoveIscsiInitiatorsFromTargetRequestType<'a>,
    seq: usize,
}

impl<'b, 'a> miniserde::ser::Map for VsanVitRemoveIscsiInitiatorsFromTargetRequestTypeSer<'b, 'a> {
    fn next(&mut self) -> Option<(std::borrow::Cow<'_, str>, &dyn miniserde::Serialize)> {
        let seq = self.seq;
        self.seq += 1;
        match seq {
            0 => return Some((std::borrow::Cow::Borrowed("_typeName"), &"VsanVitRemoveIscsiInitiatorsFromTargetRequestType")),
            1 => return Some((std::borrow::Cow::Borrowed("cluster"), &self.data.cluster as &dyn miniserde::Serialize)),
            2 => return Some((std::borrow::Cow::Borrowed("targetAlias"), &self.data.target_alias as &dyn miniserde::Serialize)),
            3 => return Some((std::borrow::Cow::Borrowed("initiatorNames"), &self.data.initiator_names as &dyn miniserde::Serialize)),
            _ => return None,
        }
    }
}
struct VsanVitRemoveIscsiLunRequestType<'a> {
    cluster: &'a crate::types::structs::ManagedObjectReference,
    target_alias: &'a str,
    lun_id: i32,
}

impl<'a> miniserde::Serialize for VsanVitRemoveIscsiLunRequestType<'a> {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Map(Box::new(VsanVitRemoveIscsiLunRequestTypeSer { data: self, seq: 0 }))
    }
}

struct VsanVitRemoveIscsiLunRequestTypeSer<'b, 'a> {
    data: &'b VsanVitRemoveIscsiLunRequestType<'a>,
    seq: usize,
}

impl<'b, 'a> miniserde::ser::Map for VsanVitRemoveIscsiLunRequestTypeSer<'b, 'a> {
    fn next(&mut self) -> Option<(std::borrow::Cow<'_, str>, &dyn miniserde::Serialize)> {
        let seq = self.seq;
        self.seq += 1;
        match seq {
            0 => return Some((std::borrow::Cow::Borrowed("_typeName"), &"VsanVitRemoveIscsiLUNRequestType")),
            1 => return Some((std::borrow::Cow::Borrowed("cluster"), &self.data.cluster as &dyn miniserde::Serialize)),
            2 => return Some((std::borrow::Cow::Borrowed("targetAlias"), &self.data.target_alias as &dyn miniserde::Serialize)),
            3 => return Some((std::borrow::Cow::Borrowed("lunId"), &self.data.lun_id as &dyn miniserde::Serialize)),
            _ => return None,
        }
    }
}
struct VsanVitRemoveIscsiTargetRequestType<'a> {
    cluster: &'a crate::types::structs::ManagedObjectReference,
    target_alias: &'a str,
}

impl<'a> miniserde::Serialize for VsanVitRemoveIscsiTargetRequestType<'a> {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Map(Box::new(VsanVitRemoveIscsiTargetRequestTypeSer { data: self, seq: 0 }))
    }
}

struct VsanVitRemoveIscsiTargetRequestTypeSer<'b, 'a> {
    data: &'b VsanVitRemoveIscsiTargetRequestType<'a>,
    seq: usize,
}

impl<'b, 'a> miniserde::ser::Map for VsanVitRemoveIscsiTargetRequestTypeSer<'b, 'a> {
    fn next(&mut self) -> Option<(std::borrow::Cow<'_, str>, &dyn miniserde::Serialize)> {
        let seq = self.seq;
        self.seq += 1;
        match seq {
            0 => return Some((std::borrow::Cow::Borrowed("_typeName"), &"VsanVitRemoveIscsiTargetRequestType")),
            1 => return Some((std::borrow::Cow::Borrowed("cluster"), &self.data.cluster as &dyn miniserde::Serialize)),
            2 => return Some((std::borrow::Cow::Borrowed("targetAlias"), &self.data.target_alias as &dyn miniserde::Serialize)),
            _ => return None,
        }
    }
}
struct VsanVitRemoveIscsiTargetFromGroupRequestType<'a> {
    cluster: &'a crate::types::structs::ManagedObjectReference,
    initiator_group_name: &'a str,
    target_alias: &'a str,
}

impl<'a> miniserde::Serialize for VsanVitRemoveIscsiTargetFromGroupRequestType<'a> {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Map(Box::new(VsanVitRemoveIscsiTargetFromGroupRequestTypeSer { data: self, seq: 0 }))
    }
}

struct VsanVitRemoveIscsiTargetFromGroupRequestTypeSer<'b, 'a> {
    data: &'b VsanVitRemoveIscsiTargetFromGroupRequestType<'a>,
    seq: usize,
}

impl<'b, 'a> miniserde::ser::Map for VsanVitRemoveIscsiTargetFromGroupRequestTypeSer<'b, 'a> {
    fn next(&mut self) -> Option<(std::borrow::Cow<'_, str>, &dyn miniserde::Serialize)> {
        let seq = self.seq;
        self.seq += 1;
        match seq {
            0 => return Some((std::borrow::Cow::Borrowed("_typeName"), &"VsanVitRemoveIscsiTargetFromGroupRequestType")),
            1 => return Some((std::borrow::Cow::Borrowed("cluster"), &self.data.cluster as &dyn miniserde::Serialize)),
            2 => return Some((std::borrow::Cow::Borrowed("initiatorGroupName"), &self.data.initiator_group_name as &dyn miniserde::Serialize)),
            3 => return Some((std::borrow::Cow::Borrowed("targetAlias"), &self.data.target_alias as &dyn miniserde::Serialize)),
            _ => return None,
        }
    }
}