/* Generated by esx_vi_generator.py */



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Enum: AutoStartWaitHeartbeatSetting
 */

enum _esxVI_AutoStartWaitHeartbeatSetting {
    esxVI_AutoStartWaitHeartbeatSetting_Undefined = 0,
    esxVI_AutoStartWaitHeartbeatSetting_Yes,
    esxVI_AutoStartWaitHeartbeatSetting_No,
    esxVI_AutoStartWaitHeartbeatSetting_SystemDefault,
};

int esxVI_AutoStartWaitHeartbeatSetting_Serialize(esxVI_AutoStartWaitHeartbeatSetting item, const char *element, virBufferPtr output);
int esxVI_AutoStartWaitHeartbeatSetting_Deserialize(xmlNodePtr node, esxVI_AutoStartWaitHeartbeatSetting *item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Enum: FibreChannelPortType
 */

enum _esxVI_FibreChannelPortType {
    esxVI_FibreChannelPortType_Undefined = 0,
    esxVI_FibreChannelPortType_Fabric,
    esxVI_FibreChannelPortType_Loop,
    esxVI_FibreChannelPortType_PointToPoint,
    esxVI_FibreChannelPortType_Unknown,
};

int esxVI_FibreChannelPortType_Deserialize(xmlNodePtr node, esxVI_FibreChannelPortType *item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Enum: ManagedEntityStatus
 */

enum _esxVI_ManagedEntityStatus {
    esxVI_ManagedEntityStatus_Undefined = 0,
    esxVI_ManagedEntityStatus_Gray,
    esxVI_ManagedEntityStatus_Green,
    esxVI_ManagedEntityStatus_Yellow,
    esxVI_ManagedEntityStatus_Red,
};

int esxVI_ManagedEntityStatus_CastFromAnyType(esxVI_AnyType *anyType, esxVI_ManagedEntityStatus *item);
int esxVI_ManagedEntityStatus_Deserialize(xmlNodePtr node, esxVI_ManagedEntityStatus *item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Enum: ObjectUpdateKind
 */

enum _esxVI_ObjectUpdateKind {
    esxVI_ObjectUpdateKind_Undefined = 0,
    esxVI_ObjectUpdateKind_Modify,
    esxVI_ObjectUpdateKind_Enter,
    esxVI_ObjectUpdateKind_Leave,
};

int esxVI_ObjectUpdateKind_Deserialize(xmlNodePtr node, esxVI_ObjectUpdateKind *item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Enum: PerfStatsType
 */

enum _esxVI_PerfStatsType {
    esxVI_PerfStatsType_Undefined = 0,
    esxVI_PerfStatsType_Absolute,
    esxVI_PerfStatsType_Delta,
    esxVI_PerfStatsType_Rate,
};

int esxVI_PerfStatsType_Deserialize(xmlNodePtr node, esxVI_PerfStatsType *item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Enum: PerfSummaryType
 */

enum _esxVI_PerfSummaryType {
    esxVI_PerfSummaryType_Undefined = 0,
    esxVI_PerfSummaryType_Average,
    esxVI_PerfSummaryType_Maximum,
    esxVI_PerfSummaryType_Minimum,
    esxVI_PerfSummaryType_Latest,
    esxVI_PerfSummaryType_Summation,
    esxVI_PerfSummaryType_None,
};

int esxVI_PerfSummaryType_Deserialize(xmlNodePtr node, esxVI_PerfSummaryType *item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Enum: PropertyChangeOp
 */

enum _esxVI_PropertyChangeOp {
    esxVI_PropertyChangeOp_Undefined = 0,
    esxVI_PropertyChangeOp_Add,
    esxVI_PropertyChangeOp_Remove,
    esxVI_PropertyChangeOp_Assign,
    esxVI_PropertyChangeOp_IndirectRemove,
};

int esxVI_PropertyChangeOp_Deserialize(xmlNodePtr node, esxVI_PropertyChangeOp *item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Enum: SharesLevel
 */

enum _esxVI_SharesLevel {
    esxVI_SharesLevel_Undefined = 0,
    esxVI_SharesLevel_Low,
    esxVI_SharesLevel_Normal,
    esxVI_SharesLevel_High,
    esxVI_SharesLevel_Custom,
};

int esxVI_SharesLevel_Serialize(esxVI_SharesLevel item, const char *element, virBufferPtr output);
int esxVI_SharesLevel_Deserialize(xmlNodePtr node, esxVI_SharesLevel *item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Enum: TaskInfoState
 */

enum _esxVI_TaskInfoState {
    esxVI_TaskInfoState_Undefined = 0,
    esxVI_TaskInfoState_Queued,
    esxVI_TaskInfoState_Running,
    esxVI_TaskInfoState_Success,
    esxVI_TaskInfoState_Error,
};

int esxVI_TaskInfoState_CastFromAnyType(esxVI_AnyType *anyType, esxVI_TaskInfoState *item);
int esxVI_TaskInfoState_Deserialize(xmlNodePtr node, esxVI_TaskInfoState *item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Enum: VirtualMachineMovePriority
 */

enum _esxVI_VirtualMachineMovePriority {
    esxVI_VirtualMachineMovePriority_Undefined = 0,
    esxVI_VirtualMachineMovePriority_LowPriority,
    esxVI_VirtualMachineMovePriority_HighPriority,
    esxVI_VirtualMachineMovePriority_DefaultPriority,
};

int esxVI_VirtualMachineMovePriority_Serialize(esxVI_VirtualMachineMovePriority item, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Enum: VirtualMachinePowerState
 */

enum _esxVI_VirtualMachinePowerState {
    esxVI_VirtualMachinePowerState_Undefined = 0,
    esxVI_VirtualMachinePowerState_PoweredOff,
    esxVI_VirtualMachinePowerState_PoweredOn,
    esxVI_VirtualMachinePowerState_Suspended,
};

int esxVI_VirtualMachinePowerState_CastFromAnyType(esxVI_AnyType *anyType, esxVI_VirtualMachinePowerState *item);
int esxVI_VirtualMachinePowerState_Serialize(esxVI_VirtualMachinePowerState item, const char *element, virBufferPtr output);
int esxVI_VirtualMachinePowerState_Deserialize(xmlNodePtr node, esxVI_VirtualMachinePowerState *item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: AboutInfo
 */

struct _esxVI_AboutInfo {
    esxVI_AboutInfo *_unused;                              /* optional */
    esxVI_Type _type;                                      /* required */

    char *name;                                            /* required */
    char *fullName;                                        /* required */
    char *vendor;                                          /* required */
    char *version;                                         /* required */
    char *build;                                           /* required */
    char *localeVersion;                                   /* optional */
    char *localeBuild;                                     /* optional */
    char *osType;                                          /* required */
    char *productLineId;                                   /* required */
    char *apiType;                                         /* required */
    char *apiVersion;                                      /* required */
    char *instanceUuid;                                    /* optional */
    char *licenseProductName;                              /* optional */
    char *licenseProductVersion;                           /* optional */
};

int esxVI_AboutInfo_Alloc(esxVI_AboutInfo **item);
void esxVI_AboutInfo_Free(esxVI_AboutInfo **item);
int esxVI_AboutInfo_Validate(esxVI_AboutInfo *item);
int esxVI_AboutInfo_Deserialize(xmlNodePtr node, esxVI_AboutInfo **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: AutoStartDefaults
 */

struct _esxVI_AutoStartDefaults {
    esxVI_AutoStartDefaults *_unused;                      /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_Boolean enabled;                                 /* optional */
    esxVI_Int *startDelay;                                 /* optional */
    esxVI_Int *stopDelay;                                  /* optional */
    esxVI_Boolean waitForHeartbeat;                        /* optional */
    char *stopAction;                                      /* optional */
};

int esxVI_AutoStartDefaults_Alloc(esxVI_AutoStartDefaults **item);
void esxVI_AutoStartDefaults_Free(esxVI_AutoStartDefaults **item);
int esxVI_AutoStartDefaults_Validate(esxVI_AutoStartDefaults *item);
int esxVI_AutoStartDefaults_CastFromAnyType(esxVI_AnyType *anyType, esxVI_AutoStartDefaults **item);
int esxVI_AutoStartDefaults_Serialize(esxVI_AutoStartDefaults *item, const char *element, virBufferPtr output);
int esxVI_AutoStartDefaults_Deserialize(xmlNodePtr node, esxVI_AutoStartDefaults **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: AutoStartPowerInfo
 */

struct _esxVI_AutoStartPowerInfo {
    esxVI_AutoStartPowerInfo *_next;                       /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_ManagedObjectReference *key;                     /* required */
    esxVI_Int *startOrder;                                 /* required */
    esxVI_Int *startDelay;                                 /* required */
    esxVI_AutoStartWaitHeartbeatSetting waitForHeartbeat;  /* required */
    char *startAction;                                     /* required */
    esxVI_Int *stopDelay;                                  /* required */
    char *stopAction;                                      /* required */
};

int esxVI_AutoStartPowerInfo_Alloc(esxVI_AutoStartPowerInfo **item);
void esxVI_AutoStartPowerInfo_Free(esxVI_AutoStartPowerInfo **item);
int esxVI_AutoStartPowerInfo_Validate(esxVI_AutoStartPowerInfo *item);
int esxVI_AutoStartPowerInfo_AppendToList(esxVI_AutoStartPowerInfo **list, esxVI_AutoStartPowerInfo *item);
int esxVI_AutoStartPowerInfo_CastFromAnyType(esxVI_AnyType *anyType, esxVI_AutoStartPowerInfo **item);
int esxVI_AutoStartPowerInfo_CastListFromAnyType(esxVI_AnyType *anyType, esxVI_AutoStartPowerInfo **list);
int esxVI_AutoStartPowerInfo_Serialize(esxVI_AutoStartPowerInfo *item, const char *element, virBufferPtr output);
int esxVI_AutoStartPowerInfo_SerializeList(esxVI_AutoStartPowerInfo *list, const char *element, virBufferPtr output);
int esxVI_AutoStartPowerInfo_Deserialize(xmlNodePtr node, esxVI_AutoStartPowerInfo **item);
int esxVI_AutoStartPowerInfo_DeserializeList(xmlNodePtr node, esxVI_AutoStartPowerInfo **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: ChoiceOption
 *            extends OptionType
 */

struct _esxVI_ChoiceOption {
    esxVI_ChoiceOption *_unused;                           /* optional */
    esxVI_Type _type;                                      /* required */

    /* OptionType */
    esxVI_Boolean valueIsReadonly;                         /* optional */

    /* ChoiceOption */
    esxVI_ElementDescription *choiceInfo;                  /* required, list */
    esxVI_Int *defaultIndex;                               /* optional */
};

int esxVI_ChoiceOption_Alloc(esxVI_ChoiceOption **item);
void esxVI_ChoiceOption_Free(esxVI_ChoiceOption **item);
int esxVI_ChoiceOption_Validate(esxVI_ChoiceOption *item);
int esxVI_ChoiceOption_Deserialize(xmlNodePtr node, esxVI_ChoiceOption **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: DatastoreHostMount
 */

struct _esxVI_DatastoreHostMount {
    esxVI_DatastoreHostMount *_next;                       /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_ManagedObjectReference *key;                     /* required */
    esxVI_HostMountInfo *mountInfo;                        /* required */
};

int esxVI_DatastoreHostMount_Alloc(esxVI_DatastoreHostMount **item);
void esxVI_DatastoreHostMount_Free(esxVI_DatastoreHostMount **item);
int esxVI_DatastoreHostMount_Validate(esxVI_DatastoreHostMount *item);
int esxVI_DatastoreHostMount_AppendToList(esxVI_DatastoreHostMount **list, esxVI_DatastoreHostMount *item);
int esxVI_DatastoreHostMount_DeepCopy(esxVI_DatastoreHostMount **dst, esxVI_DatastoreHostMount *src);
int esxVI_DatastoreHostMount_DeepCopyList(esxVI_DatastoreHostMount **dstList, esxVI_DatastoreHostMount *srcList);
int esxVI_DatastoreHostMount_CastFromAnyType(esxVI_AnyType *anyType, esxVI_DatastoreHostMount **item);
int esxVI_DatastoreHostMount_CastListFromAnyType(esxVI_AnyType *anyType, esxVI_DatastoreHostMount **list);
int esxVI_DatastoreHostMount_Deserialize(xmlNodePtr node, esxVI_DatastoreHostMount **item);
int esxVI_DatastoreHostMount_DeserializeList(xmlNodePtr node, esxVI_DatastoreHostMount **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: DatastoreInfo
 *            extended by LocalDatastoreInfo
 *                        NasDatastoreInfo
 *                        VmfsDatastoreInfo
 */

struct _esxVI_DatastoreInfo {
    esxVI_DatastoreInfo *_unused;                          /* optional */
    esxVI_Type _type;                                      /* required */

    char *name;                                            /* required */
    char *url;                                             /* required */
    esxVI_Long *freeSpace;                                 /* required */
    esxVI_Long *maxFileSize;                               /* required */
    esxVI_DateTime *timestamp;                             /* optional */
};

int esxVI_DatastoreInfo_Alloc(esxVI_DatastoreInfo **item);
void esxVI_DatastoreInfo_Free(esxVI_DatastoreInfo **item);
int esxVI_DatastoreInfo_Validate(esxVI_DatastoreInfo *item);
esxVI_DatastoreInfo *esxVI_DatastoreInfo_DynamicCast(void *item);
int esxVI_DatastoreInfo_CastFromAnyType(esxVI_AnyType *anyType, esxVI_DatastoreInfo **item);
int esxVI_DatastoreInfo_Deserialize(xmlNodePtr node, esxVI_DatastoreInfo **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: Description
 *            extended by ElementDescription
 */

struct _esxVI_Description {
    esxVI_Description *_next;                              /* optional */
    esxVI_Type _type;                                      /* required */

    char *label;                                           /* required */
    char *summary;                                         /* required */
};

int esxVI_Description_Alloc(esxVI_Description **item);
void esxVI_Description_Free(esxVI_Description **item);
int esxVI_Description_Validate(esxVI_Description *item);
esxVI_Description *esxVI_Description_DynamicCast(void *item);
int esxVI_Description_AppendToList(esxVI_Description **list, esxVI_Description *item);
int esxVI_Description_Deserialize(xmlNodePtr node, esxVI_Description **item);
int esxVI_Description_DeserializeList(xmlNodePtr node, esxVI_Description **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: DeviceBackedVirtualDiskSpec
 *            extends VirtualDiskSpec
 */

struct _esxVI_DeviceBackedVirtualDiskSpec {
    esxVI_DeviceBackedVirtualDiskSpec *_unused;            /* optional */
    esxVI_Type _type;                                      /* required */

    /* VirtualDiskSpec */
    char *diskType;                                        /* required */
    char *adapterType;                                     /* required */

    /* DeviceBackedVirtualDiskSpec */
    char *device;                                          /* required */
};

int esxVI_DeviceBackedVirtualDiskSpec_Alloc(esxVI_DeviceBackedVirtualDiskSpec **item);
void esxVI_DeviceBackedVirtualDiskSpec_Free(esxVI_DeviceBackedVirtualDiskSpec **item);
int esxVI_DeviceBackedVirtualDiskSpec_Validate(esxVI_DeviceBackedVirtualDiskSpec *item);
esxVI_DeviceBackedVirtualDiskSpec *esxVI_DeviceBackedVirtualDiskSpec_DynamicCast(void *item);
int esxVI_DeviceBackedVirtualDiskSpec_Serialize(esxVI_DeviceBackedVirtualDiskSpec *item, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: DynamicProperty
 */

struct _esxVI_DynamicProperty {
    esxVI_DynamicProperty *_next;                          /* optional */
    esxVI_Type _type;                                      /* required */

    char *name;                                            /* required */
    esxVI_AnyType *val;                                    /* required */
};

int esxVI_DynamicProperty_Alloc(esxVI_DynamicProperty **item);
void esxVI_DynamicProperty_Free(esxVI_DynamicProperty **item);
int esxVI_DynamicProperty_Validate(esxVI_DynamicProperty *item);
int esxVI_DynamicProperty_AppendToList(esxVI_DynamicProperty **list, esxVI_DynamicProperty *item);
int esxVI_DynamicProperty_DeepCopy(esxVI_DynamicProperty **dst, esxVI_DynamicProperty *src);
int esxVI_DynamicProperty_DeepCopyList(esxVI_DynamicProperty **dstList, esxVI_DynamicProperty *srcList);
int esxVI_DynamicProperty_Deserialize(xmlNodePtr node, esxVI_DynamicProperty **item);
int esxVI_DynamicProperty_DeserializeList(xmlNodePtr node, esxVI_DynamicProperty **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: ElementDescription
 *            extends Description
 *            extended by ExtendedElementDescription
 */

struct _esxVI_ElementDescription {
    esxVI_ElementDescription *_next;                       /* optional */
    esxVI_Type _type;                                      /* required */

    /* Description */
    char *label;                                           /* required */
    char *summary;                                         /* required */

    /* ElementDescription */
    char *key;                                             /* required */
};

int esxVI_ElementDescription_Alloc(esxVI_ElementDescription **item);
void esxVI_ElementDescription_Free(esxVI_ElementDescription **item);
int esxVI_ElementDescription_Validate(esxVI_ElementDescription *item);
esxVI_ElementDescription *esxVI_ElementDescription_DynamicCast(void *item);
int esxVI_ElementDescription_AppendToList(esxVI_ElementDescription **list, esxVI_ElementDescription *item);
int esxVI_ElementDescription_Deserialize(xmlNodePtr node, esxVI_ElementDescription **item);
int esxVI_ElementDescription_DeserializeList(xmlNodePtr node, esxVI_ElementDescription **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: EntityEventArgument
 *            extends EventArgument
 *            extended by VmEventArgument
 */

struct _esxVI_EntityEventArgument {
    esxVI_EntityEventArgument *_unused;                    /* optional */
    esxVI_Type _type;                                      /* required */

    /* EventArgument */
    /* no properties */

    /* EntityEventArgument */
    char *name;                                            /* required */
};

int esxVI_EntityEventArgument_Alloc(esxVI_EntityEventArgument **item);
void esxVI_EntityEventArgument_Free(esxVI_EntityEventArgument **item);
int esxVI_EntityEventArgument_Validate(esxVI_EntityEventArgument *item);
int esxVI_EntityEventArgument_Deserialize(xmlNodePtr node, esxVI_EntityEventArgument **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: EventArgument
 *            extended by EntityEventArgument
 */

struct _esxVI_EventArgument {
    esxVI_EventArgument *_unused;                          /* optional */
    esxVI_Type _type;                                      /* required */

    /* no properties */
};

int esxVI_EventArgument_Alloc(esxVI_EventArgument **item);
void esxVI_EventArgument_Free(esxVI_EventArgument **item);
int esxVI_EventArgument_Validate(esxVI_EventArgument *item);
int esxVI_EventArgument_Deserialize(xmlNodePtr node, esxVI_EventArgument **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: ExtendedElementDescription
 *            extends ElementDescription
 */

struct _esxVI_ExtendedElementDescription {
    esxVI_ExtendedElementDescription *_next;               /* optional */
    esxVI_Type _type;                                      /* required */

    /* Description */
    char *label;                                           /* required */
    char *summary;                                         /* required */

    /* ElementDescription */
    char *key;                                             /* required */

    /* ExtendedElementDescription */
    char *messageCatalogKeyPrefix;                         /* required */
    esxVI_KeyAnyValue *messageArg;                         /* optional, list */
};

int esxVI_ExtendedElementDescription_Alloc(esxVI_ExtendedElementDescription **item);
void esxVI_ExtendedElementDescription_Free(esxVI_ExtendedElementDescription **item);
int esxVI_ExtendedElementDescription_Validate(esxVI_ExtendedElementDescription *item);
esxVI_ExtendedElementDescription *esxVI_ExtendedElementDescription_DynamicCast(void *item);
int esxVI_ExtendedElementDescription_AppendToList(esxVI_ExtendedElementDescription **list, esxVI_ExtendedElementDescription *item);
int esxVI_ExtendedElementDescription_Deserialize(xmlNodePtr node, esxVI_ExtendedElementDescription **item);
int esxVI_ExtendedElementDescription_DeserializeList(xmlNodePtr node, esxVI_ExtendedElementDescription **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: FileBackedVirtualDiskSpec
 *            extends VirtualDiskSpec
 */

struct _esxVI_FileBackedVirtualDiskSpec {
    esxVI_FileBackedVirtualDiskSpec *_unused;              /* optional */
    esxVI_Type _type;                                      /* required */

    /* VirtualDiskSpec */
    char *diskType;                                        /* required */
    char *adapterType;                                     /* required */

    /* FileBackedVirtualDiskSpec */
    esxVI_Long *capacityKb;                                /* required */
};

int esxVI_FileBackedVirtualDiskSpec_Alloc(esxVI_FileBackedVirtualDiskSpec **item);
void esxVI_FileBackedVirtualDiskSpec_Free(esxVI_FileBackedVirtualDiskSpec **item);
int esxVI_FileBackedVirtualDiskSpec_Validate(esxVI_FileBackedVirtualDiskSpec *item);
esxVI_FileBackedVirtualDiskSpec *esxVI_FileBackedVirtualDiskSpec_DynamicCast(void *item);
int esxVI_FileBackedVirtualDiskSpec_Serialize(esxVI_FileBackedVirtualDiskSpec *item, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: FileInfo
 *            extended by FloppyImageFileInfo
 *                        FolderFileInfo
 *                        IsoImageFileInfo
 *                        VmConfigFileInfo
 *                        VmDiskFileInfo
 *                        VmLogFileInfo
 *                        VmNvramFileInfo
 *                        VmSnapshotFileInfo
 */

struct _esxVI_FileInfo {
    esxVI_FileInfo *_next;                                 /* optional */
    esxVI_Type _type;                                      /* required */

    char *path;                                            /* required */
    esxVI_Long *fileSize;                                  /* optional */
    esxVI_DateTime *modification;                          /* optional */
    char *owner;                                           /* optional */
};

int esxVI_FileInfo_Alloc(esxVI_FileInfo **item);
void esxVI_FileInfo_Free(esxVI_FileInfo **item);
int esxVI_FileInfo_Validate(esxVI_FileInfo *item);
esxVI_FileInfo *esxVI_FileInfo_DynamicCast(void *item);
int esxVI_FileInfo_AppendToList(esxVI_FileInfo **list, esxVI_FileInfo *item);
int esxVI_FileInfo_Deserialize(xmlNodePtr node, esxVI_FileInfo **item);
int esxVI_FileInfo_DeserializeList(xmlNodePtr node, esxVI_FileInfo **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: FileQuery
 *            extended by FloppyImageFileQuery
 *                        FolderFileQuery
 *                        IsoImageFileQuery
 *                        VmConfigFileQuery
 *                        VmDiskFileQuery
 *                        VmLogFileQuery
 *                        VmNvramFileQuery
 *                        VmSnapshotFileQuery
 */

struct _esxVI_FileQuery {
    esxVI_FileQuery *_next;                                /* optional */
    esxVI_Type _type;                                      /* required */

    /* no properties */
};

int esxVI_FileQuery_Alloc(esxVI_FileQuery **item);
void esxVI_FileQuery_Free(esxVI_FileQuery **item);
int esxVI_FileQuery_Validate(esxVI_FileQuery *item);
esxVI_FileQuery *esxVI_FileQuery_DynamicCast(void *item);
int esxVI_FileQuery_AppendToList(esxVI_FileQuery **list, esxVI_FileQuery *item);
int esxVI_FileQuery_Serialize(esxVI_FileQuery *item, const char *element, virBufferPtr output);
int esxVI_FileQuery_SerializeList(esxVI_FileQuery *list, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: FileQueryFlags
 */

struct _esxVI_FileQueryFlags {
    esxVI_FileQueryFlags *_unused;                         /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_Boolean fileType;                                /* required */
    esxVI_Boolean fileSize;                                /* required */
    esxVI_Boolean modification;                            /* required */
    esxVI_Boolean fileOwner;                               /* optional */
};

int esxVI_FileQueryFlags_Alloc(esxVI_FileQueryFlags **item);
void esxVI_FileQueryFlags_Free(esxVI_FileQueryFlags **item);
int esxVI_FileQueryFlags_Validate(esxVI_FileQueryFlags *item);
int esxVI_FileQueryFlags_Serialize(esxVI_FileQueryFlags *item, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: FloppyImageFileInfo
 *            extends FileInfo
 */

struct _esxVI_FloppyImageFileInfo {
    esxVI_FloppyImageFileInfo *_next;                      /* optional */
    esxVI_Type _type;                                      /* required */

    /* FileInfo */
    char *path;                                            /* required */
    esxVI_Long *fileSize;                                  /* optional */
    esxVI_DateTime *modification;                          /* optional */
    char *owner;                                           /* optional */

    /* FloppyImageFileInfo */
    /* no properties */
};

int esxVI_FloppyImageFileInfo_Alloc(esxVI_FloppyImageFileInfo **item);
void esxVI_FloppyImageFileInfo_Free(esxVI_FloppyImageFileInfo **item);
int esxVI_FloppyImageFileInfo_Validate(esxVI_FloppyImageFileInfo *item);
esxVI_FloppyImageFileInfo *esxVI_FloppyImageFileInfo_DynamicCast(void *item);
int esxVI_FloppyImageFileInfo_AppendToList(esxVI_FloppyImageFileInfo **list, esxVI_FloppyImageFileInfo *item);
int esxVI_FloppyImageFileInfo_Deserialize(xmlNodePtr node, esxVI_FloppyImageFileInfo **item);
int esxVI_FloppyImageFileInfo_DeserializeList(xmlNodePtr node, esxVI_FloppyImageFileInfo **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: FloppyImageFileQuery
 *            extends FileQuery
 */

struct _esxVI_FloppyImageFileQuery {
    esxVI_FloppyImageFileQuery *_next;                     /* optional */
    esxVI_Type _type;                                      /* required */

    /* FileQuery */
    /* no properties */

    /* FloppyImageFileQuery */
    /* no properties */
};

int esxVI_FloppyImageFileQuery_Alloc(esxVI_FloppyImageFileQuery **item);
void esxVI_FloppyImageFileQuery_Free(esxVI_FloppyImageFileQuery **item);
int esxVI_FloppyImageFileQuery_Validate(esxVI_FloppyImageFileQuery *item);
esxVI_FloppyImageFileQuery *esxVI_FloppyImageFileQuery_DynamicCast(void *item);
int esxVI_FloppyImageFileQuery_AppendToList(esxVI_FloppyImageFileQuery **list, esxVI_FloppyImageFileQuery *item);
int esxVI_FloppyImageFileQuery_Serialize(esxVI_FloppyImageFileQuery *item, const char *element, virBufferPtr output);
int esxVI_FloppyImageFileQuery_SerializeList(esxVI_FloppyImageFileQuery *list, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: FolderFileInfo
 *            extends FileInfo
 */

struct _esxVI_FolderFileInfo {
    esxVI_FolderFileInfo *_next;                           /* optional */
    esxVI_Type _type;                                      /* required */

    /* FileInfo */
    char *path;                                            /* required */
    esxVI_Long *fileSize;                                  /* optional */
    esxVI_DateTime *modification;                          /* optional */
    char *owner;                                           /* optional */

    /* FolderFileInfo */
    /* no properties */
};

int esxVI_FolderFileInfo_Alloc(esxVI_FolderFileInfo **item);
void esxVI_FolderFileInfo_Free(esxVI_FolderFileInfo **item);
int esxVI_FolderFileInfo_Validate(esxVI_FolderFileInfo *item);
esxVI_FolderFileInfo *esxVI_FolderFileInfo_DynamicCast(void *item);
int esxVI_FolderFileInfo_AppendToList(esxVI_FolderFileInfo **list, esxVI_FolderFileInfo *item);
int esxVI_FolderFileInfo_Deserialize(xmlNodePtr node, esxVI_FolderFileInfo **item);
int esxVI_FolderFileInfo_DeserializeList(xmlNodePtr node, esxVI_FolderFileInfo **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: FolderFileQuery
 *            extends FileQuery
 */

struct _esxVI_FolderFileQuery {
    esxVI_FolderFileQuery *_next;                          /* optional */
    esxVI_Type _type;                                      /* required */

    /* FileQuery */
    /* no properties */

    /* FolderFileQuery */
    /* no properties */
};

int esxVI_FolderFileQuery_Alloc(esxVI_FolderFileQuery **item);
void esxVI_FolderFileQuery_Free(esxVI_FolderFileQuery **item);
int esxVI_FolderFileQuery_Validate(esxVI_FolderFileQuery *item);
esxVI_FolderFileQuery *esxVI_FolderFileQuery_DynamicCast(void *item);
int esxVI_FolderFileQuery_AppendToList(esxVI_FolderFileQuery **list, esxVI_FolderFileQuery *item);
int esxVI_FolderFileQuery_Serialize(esxVI_FolderFileQuery *item, const char *element, virBufferPtr output);
int esxVI_FolderFileQuery_SerializeList(esxVI_FolderFileQuery *list, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostAutoStartManagerConfig
 */

struct _esxVI_HostAutoStartManagerConfig {
    esxVI_HostAutoStartManagerConfig *_unused;             /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_AutoStartDefaults *defaults;                     /* optional */
    esxVI_AutoStartPowerInfo *powerInfo;                   /* optional, list */
};

int esxVI_HostAutoStartManagerConfig_Alloc(esxVI_HostAutoStartManagerConfig **item);
void esxVI_HostAutoStartManagerConfig_Free(esxVI_HostAutoStartManagerConfig **item);
int esxVI_HostAutoStartManagerConfig_Validate(esxVI_HostAutoStartManagerConfig *item);
int esxVI_HostAutoStartManagerConfig_Serialize(esxVI_HostAutoStartManagerConfig *item, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostBlockAdapterTargetTransport
 *            extends HostTargetTransport
 */

struct _esxVI_HostBlockAdapterTargetTransport {
    esxVI_HostBlockAdapterTargetTransport *_unused;        /* optional */
    esxVI_Type _type;                                      /* required */

    /* HostTargetTransport */
    /* no properties */

    /* HostBlockAdapterTargetTransport */
    /* no properties */
};

int esxVI_HostBlockAdapterTargetTransport_Alloc(esxVI_HostBlockAdapterTargetTransport **item);
void esxVI_HostBlockAdapterTargetTransport_Free(esxVI_HostBlockAdapterTargetTransport **item);
int esxVI_HostBlockAdapterTargetTransport_Validate(esxVI_HostBlockAdapterTargetTransport *item);
esxVI_HostBlockAdapterTargetTransport *esxVI_HostBlockAdapterTargetTransport_DynamicCast(void *item);
int esxVI_HostBlockAdapterTargetTransport_Deserialize(xmlNodePtr node, esxVI_HostBlockAdapterTargetTransport **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostBlockHba
 *            extends HostHostBusAdapter
 */

struct _esxVI_HostBlockHba {
    esxVI_HostBlockHba *_next;                             /* optional */
    esxVI_Type _type;                                      /* required */

    /* HostHostBusAdapter */
    char *key;                                             /* optional */
    char *device;                                          /* required */
    esxVI_Int *bus;                                        /* required */
    char *status;                                          /* required */
    char *model;                                           /* required */
    char *driver;                                          /* optional */
    char *pci;                                             /* optional */

    /* HostBlockHba */
    /* no properties */
};

int esxVI_HostBlockHba_Alloc(esxVI_HostBlockHba **item);
void esxVI_HostBlockHba_Free(esxVI_HostBlockHba **item);
int esxVI_HostBlockHba_Validate(esxVI_HostBlockHba *item);
esxVI_HostBlockHba *esxVI_HostBlockHba_DynamicCast(void *item);
int esxVI_HostBlockHba_AppendToList(esxVI_HostBlockHba **list, esxVI_HostBlockHba *item);
int esxVI_HostBlockHba_DeepCopy(esxVI_HostBlockHba **dst, esxVI_HostBlockHba *src);
int esxVI_HostBlockHba_DeepCopyList(esxVI_HostBlockHba **dstList, esxVI_HostBlockHba *srcList);
int esxVI_HostBlockHba_CastFromAnyType(esxVI_AnyType *anyType, esxVI_HostBlockHba **item);
int esxVI_HostBlockHba_CastListFromAnyType(esxVI_AnyType *anyType, esxVI_HostBlockHba **list);
int esxVI_HostBlockHba_Deserialize(xmlNodePtr node, esxVI_HostBlockHba **item);
int esxVI_HostBlockHba_DeserializeList(xmlNodePtr node, esxVI_HostBlockHba **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostConfigManager
 */

struct _esxVI_HostConfigManager {
    esxVI_HostConfigManager *_unused;                      /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_ManagedObjectReference *cpuScheduler;            /* optional */
    esxVI_ManagedObjectReference *datastoreSystem;         /* optional */
    esxVI_ManagedObjectReference *memoryManager;           /* optional */
    esxVI_ManagedObjectReference *storageSystem;           /* optional */
    esxVI_ManagedObjectReference *networkSystem;           /* optional */
    esxVI_ManagedObjectReference *vmotionSystem;           /* optional */
    esxVI_ManagedObjectReference *virtualNicManager;       /* optional */
    esxVI_ManagedObjectReference *serviceSystem;           /* optional */
    esxVI_ManagedObjectReference *firewallSystem;          /* optional */
    esxVI_ManagedObjectReference *advancedOption;          /* optional */
    esxVI_ManagedObjectReference *diagnosticSystem;        /* optional */
    esxVI_ManagedObjectReference *autoStartManager;        /* optional */
    esxVI_ManagedObjectReference *snmpSystem;              /* optional */
    esxVI_ManagedObjectReference *dateTimeSystem;          /* optional */
    esxVI_ManagedObjectReference *patchManager;            /* optional */
    esxVI_ManagedObjectReference *bootDeviceSystem;        /* optional */
    esxVI_ManagedObjectReference *firmwareSystem;          /* optional */
    esxVI_ManagedObjectReference *healthStatusSystem;      /* optional */
    esxVI_ManagedObjectReference *pciPassthruSystem;       /* optional */
    esxVI_ManagedObjectReference *licenseManager;          /* optional */
    esxVI_ManagedObjectReference *kernelModuleSystem;      /* optional */
};

int esxVI_HostConfigManager_Alloc(esxVI_HostConfigManager **item);
void esxVI_HostConfigManager_Free(esxVI_HostConfigManager **item);
int esxVI_HostConfigManager_Validate(esxVI_HostConfigManager *item);
int esxVI_HostConfigManager_CastFromAnyType(esxVI_AnyType *anyType, esxVI_HostConfigManager **item);
int esxVI_HostConfigManager_Deserialize(xmlNodePtr node, esxVI_HostConfigManager **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostCpuIdInfo
 */

struct _esxVI_HostCpuIdInfo {
    esxVI_HostCpuIdInfo *_next;                            /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_Int *level;                                      /* required */
    char *vendor;                                          /* optional */
    char *eax;                                             /* optional */
    char *ebx;                                             /* optional */
    char *ecx;                                             /* optional */
    char *edx;                                             /* optional */
};

int esxVI_HostCpuIdInfo_Alloc(esxVI_HostCpuIdInfo **item);
void esxVI_HostCpuIdInfo_Free(esxVI_HostCpuIdInfo **item);
int esxVI_HostCpuIdInfo_Validate(esxVI_HostCpuIdInfo *item);
int esxVI_HostCpuIdInfo_AppendToList(esxVI_HostCpuIdInfo **list, esxVI_HostCpuIdInfo *item);
int esxVI_HostCpuIdInfo_CastFromAnyType(esxVI_AnyType *anyType, esxVI_HostCpuIdInfo **item);
int esxVI_HostCpuIdInfo_CastListFromAnyType(esxVI_AnyType *anyType, esxVI_HostCpuIdInfo **list);
int esxVI_HostCpuIdInfo_Deserialize(xmlNodePtr node, esxVI_HostCpuIdInfo **item);
int esxVI_HostCpuIdInfo_DeserializeList(xmlNodePtr node, esxVI_HostCpuIdInfo **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostDatastoreBrowserSearchResults
 */

struct _esxVI_HostDatastoreBrowserSearchResults {
    esxVI_HostDatastoreBrowserSearchResults *_next;        /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_ManagedObjectReference *datastore;               /* optional */
    char *folderPath;                                      /* optional */
    esxVI_FileInfo *file;                                  /* optional, list */
};

int esxVI_HostDatastoreBrowserSearchResults_Alloc(esxVI_HostDatastoreBrowserSearchResults **item);
void esxVI_HostDatastoreBrowserSearchResults_Free(esxVI_HostDatastoreBrowserSearchResults **item);
int esxVI_HostDatastoreBrowserSearchResults_Validate(esxVI_HostDatastoreBrowserSearchResults *item);
int esxVI_HostDatastoreBrowserSearchResults_AppendToList(esxVI_HostDatastoreBrowserSearchResults **list, esxVI_HostDatastoreBrowserSearchResults *item);
int esxVI_HostDatastoreBrowserSearchResults_CastFromAnyType(esxVI_AnyType *anyType, esxVI_HostDatastoreBrowserSearchResults **item);
int esxVI_HostDatastoreBrowserSearchResults_CastListFromAnyType(esxVI_AnyType *anyType, esxVI_HostDatastoreBrowserSearchResults **list);
int esxVI_HostDatastoreBrowserSearchResults_Deserialize(xmlNodePtr node, esxVI_HostDatastoreBrowserSearchResults **item);
int esxVI_HostDatastoreBrowserSearchResults_DeserializeList(xmlNodePtr node, esxVI_HostDatastoreBrowserSearchResults **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostDatastoreBrowserSearchSpec
 */

struct _esxVI_HostDatastoreBrowserSearchSpec {
    esxVI_HostDatastoreBrowserSearchSpec *_unused;         /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_FileQuery *query;                                /* optional, list */
    esxVI_FileQueryFlags *details;                         /* optional */
    esxVI_Boolean searchCaseInsensitive;                   /* optional */
    esxVI_String *matchPattern;                            /* optional, list */
    esxVI_Boolean sortFoldersFirst;                        /* optional */
};

int esxVI_HostDatastoreBrowserSearchSpec_Alloc(esxVI_HostDatastoreBrowserSearchSpec **item);
void esxVI_HostDatastoreBrowserSearchSpec_Free(esxVI_HostDatastoreBrowserSearchSpec **item);
int esxVI_HostDatastoreBrowserSearchSpec_Validate(esxVI_HostDatastoreBrowserSearchSpec *item);
int esxVI_HostDatastoreBrowserSearchSpec_Serialize(esxVI_HostDatastoreBrowserSearchSpec *item, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostDevice
 *            extended by ScsiLun
 */

struct _esxVI_HostDevice {
    esxVI_HostDevice *_next;                               /* optional */
    esxVI_Type _type;                                      /* required */

    char *deviceName;                                      /* required */
    char *deviceType;                                      /* required */
};

int esxVI_HostDevice_Alloc(esxVI_HostDevice **item);
void esxVI_HostDevice_Free(esxVI_HostDevice **item);
int esxVI_HostDevice_Validate(esxVI_HostDevice *item);
esxVI_HostDevice *esxVI_HostDevice_DynamicCast(void *item);
int esxVI_HostDevice_AppendToList(esxVI_HostDevice **list, esxVI_HostDevice *item);
int esxVI_HostDevice_DeepCopy(esxVI_HostDevice **dst, esxVI_HostDevice *src);
int esxVI_HostDevice_DeepCopyList(esxVI_HostDevice **dstList, esxVI_HostDevice *srcList);
int esxVI_HostDevice_CastFromAnyType(esxVI_AnyType *anyType, esxVI_HostDevice **item);
int esxVI_HostDevice_CastListFromAnyType(esxVI_AnyType *anyType, esxVI_HostDevice **list);
int esxVI_HostDevice_Deserialize(xmlNodePtr node, esxVI_HostDevice **item);
int esxVI_HostDevice_DeserializeList(xmlNodePtr node, esxVI_HostDevice **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostDiskDimensionsLba
 */

struct _esxVI_HostDiskDimensionsLba {
    esxVI_HostDiskDimensionsLba *_unused;                  /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_Int *blockSize;                                  /* required */
    esxVI_Long *block;                                     /* required */
};

int esxVI_HostDiskDimensionsLba_Alloc(esxVI_HostDiskDimensionsLba **item);
void esxVI_HostDiskDimensionsLba_Free(esxVI_HostDiskDimensionsLba **item);
int esxVI_HostDiskDimensionsLba_Validate(esxVI_HostDiskDimensionsLba *item);
int esxVI_HostDiskDimensionsLba_DeepCopy(esxVI_HostDiskDimensionsLba **dst, esxVI_HostDiskDimensionsLba *src);
int esxVI_HostDiskDimensionsLba_Deserialize(xmlNodePtr node, esxVI_HostDiskDimensionsLba **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostFibreChannelHba
 *            extends HostHostBusAdapter
 */

struct _esxVI_HostFibreChannelHba {
    esxVI_HostFibreChannelHba *_next;                      /* optional */
    esxVI_Type _type;                                      /* required */

    /* HostHostBusAdapter */
    char *key;                                             /* optional */
    char *device;                                          /* required */
    esxVI_Int *bus;                                        /* required */
    char *status;                                          /* required */
    char *model;                                           /* required */
    char *driver;                                          /* optional */
    char *pci;                                             /* optional */

    /* HostFibreChannelHba */
    esxVI_Long *portWorldWideName;                         /* required */
    esxVI_Long *nodeWorldWideName;                         /* required */
    esxVI_FibreChannelPortType portType;                   /* required */
    esxVI_Long *speed;                                     /* required */
};

int esxVI_HostFibreChannelHba_Alloc(esxVI_HostFibreChannelHba **item);
void esxVI_HostFibreChannelHba_Free(esxVI_HostFibreChannelHba **item);
int esxVI_HostFibreChannelHba_Validate(esxVI_HostFibreChannelHba *item);
esxVI_HostFibreChannelHba *esxVI_HostFibreChannelHba_DynamicCast(void *item);
int esxVI_HostFibreChannelHba_AppendToList(esxVI_HostFibreChannelHba **list, esxVI_HostFibreChannelHba *item);
int esxVI_HostFibreChannelHba_DeepCopy(esxVI_HostFibreChannelHba **dst, esxVI_HostFibreChannelHba *src);
int esxVI_HostFibreChannelHba_DeepCopyList(esxVI_HostFibreChannelHba **dstList, esxVI_HostFibreChannelHba *srcList);
int esxVI_HostFibreChannelHba_CastFromAnyType(esxVI_AnyType *anyType, esxVI_HostFibreChannelHba **item);
int esxVI_HostFibreChannelHba_CastListFromAnyType(esxVI_AnyType *anyType, esxVI_HostFibreChannelHba **list);
int esxVI_HostFibreChannelHba_Deserialize(xmlNodePtr node, esxVI_HostFibreChannelHba **item);
int esxVI_HostFibreChannelHba_DeserializeList(xmlNodePtr node, esxVI_HostFibreChannelHba **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostFibreChannelTargetTransport
 *            extends HostTargetTransport
 */

struct _esxVI_HostFibreChannelTargetTransport {
    esxVI_HostFibreChannelTargetTransport *_unused;        /* optional */
    esxVI_Type _type;                                      /* required */

    /* HostTargetTransport */
    /* no properties */

    /* HostFibreChannelTargetTransport */
    esxVI_Long *portWorldWideName;                         /* required */
    esxVI_Long *nodeWorldWideName;                         /* required */
};

int esxVI_HostFibreChannelTargetTransport_Alloc(esxVI_HostFibreChannelTargetTransport **item);
void esxVI_HostFibreChannelTargetTransport_Free(esxVI_HostFibreChannelTargetTransport **item);
int esxVI_HostFibreChannelTargetTransport_Validate(esxVI_HostFibreChannelTargetTransport *item);
esxVI_HostFibreChannelTargetTransport *esxVI_HostFibreChannelTargetTransport_DynamicCast(void *item);
int esxVI_HostFibreChannelTargetTransport_Deserialize(xmlNodePtr node, esxVI_HostFibreChannelTargetTransport **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostFileSystemVolume
 *            extended by HostNasVolume
 *                        HostVmfsVolume
 */

struct _esxVI_HostFileSystemVolume {
    esxVI_HostFileSystemVolume *_unused;                   /* optional */
    esxVI_Type _type;                                      /* required */

    char *type;                                            /* required */
    char *name;                                            /* required */
    esxVI_Long *capacity;                                  /* required */
};

int esxVI_HostFileSystemVolume_Alloc(esxVI_HostFileSystemVolume **item);
void esxVI_HostFileSystemVolume_Free(esxVI_HostFileSystemVolume **item);
int esxVI_HostFileSystemVolume_Validate(esxVI_HostFileSystemVolume *item);
int esxVI_HostFileSystemVolume_Deserialize(xmlNodePtr node, esxVI_HostFileSystemVolume **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostHostBusAdapter
 *            extended by HostBlockHba
 *                        HostFibreChannelHba
 *                        HostInternetScsiHba
 *                        HostParallelScsiHba
 */

struct _esxVI_HostHostBusAdapter {
    esxVI_HostHostBusAdapter *_next;                       /* optional */
    esxVI_Type _type;                                      /* required */

    char *key;                                             /* optional */
    char *device;                                          /* required */
    esxVI_Int *bus;                                        /* required */
    char *status;                                          /* required */
    char *model;                                           /* required */
    char *driver;                                          /* optional */
    char *pci;                                             /* optional */
};

int esxVI_HostHostBusAdapter_Alloc(esxVI_HostHostBusAdapter **item);
void esxVI_HostHostBusAdapter_Free(esxVI_HostHostBusAdapter **item);
int esxVI_HostHostBusAdapter_Validate(esxVI_HostHostBusAdapter *item);
esxVI_HostHostBusAdapter *esxVI_HostHostBusAdapter_DynamicCast(void *item);
int esxVI_HostHostBusAdapter_AppendToList(esxVI_HostHostBusAdapter **list, esxVI_HostHostBusAdapter *item);
int esxVI_HostHostBusAdapter_DeepCopy(esxVI_HostHostBusAdapter **dst, esxVI_HostHostBusAdapter *src);
int esxVI_HostHostBusAdapter_DeepCopyList(esxVI_HostHostBusAdapter **dstList, esxVI_HostHostBusAdapter *srcList);
int esxVI_HostHostBusAdapter_CastFromAnyType(esxVI_AnyType *anyType, esxVI_HostHostBusAdapter **item);
int esxVI_HostHostBusAdapter_CastListFromAnyType(esxVI_AnyType *anyType, esxVI_HostHostBusAdapter **list);
int esxVI_HostHostBusAdapter_Deserialize(xmlNodePtr node, esxVI_HostHostBusAdapter **item);
int esxVI_HostHostBusAdapter_DeserializeList(xmlNodePtr node, esxVI_HostHostBusAdapter **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostInternetScsiHba
 *            extends HostHostBusAdapter
 */

struct _esxVI_HostInternetScsiHba {
    esxVI_HostInternetScsiHba *_next;                      /* optional */
    esxVI_Type _type;                                      /* required */

    /* HostHostBusAdapter */
    char *key;                                             /* optional */
    char *device;                                          /* required */
    esxVI_Int *bus;                                        /* required */
    char *status;                                          /* required */
    char *model;                                           /* required */
    char *driver;                                          /* optional */
    char *pci;                                             /* optional */

    /* HostInternetScsiHba */
    esxVI_Boolean isSoftwareBased;                         /* required */
    esxVI_HostInternetScsiHbaDiscoveryCapabilities *discoveryCapabilities; /* required */
    esxVI_HostInternetScsiHbaDiscoveryProperties *discoveryProperties; /* required */
    esxVI_HostInternetScsiHbaAuthenticationCapabilities *authenticationCapabilities; /* required */
    esxVI_HostInternetScsiHbaAuthenticationProperties *authenticationProperties; /* required */
    esxVI_HostInternetScsiHbaDigestCapabilities *digestCapabilities; /* optional */
    esxVI_HostInternetScsiHbaDigestProperties *digestProperties; /* optional */
    esxVI_HostInternetScsiHbaIPCapabilities *ipCapabilities; /* required */
    esxVI_HostInternetScsiHbaIPProperties *ipProperties;   /* required */
    /* FIXME: supportedAdvancedOptions is currently ignored */
    esxVI_HostInternetScsiHbaParamValue *advancedOptions;  /* optional, list */
    char *iScsiName;                                       /* required */
    char *iScsiAlias;                                      /* optional */
    esxVI_HostInternetScsiHbaSendTarget *configuredSendTarget; /* optional, list */
    esxVI_HostInternetScsiHbaStaticTarget *configuredStaticTarget; /* optional, list */
    esxVI_Int *maxSpeedMb;                                 /* optional */
    esxVI_Int *currentSpeedMb;                             /* optional */
};

int esxVI_HostInternetScsiHba_Alloc(esxVI_HostInternetScsiHba **item);
void esxVI_HostInternetScsiHba_Free(esxVI_HostInternetScsiHba **item);
int esxVI_HostInternetScsiHba_Validate(esxVI_HostInternetScsiHba *item);
esxVI_HostInternetScsiHba *esxVI_HostInternetScsiHba_DynamicCast(void *item);
int esxVI_HostInternetScsiHba_AppendToList(esxVI_HostInternetScsiHba **list, esxVI_HostInternetScsiHba *item);
int esxVI_HostInternetScsiHba_DeepCopy(esxVI_HostInternetScsiHba **dst, esxVI_HostInternetScsiHba *src);
int esxVI_HostInternetScsiHba_DeepCopyList(esxVI_HostInternetScsiHba **dstList, esxVI_HostInternetScsiHba *srcList);
int esxVI_HostInternetScsiHba_CastFromAnyType(esxVI_AnyType *anyType, esxVI_HostInternetScsiHba **item);
int esxVI_HostInternetScsiHba_CastListFromAnyType(esxVI_AnyType *anyType, esxVI_HostInternetScsiHba **list);
int esxVI_HostInternetScsiHba_Deserialize(xmlNodePtr node, esxVI_HostInternetScsiHba **item);
int esxVI_HostInternetScsiHba_DeserializeList(xmlNodePtr node, esxVI_HostInternetScsiHba **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostInternetScsiHbaAuthenticationCapabilities
 */

struct _esxVI_HostInternetScsiHbaAuthenticationCapabilities {
    esxVI_HostInternetScsiHbaAuthenticationCapabilities *_unused; /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_Boolean chapAuthSettable;                        /* required */
    esxVI_Boolean krb5AuthSettable;                        /* required */
    esxVI_Boolean srpAuthSettable;                         /* required */
    esxVI_Boolean spkmAuthSettable;                        /* required */
    esxVI_Boolean mutualChapSettable;                      /* optional */
    esxVI_Boolean targetChapSettable;                      /* optional */
    esxVI_Boolean targetMutualChapSettable;                /* optional */
};

int esxVI_HostInternetScsiHbaAuthenticationCapabilities_Alloc(esxVI_HostInternetScsiHbaAuthenticationCapabilities **item);
void esxVI_HostInternetScsiHbaAuthenticationCapabilities_Free(esxVI_HostInternetScsiHbaAuthenticationCapabilities **item);
int esxVI_HostInternetScsiHbaAuthenticationCapabilities_Validate(esxVI_HostInternetScsiHbaAuthenticationCapabilities *item);
int esxVI_HostInternetScsiHbaAuthenticationCapabilities_DeepCopy(esxVI_HostInternetScsiHbaAuthenticationCapabilities **dst, esxVI_HostInternetScsiHbaAuthenticationCapabilities *src);
int esxVI_HostInternetScsiHbaAuthenticationCapabilities_Deserialize(xmlNodePtr node, esxVI_HostInternetScsiHbaAuthenticationCapabilities **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostInternetScsiHbaAuthenticationProperties
 */

struct _esxVI_HostInternetScsiHbaAuthenticationProperties {
    esxVI_HostInternetScsiHbaAuthenticationProperties *_unused; /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_Boolean chapAuthEnabled;                         /* required */
    char *chapName;                                        /* optional */
    char *chapSecret;                                      /* optional */
    char *chapAuthenticationType;                          /* optional */
    esxVI_Boolean chapInherited;                           /* optional */
    char *mutualChapName;                                  /* optional */
    char *mutualChapSecret;                                /* optional */
    char *mutualChapAuthenticationType;                    /* optional */
    esxVI_Boolean mutualChapInherited;                     /* optional */
};

int esxVI_HostInternetScsiHbaAuthenticationProperties_Alloc(esxVI_HostInternetScsiHbaAuthenticationProperties **item);
void esxVI_HostInternetScsiHbaAuthenticationProperties_Free(esxVI_HostInternetScsiHbaAuthenticationProperties **item);
int esxVI_HostInternetScsiHbaAuthenticationProperties_Validate(esxVI_HostInternetScsiHbaAuthenticationProperties *item);
int esxVI_HostInternetScsiHbaAuthenticationProperties_DeepCopy(esxVI_HostInternetScsiHbaAuthenticationProperties **dst, esxVI_HostInternetScsiHbaAuthenticationProperties *src);
int esxVI_HostInternetScsiHbaAuthenticationProperties_Deserialize(xmlNodePtr node, esxVI_HostInternetScsiHbaAuthenticationProperties **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostInternetScsiHbaDigestCapabilities
 */

struct _esxVI_HostInternetScsiHbaDigestCapabilities {
    esxVI_HostInternetScsiHbaDigestCapabilities *_unused;  /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_Boolean headerDigestSettable;                    /* optional */
    esxVI_Boolean dataDigestSettable;                      /* optional */
    esxVI_Boolean targetHeaderDigestSettable;              /* optional */
    esxVI_Boolean targetDataDigestSettable;                /* optional */
};

int esxVI_HostInternetScsiHbaDigestCapabilities_Alloc(esxVI_HostInternetScsiHbaDigestCapabilities **item);
void esxVI_HostInternetScsiHbaDigestCapabilities_Free(esxVI_HostInternetScsiHbaDigestCapabilities **item);
int esxVI_HostInternetScsiHbaDigestCapabilities_Validate(esxVI_HostInternetScsiHbaDigestCapabilities *item);
int esxVI_HostInternetScsiHbaDigestCapabilities_DeepCopy(esxVI_HostInternetScsiHbaDigestCapabilities **dst, esxVI_HostInternetScsiHbaDigestCapabilities *src);
int esxVI_HostInternetScsiHbaDigestCapabilities_Deserialize(xmlNodePtr node, esxVI_HostInternetScsiHbaDigestCapabilities **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostInternetScsiHbaDigestProperties
 */

struct _esxVI_HostInternetScsiHbaDigestProperties {
    esxVI_HostInternetScsiHbaDigestProperties *_unused;    /* optional */
    esxVI_Type _type;                                      /* required */

    char *headerDigestType;                                /* optional */
    esxVI_Boolean headerDigestInherited;                   /* optional */
    char *dataDigestType;                                  /* optional */
    esxVI_Boolean dataDigestInherited;                     /* optional */
};

int esxVI_HostInternetScsiHbaDigestProperties_Alloc(esxVI_HostInternetScsiHbaDigestProperties **item);
void esxVI_HostInternetScsiHbaDigestProperties_Free(esxVI_HostInternetScsiHbaDigestProperties **item);
int esxVI_HostInternetScsiHbaDigestProperties_Validate(esxVI_HostInternetScsiHbaDigestProperties *item);
int esxVI_HostInternetScsiHbaDigestProperties_DeepCopy(esxVI_HostInternetScsiHbaDigestProperties **dst, esxVI_HostInternetScsiHbaDigestProperties *src);
int esxVI_HostInternetScsiHbaDigestProperties_Deserialize(xmlNodePtr node, esxVI_HostInternetScsiHbaDigestProperties **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostInternetScsiHbaDiscoveryCapabilities
 */

struct _esxVI_HostInternetScsiHbaDiscoveryCapabilities {
    esxVI_HostInternetScsiHbaDiscoveryCapabilities *_unused; /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_Boolean iSnsDiscoverySettable;                   /* required */
    esxVI_Boolean slpDiscoverySettable;                    /* required */
    esxVI_Boolean staticTargetDiscoverySettable;           /* required */
    esxVI_Boolean sendTargetsDiscoverySettable;            /* required */
};

int esxVI_HostInternetScsiHbaDiscoveryCapabilities_Alloc(esxVI_HostInternetScsiHbaDiscoveryCapabilities **item);
void esxVI_HostInternetScsiHbaDiscoveryCapabilities_Free(esxVI_HostInternetScsiHbaDiscoveryCapabilities **item);
int esxVI_HostInternetScsiHbaDiscoveryCapabilities_Validate(esxVI_HostInternetScsiHbaDiscoveryCapabilities *item);
int esxVI_HostInternetScsiHbaDiscoveryCapabilities_DeepCopy(esxVI_HostInternetScsiHbaDiscoveryCapabilities **dst, esxVI_HostInternetScsiHbaDiscoveryCapabilities *src);
int esxVI_HostInternetScsiHbaDiscoveryCapabilities_Deserialize(xmlNodePtr node, esxVI_HostInternetScsiHbaDiscoveryCapabilities **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostInternetScsiHbaDiscoveryProperties
 */

struct _esxVI_HostInternetScsiHbaDiscoveryProperties {
    esxVI_HostInternetScsiHbaDiscoveryProperties *_unused; /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_Boolean iSnsDiscoveryEnabled;                    /* required */
    char *iSnsDiscoveryMethod;                             /* optional */
    char *iSnsHost;                                        /* optional */
    esxVI_Boolean slpDiscoveryEnabled;                     /* required */
    char *slpDiscoveryMethod;                              /* optional */
    char *slpHost;                                         /* optional */
    esxVI_Boolean staticTargetDiscoveryEnabled;            /* required */
    esxVI_Boolean sendTargetsDiscoveryEnabled;             /* required */
};

int esxVI_HostInternetScsiHbaDiscoveryProperties_Alloc(esxVI_HostInternetScsiHbaDiscoveryProperties **item);
void esxVI_HostInternetScsiHbaDiscoveryProperties_Free(esxVI_HostInternetScsiHbaDiscoveryProperties **item);
int esxVI_HostInternetScsiHbaDiscoveryProperties_Validate(esxVI_HostInternetScsiHbaDiscoveryProperties *item);
int esxVI_HostInternetScsiHbaDiscoveryProperties_DeepCopy(esxVI_HostInternetScsiHbaDiscoveryProperties **dst, esxVI_HostInternetScsiHbaDiscoveryProperties *src);
int esxVI_HostInternetScsiHbaDiscoveryProperties_Deserialize(xmlNodePtr node, esxVI_HostInternetScsiHbaDiscoveryProperties **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostInternetScsiHbaIPCapabilities
 */

struct _esxVI_HostInternetScsiHbaIPCapabilities {
    esxVI_HostInternetScsiHbaIPCapabilities *_unused;      /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_Boolean addressSettable;                         /* required */
    esxVI_Boolean ipConfigurationMethodSettable;           /* required */
    esxVI_Boolean subnetMaskSettable;                      /* required */
    esxVI_Boolean defaultGatewaySettable;                  /* required */
    esxVI_Boolean primaryDnsServerAddressSettable;         /* required */
    esxVI_Boolean alternateDnsServerAddressSettable;       /* required */
    esxVI_Boolean ipv6Supported;                           /* optional */
    esxVI_Boolean arpRedirectSettable;                     /* optional */
    esxVI_Boolean mtuSettable;                             /* optional */
    esxVI_Boolean hostNameAsTargetAddress;                 /* optional */
};

int esxVI_HostInternetScsiHbaIPCapabilities_Alloc(esxVI_HostInternetScsiHbaIPCapabilities **item);
void esxVI_HostInternetScsiHbaIPCapabilities_Free(esxVI_HostInternetScsiHbaIPCapabilities **item);
int esxVI_HostInternetScsiHbaIPCapabilities_Validate(esxVI_HostInternetScsiHbaIPCapabilities *item);
int esxVI_HostInternetScsiHbaIPCapabilities_DeepCopy(esxVI_HostInternetScsiHbaIPCapabilities **dst, esxVI_HostInternetScsiHbaIPCapabilities *src);
int esxVI_HostInternetScsiHbaIPCapabilities_Deserialize(xmlNodePtr node, esxVI_HostInternetScsiHbaIPCapabilities **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostInternetScsiHbaIPProperties
 */

struct _esxVI_HostInternetScsiHbaIPProperties {
    esxVI_HostInternetScsiHbaIPProperties *_unused;        /* optional */
    esxVI_Type _type;                                      /* required */

    char *mac;                                             /* optional */
    char *address;                                         /* optional */
    esxVI_Boolean dhcpConfigurationEnabled;                /* required */
    char *subnetMask;                                      /* optional */
    char *defaultGateway;                                  /* optional */
    char *primaryDnsServerAddress;                         /* optional */
    char *alternateDnsServerAddress;                       /* optional */
    char *ipv6Address;                                     /* optional */
    char *ipv6SubnetMask;                                  /* optional */
    char *ipv6DefaultGateway;                              /* optional */
    esxVI_Boolean arpRedirectEnabled;                      /* optional */
    esxVI_Int *mtu;                                        /* optional */
    esxVI_Boolean jumboFramesEnabled;                      /* optional */
};

int esxVI_HostInternetScsiHbaIPProperties_Alloc(esxVI_HostInternetScsiHbaIPProperties **item);
void esxVI_HostInternetScsiHbaIPProperties_Free(esxVI_HostInternetScsiHbaIPProperties **item);
int esxVI_HostInternetScsiHbaIPProperties_Validate(esxVI_HostInternetScsiHbaIPProperties *item);
int esxVI_HostInternetScsiHbaIPProperties_DeepCopy(esxVI_HostInternetScsiHbaIPProperties **dst, esxVI_HostInternetScsiHbaIPProperties *src);
int esxVI_HostInternetScsiHbaIPProperties_Deserialize(xmlNodePtr node, esxVI_HostInternetScsiHbaIPProperties **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostInternetScsiHbaParamValue
 *            extends OptionValue
 */

struct _esxVI_HostInternetScsiHbaParamValue {
    esxVI_HostInternetScsiHbaParamValue *_next;            /* optional */
    esxVI_Type _type;                                      /* required */

    /* OptionValue */
    char *key;                                             /* required */
    esxVI_AnyType *value;                                  /* optional */

    /* HostInternetScsiHbaParamValue */
    esxVI_Boolean isInherited;                             /* optional */
};

int esxVI_HostInternetScsiHbaParamValue_Alloc(esxVI_HostInternetScsiHbaParamValue **item);
void esxVI_HostInternetScsiHbaParamValue_Free(esxVI_HostInternetScsiHbaParamValue **item);
int esxVI_HostInternetScsiHbaParamValue_Validate(esxVI_HostInternetScsiHbaParamValue *item);
esxVI_HostInternetScsiHbaParamValue *esxVI_HostInternetScsiHbaParamValue_DynamicCast(void *item);
int esxVI_HostInternetScsiHbaParamValue_AppendToList(esxVI_HostInternetScsiHbaParamValue **list, esxVI_HostInternetScsiHbaParamValue *item);
int esxVI_HostInternetScsiHbaParamValue_DeepCopy(esxVI_HostInternetScsiHbaParamValue **dst, esxVI_HostInternetScsiHbaParamValue *src);
int esxVI_HostInternetScsiHbaParamValue_DeepCopyList(esxVI_HostInternetScsiHbaParamValue **dstList, esxVI_HostInternetScsiHbaParamValue *srcList);
int esxVI_HostInternetScsiHbaParamValue_Deserialize(xmlNodePtr node, esxVI_HostInternetScsiHbaParamValue **item);
int esxVI_HostInternetScsiHbaParamValue_DeserializeList(xmlNodePtr node, esxVI_HostInternetScsiHbaParamValue **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostInternetScsiHbaSendTarget
 */

struct _esxVI_HostInternetScsiHbaSendTarget {
    esxVI_HostInternetScsiHbaSendTarget *_next;            /* optional */
    esxVI_Type _type;                                      /* required */

    char *address;                                         /* required */
    esxVI_Int *port;                                       /* optional */
    esxVI_HostInternetScsiHbaAuthenticationProperties *authenticationProperties; /* optional */
    esxVI_HostInternetScsiHbaDigestProperties *digestProperties; /* optional */
    /* FIXME: supportedAdvancedOptions is currently ignored */
    esxVI_HostInternetScsiHbaParamValue *advancedOptions;  /* optional, list */
    char *parent;                                          /* optional */
};

int esxVI_HostInternetScsiHbaSendTarget_Alloc(esxVI_HostInternetScsiHbaSendTarget **item);
void esxVI_HostInternetScsiHbaSendTarget_Free(esxVI_HostInternetScsiHbaSendTarget **item);
int esxVI_HostInternetScsiHbaSendTarget_Validate(esxVI_HostInternetScsiHbaSendTarget *item);
int esxVI_HostInternetScsiHbaSendTarget_AppendToList(esxVI_HostInternetScsiHbaSendTarget **list, esxVI_HostInternetScsiHbaSendTarget *item);
int esxVI_HostInternetScsiHbaSendTarget_DeepCopy(esxVI_HostInternetScsiHbaSendTarget **dst, esxVI_HostInternetScsiHbaSendTarget *src);
int esxVI_HostInternetScsiHbaSendTarget_DeepCopyList(esxVI_HostInternetScsiHbaSendTarget **dstList, esxVI_HostInternetScsiHbaSendTarget *srcList);
int esxVI_HostInternetScsiHbaSendTarget_Deserialize(xmlNodePtr node, esxVI_HostInternetScsiHbaSendTarget **item);
int esxVI_HostInternetScsiHbaSendTarget_DeserializeList(xmlNodePtr node, esxVI_HostInternetScsiHbaSendTarget **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostInternetScsiHbaStaticTarget
 */

struct _esxVI_HostInternetScsiHbaStaticTarget {
    esxVI_HostInternetScsiHbaStaticTarget *_next;          /* optional */
    esxVI_Type _type;                                      /* required */

    char *address;                                         /* required */
    esxVI_Int *port;                                       /* optional */
    char *iScsiName;                                       /* required */
    esxVI_HostInternetScsiHbaAuthenticationProperties *authenticationProperties; /* optional */
    esxVI_HostInternetScsiHbaDigestProperties *digestProperties; /* optional */
    /* FIXME: supportedAdvancedOptions is currently ignored */
    esxVI_HostInternetScsiHbaParamValue *advancedOptions;  /* optional, list */
    char *parent;                                          /* optional */
};

int esxVI_HostInternetScsiHbaStaticTarget_Alloc(esxVI_HostInternetScsiHbaStaticTarget **item);
void esxVI_HostInternetScsiHbaStaticTarget_Free(esxVI_HostInternetScsiHbaStaticTarget **item);
int esxVI_HostInternetScsiHbaStaticTarget_Validate(esxVI_HostInternetScsiHbaStaticTarget *item);
int esxVI_HostInternetScsiHbaStaticTarget_AppendToList(esxVI_HostInternetScsiHbaStaticTarget **list, esxVI_HostInternetScsiHbaStaticTarget *item);
int esxVI_HostInternetScsiHbaStaticTarget_DeepCopy(esxVI_HostInternetScsiHbaStaticTarget **dst, esxVI_HostInternetScsiHbaStaticTarget *src);
int esxVI_HostInternetScsiHbaStaticTarget_DeepCopyList(esxVI_HostInternetScsiHbaStaticTarget **dstList, esxVI_HostInternetScsiHbaStaticTarget *srcList);
int esxVI_HostInternetScsiHbaStaticTarget_Deserialize(xmlNodePtr node, esxVI_HostInternetScsiHbaStaticTarget **item);
int esxVI_HostInternetScsiHbaStaticTarget_DeserializeList(xmlNodePtr node, esxVI_HostInternetScsiHbaStaticTarget **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostInternetScsiTargetTransport
 *            extends HostTargetTransport
 */

struct _esxVI_HostInternetScsiTargetTransport {
    esxVI_HostInternetScsiTargetTransport *_unused;        /* optional */
    esxVI_Type _type;                                      /* required */

    /* HostTargetTransport */
    /* no properties */

    /* HostInternetScsiTargetTransport */
    char *iScsiName;                                       /* required */
    char *iScsiAlias;                                      /* required */
    esxVI_String *address;                                 /* optional, list */
};

int esxVI_HostInternetScsiTargetTransport_Alloc(esxVI_HostInternetScsiTargetTransport **item);
void esxVI_HostInternetScsiTargetTransport_Free(esxVI_HostInternetScsiTargetTransport **item);
int esxVI_HostInternetScsiTargetTransport_Validate(esxVI_HostInternetScsiTargetTransport *item);
esxVI_HostInternetScsiTargetTransport *esxVI_HostInternetScsiTargetTransport_DynamicCast(void *item);
int esxVI_HostInternetScsiTargetTransport_Deserialize(xmlNodePtr node, esxVI_HostInternetScsiTargetTransport **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostIpConfig
 */

struct _esxVI_HostIpConfig {
    esxVI_HostIpConfig *_unused;                           /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_Boolean dhcp;                                    /* required */
    char *ipAddress;                                       /* optional */
    char *subnetMask;                                      /* optional */
    /* FIXME: ipV6Config is currently ignored */
};

int esxVI_HostIpConfig_Alloc(esxVI_HostIpConfig **item);
void esxVI_HostIpConfig_Free(esxVI_HostIpConfig **item);
int esxVI_HostIpConfig_Validate(esxVI_HostIpConfig *item);
int esxVI_HostIpConfig_DeepCopy(esxVI_HostIpConfig **dst, esxVI_HostIpConfig *src);
int esxVI_HostIpConfig_Deserialize(xmlNodePtr node, esxVI_HostIpConfig **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostMountInfo
 */

struct _esxVI_HostMountInfo {
    esxVI_HostMountInfo *_unused;                          /* optional */
    esxVI_Type _type;                                      /* required */

    char *path;                                            /* optional */
    char *accessMode;                                      /* required */
    esxVI_Boolean accessible;                              /* optional */
};

int esxVI_HostMountInfo_Alloc(esxVI_HostMountInfo **item);
void esxVI_HostMountInfo_Free(esxVI_HostMountInfo **item);
int esxVI_HostMountInfo_Validate(esxVI_HostMountInfo *item);
int esxVI_HostMountInfo_DeepCopy(esxVI_HostMountInfo **dst, esxVI_HostMountInfo *src);
int esxVI_HostMountInfo_Deserialize(xmlNodePtr node, esxVI_HostMountInfo **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostNasVolume
 *            extends HostFileSystemVolume
 */

struct _esxVI_HostNasVolume {
    esxVI_HostNasVolume *_unused;                          /* optional */
    esxVI_Type _type;                                      /* required */

    /* HostFileSystemVolume */
    char *type;                                            /* required */
    char *name;                                            /* required */
    esxVI_Long *capacity;                                  /* required */

    /* HostNasVolume */
    char *remoteHost;                                      /* required */
    char *remotePath;                                      /* required */
    char *userName;                                        /* optional */
};

int esxVI_HostNasVolume_Alloc(esxVI_HostNasVolume **item);
void esxVI_HostNasVolume_Free(esxVI_HostNasVolume **item);
int esxVI_HostNasVolume_Validate(esxVI_HostNasVolume *item);
int esxVI_HostNasVolume_Deserialize(xmlNodePtr node, esxVI_HostNasVolume **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostNetOffloadCapabilities
 */

struct _esxVI_HostNetOffloadCapabilities {
    esxVI_HostNetOffloadCapabilities *_unused;             /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_Boolean csumOffload;                             /* optional */
    esxVI_Boolean tcpSegmentation;                         /* optional */
    esxVI_Boolean zeroCopyXmit;                            /* optional */
};

int esxVI_HostNetOffloadCapabilities_Alloc(esxVI_HostNetOffloadCapabilities **item);
void esxVI_HostNetOffloadCapabilities_Free(esxVI_HostNetOffloadCapabilities **item);
int esxVI_HostNetOffloadCapabilities_Validate(esxVI_HostNetOffloadCapabilities *item);
int esxVI_HostNetOffloadCapabilities_DeepCopy(esxVI_HostNetOffloadCapabilities **dst, esxVI_HostNetOffloadCapabilities *src);
int esxVI_HostNetOffloadCapabilities_Serialize(esxVI_HostNetOffloadCapabilities *item, const char *element, virBufferPtr output);
int esxVI_HostNetOffloadCapabilities_Deserialize(xmlNodePtr node, esxVI_HostNetOffloadCapabilities **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostNetworkPolicy
 */

struct _esxVI_HostNetworkPolicy {
    esxVI_HostNetworkPolicy *_unused;                      /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_HostNetworkSecurityPolicy *security;             /* optional */
    esxVI_HostNicTeamingPolicy *nicTeaming;                /* optional */
    esxVI_HostNetOffloadCapabilities *offloadPolicy;       /* optional */
    esxVI_HostNetworkTrafficShapingPolicy *shapingPolicy;  /* optional */
};

int esxVI_HostNetworkPolicy_Alloc(esxVI_HostNetworkPolicy **item);
void esxVI_HostNetworkPolicy_Free(esxVI_HostNetworkPolicy **item);
int esxVI_HostNetworkPolicy_Validate(esxVI_HostNetworkPolicy *item);
int esxVI_HostNetworkPolicy_DeepCopy(esxVI_HostNetworkPolicy **dst, esxVI_HostNetworkPolicy *src);
int esxVI_HostNetworkPolicy_Serialize(esxVI_HostNetworkPolicy *item, const char *element, virBufferPtr output);
int esxVI_HostNetworkPolicy_Deserialize(xmlNodePtr node, esxVI_HostNetworkPolicy **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostNetworkSecurityPolicy
 */

struct _esxVI_HostNetworkSecurityPolicy {
    esxVI_HostNetworkSecurityPolicy *_unused;              /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_Boolean allowPromiscuous;                        /* optional */
    esxVI_Boolean macChanges;                              /* optional */
    esxVI_Boolean forgedTransmits;                         /* optional */
};

int esxVI_HostNetworkSecurityPolicy_Alloc(esxVI_HostNetworkSecurityPolicy **item);
void esxVI_HostNetworkSecurityPolicy_Free(esxVI_HostNetworkSecurityPolicy **item);
int esxVI_HostNetworkSecurityPolicy_Validate(esxVI_HostNetworkSecurityPolicy *item);
int esxVI_HostNetworkSecurityPolicy_DeepCopy(esxVI_HostNetworkSecurityPolicy **dst, esxVI_HostNetworkSecurityPolicy *src);
int esxVI_HostNetworkSecurityPolicy_Serialize(esxVI_HostNetworkSecurityPolicy *item, const char *element, virBufferPtr output);
int esxVI_HostNetworkSecurityPolicy_Deserialize(xmlNodePtr node, esxVI_HostNetworkSecurityPolicy **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostNetworkTrafficShapingPolicy
 */

struct _esxVI_HostNetworkTrafficShapingPolicy {
    esxVI_HostNetworkTrafficShapingPolicy *_unused;        /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_Boolean enabled;                                 /* optional */
    esxVI_Long *averageBandwidth;                          /* optional */
    esxVI_Long *peakBandwidth;                             /* optional */
    esxVI_Long *burstSize;                                 /* optional */
};

int esxVI_HostNetworkTrafficShapingPolicy_Alloc(esxVI_HostNetworkTrafficShapingPolicy **item);
void esxVI_HostNetworkTrafficShapingPolicy_Free(esxVI_HostNetworkTrafficShapingPolicy **item);
int esxVI_HostNetworkTrafficShapingPolicy_Validate(esxVI_HostNetworkTrafficShapingPolicy *item);
int esxVI_HostNetworkTrafficShapingPolicy_DeepCopy(esxVI_HostNetworkTrafficShapingPolicy **dst, esxVI_HostNetworkTrafficShapingPolicy *src);
int esxVI_HostNetworkTrafficShapingPolicy_Serialize(esxVI_HostNetworkTrafficShapingPolicy *item, const char *element, virBufferPtr output);
int esxVI_HostNetworkTrafficShapingPolicy_Deserialize(xmlNodePtr node, esxVI_HostNetworkTrafficShapingPolicy **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostNicFailureCriteria
 */

struct _esxVI_HostNicFailureCriteria {
    esxVI_HostNicFailureCriteria *_unused;                 /* optional */
    esxVI_Type _type;                                      /* required */

    char *checkSpeed;                                      /* optional */
    esxVI_Int *speed;                                      /* optional */
    esxVI_Boolean checkDuplex;                             /* optional */
    esxVI_Boolean fullDuplex;                              /* optional */
    esxVI_Boolean checkErrorPercent;                       /* optional */
    esxVI_Int *percentage;                                 /* optional */
    esxVI_Boolean checkBeacon;                             /* optional */
};

int esxVI_HostNicFailureCriteria_Alloc(esxVI_HostNicFailureCriteria **item);
void esxVI_HostNicFailureCriteria_Free(esxVI_HostNicFailureCriteria **item);
int esxVI_HostNicFailureCriteria_Validate(esxVI_HostNicFailureCriteria *item);
int esxVI_HostNicFailureCriteria_DeepCopy(esxVI_HostNicFailureCriteria **dst, esxVI_HostNicFailureCriteria *src);
int esxVI_HostNicFailureCriteria_Serialize(esxVI_HostNicFailureCriteria *item, const char *element, virBufferPtr output);
int esxVI_HostNicFailureCriteria_Deserialize(xmlNodePtr node, esxVI_HostNicFailureCriteria **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostNicOrderPolicy
 */

struct _esxVI_HostNicOrderPolicy {
    esxVI_HostNicOrderPolicy *_unused;                     /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_String *activeNic;                               /* optional, list */
    esxVI_String *standbyNic;                              /* optional, list */
};

int esxVI_HostNicOrderPolicy_Alloc(esxVI_HostNicOrderPolicy **item);
void esxVI_HostNicOrderPolicy_Free(esxVI_HostNicOrderPolicy **item);
int esxVI_HostNicOrderPolicy_Validate(esxVI_HostNicOrderPolicy *item);
int esxVI_HostNicOrderPolicy_DeepCopy(esxVI_HostNicOrderPolicy **dst, esxVI_HostNicOrderPolicy *src);
int esxVI_HostNicOrderPolicy_Serialize(esxVI_HostNicOrderPolicy *item, const char *element, virBufferPtr output);
int esxVI_HostNicOrderPolicy_Deserialize(xmlNodePtr node, esxVI_HostNicOrderPolicy **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostNicTeamingPolicy
 */

struct _esxVI_HostNicTeamingPolicy {
    esxVI_HostNicTeamingPolicy *_unused;                   /* optional */
    esxVI_Type _type;                                      /* required */

    char *policy;                                          /* optional */
    esxVI_Boolean reversePolicy;                           /* optional */
    esxVI_Boolean notifySwitches;                          /* optional */
    esxVI_Boolean rollingOrder;                            /* optional */
    esxVI_HostNicFailureCriteria *failureCriteria;         /* optional */
    esxVI_HostNicOrderPolicy *nicOrder;                    /* optional */
};

int esxVI_HostNicTeamingPolicy_Alloc(esxVI_HostNicTeamingPolicy **item);
void esxVI_HostNicTeamingPolicy_Free(esxVI_HostNicTeamingPolicy **item);
int esxVI_HostNicTeamingPolicy_Validate(esxVI_HostNicTeamingPolicy *item);
int esxVI_HostNicTeamingPolicy_DeepCopy(esxVI_HostNicTeamingPolicy **dst, esxVI_HostNicTeamingPolicy *src);
int esxVI_HostNicTeamingPolicy_Serialize(esxVI_HostNicTeamingPolicy *item, const char *element, virBufferPtr output);
int esxVI_HostNicTeamingPolicy_Deserialize(xmlNodePtr node, esxVI_HostNicTeamingPolicy **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostParallelScsiHba
 *            extends HostHostBusAdapter
 */

struct _esxVI_HostParallelScsiHba {
    esxVI_HostParallelScsiHba *_next;                      /* optional */
    esxVI_Type _type;                                      /* required */

    /* HostHostBusAdapter */
    char *key;                                             /* optional */
    char *device;                                          /* required */
    esxVI_Int *bus;                                        /* required */
    char *status;                                          /* required */
    char *model;                                           /* required */
    char *driver;                                          /* optional */
    char *pci;                                             /* optional */

    /* HostParallelScsiHba */
    /* no properties */
};

int esxVI_HostParallelScsiHba_Alloc(esxVI_HostParallelScsiHba **item);
void esxVI_HostParallelScsiHba_Free(esxVI_HostParallelScsiHba **item);
int esxVI_HostParallelScsiHba_Validate(esxVI_HostParallelScsiHba *item);
esxVI_HostParallelScsiHba *esxVI_HostParallelScsiHba_DynamicCast(void *item);
int esxVI_HostParallelScsiHba_AppendToList(esxVI_HostParallelScsiHba **list, esxVI_HostParallelScsiHba *item);
int esxVI_HostParallelScsiHba_DeepCopy(esxVI_HostParallelScsiHba **dst, esxVI_HostParallelScsiHba *src);
int esxVI_HostParallelScsiHba_DeepCopyList(esxVI_HostParallelScsiHba **dstList, esxVI_HostParallelScsiHba *srcList);
int esxVI_HostParallelScsiHba_CastFromAnyType(esxVI_AnyType *anyType, esxVI_HostParallelScsiHba **item);
int esxVI_HostParallelScsiHba_CastListFromAnyType(esxVI_AnyType *anyType, esxVI_HostParallelScsiHba **list);
int esxVI_HostParallelScsiHba_Deserialize(xmlNodePtr node, esxVI_HostParallelScsiHba **item);
int esxVI_HostParallelScsiHba_DeserializeList(xmlNodePtr node, esxVI_HostParallelScsiHba **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostParallelScsiTargetTransport
 *            extends HostTargetTransport
 */

struct _esxVI_HostParallelScsiTargetTransport {
    esxVI_HostParallelScsiTargetTransport *_unused;        /* optional */
    esxVI_Type _type;                                      /* required */

    /* HostTargetTransport */
    /* no properties */

    /* HostParallelScsiTargetTransport */
    /* no properties */
};

int esxVI_HostParallelScsiTargetTransport_Alloc(esxVI_HostParallelScsiTargetTransport **item);
void esxVI_HostParallelScsiTargetTransport_Free(esxVI_HostParallelScsiTargetTransport **item);
int esxVI_HostParallelScsiTargetTransport_Validate(esxVI_HostParallelScsiTargetTransport *item);
esxVI_HostParallelScsiTargetTransport *esxVI_HostParallelScsiTargetTransport_DynamicCast(void *item);
int esxVI_HostParallelScsiTargetTransport_Deserialize(xmlNodePtr node, esxVI_HostParallelScsiTargetTransport **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostPortGroup
 */

struct _esxVI_HostPortGroup {
    esxVI_HostPortGroup *_next;                            /* optional */
    esxVI_Type _type;                                      /* required */

    char *key;                                             /* optional */
    esxVI_HostPortGroupPort *port;                         /* optional, list */
    char *vswitch;                                         /* optional */
    esxVI_HostNetworkPolicy *computedPolicy;               /* required */
    esxVI_HostPortGroupSpec *spec;                         /* required */
};

int esxVI_HostPortGroup_Alloc(esxVI_HostPortGroup **item);
void esxVI_HostPortGroup_Free(esxVI_HostPortGroup **item);
int esxVI_HostPortGroup_Validate(esxVI_HostPortGroup *item);
int esxVI_HostPortGroup_AppendToList(esxVI_HostPortGroup **list, esxVI_HostPortGroup *item);
int esxVI_HostPortGroup_CastFromAnyType(esxVI_AnyType *anyType, esxVI_HostPortGroup **item);
int esxVI_HostPortGroup_CastListFromAnyType(esxVI_AnyType *anyType, esxVI_HostPortGroup **list);
int esxVI_HostPortGroup_Deserialize(xmlNodePtr node, esxVI_HostPortGroup **item);
int esxVI_HostPortGroup_DeserializeList(xmlNodePtr node, esxVI_HostPortGroup **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostPortGroupPort
 */

struct _esxVI_HostPortGroupPort {
    esxVI_HostPortGroupPort *_next;                        /* optional */
    esxVI_Type _type;                                      /* required */

    char *key;                                             /* optional */
    esxVI_String *mac;                                     /* optional, list */
    char *type;                                            /* required */
};

int esxVI_HostPortGroupPort_Alloc(esxVI_HostPortGroupPort **item);
void esxVI_HostPortGroupPort_Free(esxVI_HostPortGroupPort **item);
int esxVI_HostPortGroupPort_Validate(esxVI_HostPortGroupPort *item);
int esxVI_HostPortGroupPort_AppendToList(esxVI_HostPortGroupPort **list, esxVI_HostPortGroupPort *item);
int esxVI_HostPortGroupPort_Deserialize(xmlNodePtr node, esxVI_HostPortGroupPort **item);
int esxVI_HostPortGroupPort_DeserializeList(xmlNodePtr node, esxVI_HostPortGroupPort **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostPortGroupSpec
 */

struct _esxVI_HostPortGroupSpec {
    esxVI_HostPortGroupSpec *_unused;                      /* optional */
    esxVI_Type _type;                                      /* required */

    char *name;                                            /* required */
    esxVI_Int *vlanId;                                     /* required */
    char *vswitchName;                                     /* required */
    esxVI_HostNetworkPolicy *policy;                       /* required */
};

int esxVI_HostPortGroupSpec_Alloc(esxVI_HostPortGroupSpec **item);
void esxVI_HostPortGroupSpec_Free(esxVI_HostPortGroupSpec **item);
int esxVI_HostPortGroupSpec_Validate(esxVI_HostPortGroupSpec *item);
int esxVI_HostPortGroupSpec_Serialize(esxVI_HostPortGroupSpec *item, const char *element, virBufferPtr output);
int esxVI_HostPortGroupSpec_Deserialize(xmlNodePtr node, esxVI_HostPortGroupSpec **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostScsiDisk
 *            extends ScsiLun
 */

struct _esxVI_HostScsiDisk {
    esxVI_HostScsiDisk *_next;                             /* optional */
    esxVI_Type _type;                                      /* required */

    /* HostDevice */
    char *deviceName;                                      /* required */
    char *deviceType;                                      /* required */

    /* ScsiLun */
    char *key;                                             /* optional */
    char *uuid;                                            /* required */
    esxVI_ScsiLunDescriptor *descriptor;                   /* optional, list */
    char *canonicalName;                                   /* optional */
    char *displayName;                                     /* optional */
    char *lunType;                                         /* required */
    char *vendor;                                          /* optional */
    char *model;                                           /* optional */
    char *revision;                                        /* optional */
    esxVI_Int *scsiLevel;                                  /* optional */
    char *serialNumber;                                    /* optional */
    esxVI_ScsiLunDurableName *durableName;                 /* optional */
    esxVI_ScsiLunDurableName *alternateName;               /* optional, list */
    esxVI_Byte *standardInquiry;                           /* optional, list */
    esxVI_Int *queueDepth;                                 /* optional */
    esxVI_String *operationalState;                        /* required, list */
    esxVI_ScsiLunCapabilities *capabilities;               /* optional */

    /* HostScsiDisk */
    esxVI_HostDiskDimensionsLba *capacity;                 /* required */
    char *devicePath;                                      /* required */
};

int esxVI_HostScsiDisk_Alloc(esxVI_HostScsiDisk **item);
void esxVI_HostScsiDisk_Free(esxVI_HostScsiDisk **item);
int esxVI_HostScsiDisk_Validate(esxVI_HostScsiDisk *item);
esxVI_HostScsiDisk *esxVI_HostScsiDisk_DynamicCast(void *item);
int esxVI_HostScsiDisk_AppendToList(esxVI_HostScsiDisk **list, esxVI_HostScsiDisk *item);
int esxVI_HostScsiDisk_DeepCopy(esxVI_HostScsiDisk **dst, esxVI_HostScsiDisk *src);
int esxVI_HostScsiDisk_DeepCopyList(esxVI_HostScsiDisk **dstList, esxVI_HostScsiDisk *srcList);
int esxVI_HostScsiDisk_CastFromAnyType(esxVI_AnyType *anyType, esxVI_HostScsiDisk **item);
int esxVI_HostScsiDisk_CastListFromAnyType(esxVI_AnyType *anyType, esxVI_HostScsiDisk **list);
int esxVI_HostScsiDisk_Deserialize(xmlNodePtr node, esxVI_HostScsiDisk **item);
int esxVI_HostScsiDisk_DeserializeList(xmlNodePtr node, esxVI_HostScsiDisk **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostScsiDiskPartition
 */

struct _esxVI_HostScsiDiskPartition {
    esxVI_HostScsiDiskPartition *_next;                    /* optional */
    esxVI_Type _type;                                      /* required */

    char *diskName;                                        /* required */
    esxVI_Int *partition;                                  /* required */
};

int esxVI_HostScsiDiskPartition_Alloc(esxVI_HostScsiDiskPartition **item);
void esxVI_HostScsiDiskPartition_Free(esxVI_HostScsiDiskPartition **item);
int esxVI_HostScsiDiskPartition_Validate(esxVI_HostScsiDiskPartition *item);
int esxVI_HostScsiDiskPartition_AppendToList(esxVI_HostScsiDiskPartition **list, esxVI_HostScsiDiskPartition *item);
int esxVI_HostScsiDiskPartition_Deserialize(xmlNodePtr node, esxVI_HostScsiDiskPartition **item);
int esxVI_HostScsiDiskPartition_DeserializeList(xmlNodePtr node, esxVI_HostScsiDiskPartition **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostScsiTopologyInterface
 */

struct _esxVI_HostScsiTopologyInterface {
    esxVI_HostScsiTopologyInterface *_next;                /* optional */
    esxVI_Type _type;                                      /* required */

    char *key;                                             /* required */
    char *adapter;                                         /* required */
    esxVI_HostScsiTopologyTarget *target;                  /* optional, list */
};

int esxVI_HostScsiTopologyInterface_Alloc(esxVI_HostScsiTopologyInterface **item);
void esxVI_HostScsiTopologyInterface_Free(esxVI_HostScsiTopologyInterface **item);
int esxVI_HostScsiTopologyInterface_Validate(esxVI_HostScsiTopologyInterface *item);
int esxVI_HostScsiTopologyInterface_AppendToList(esxVI_HostScsiTopologyInterface **list, esxVI_HostScsiTopologyInterface *item);
int esxVI_HostScsiTopologyInterface_CastFromAnyType(esxVI_AnyType *anyType, esxVI_HostScsiTopologyInterface **item);
int esxVI_HostScsiTopologyInterface_CastListFromAnyType(esxVI_AnyType *anyType, esxVI_HostScsiTopologyInterface **list);
int esxVI_HostScsiTopologyInterface_Deserialize(xmlNodePtr node, esxVI_HostScsiTopologyInterface **item);
int esxVI_HostScsiTopologyInterface_DeserializeList(xmlNodePtr node, esxVI_HostScsiTopologyInterface **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostScsiTopologyLun
 */

struct _esxVI_HostScsiTopologyLun {
    esxVI_HostScsiTopologyLun *_next;                      /* optional */
    esxVI_Type _type;                                      /* required */

    char *key;                                             /* required */
    esxVI_Int *lun;                                        /* required */
    char *scsiLun;                                         /* required */
};

int esxVI_HostScsiTopologyLun_Alloc(esxVI_HostScsiTopologyLun **item);
void esxVI_HostScsiTopologyLun_Free(esxVI_HostScsiTopologyLun **item);
int esxVI_HostScsiTopologyLun_Validate(esxVI_HostScsiTopologyLun *item);
int esxVI_HostScsiTopologyLun_AppendToList(esxVI_HostScsiTopologyLun **list, esxVI_HostScsiTopologyLun *item);
int esxVI_HostScsiTopologyLun_DeepCopy(esxVI_HostScsiTopologyLun **dst, esxVI_HostScsiTopologyLun *src);
int esxVI_HostScsiTopologyLun_DeepCopyList(esxVI_HostScsiTopologyLun **dstList, esxVI_HostScsiTopologyLun *srcList);
int esxVI_HostScsiTopologyLun_CastFromAnyType(esxVI_AnyType *anyType, esxVI_HostScsiTopologyLun **item);
int esxVI_HostScsiTopologyLun_CastListFromAnyType(esxVI_AnyType *anyType, esxVI_HostScsiTopologyLun **list);
int esxVI_HostScsiTopologyLun_Deserialize(xmlNodePtr node, esxVI_HostScsiTopologyLun **item);
int esxVI_HostScsiTopologyLun_DeserializeList(xmlNodePtr node, esxVI_HostScsiTopologyLun **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostScsiTopologyTarget
 */

struct _esxVI_HostScsiTopologyTarget {
    esxVI_HostScsiTopologyTarget *_next;                   /* optional */
    esxVI_Type _type;                                      /* required */

    char *key;                                             /* required */
    esxVI_Int *target;                                     /* required */
    esxVI_HostScsiTopologyLun *lun;                        /* optional, list */
    esxVI_HostTargetTransport *transport;                  /* optional */
};

int esxVI_HostScsiTopologyTarget_Alloc(esxVI_HostScsiTopologyTarget **item);
void esxVI_HostScsiTopologyTarget_Free(esxVI_HostScsiTopologyTarget **item);
int esxVI_HostScsiTopologyTarget_Validate(esxVI_HostScsiTopologyTarget *item);
int esxVI_HostScsiTopologyTarget_AppendToList(esxVI_HostScsiTopologyTarget **list, esxVI_HostScsiTopologyTarget *item);
int esxVI_HostScsiTopologyTarget_CastFromAnyType(esxVI_AnyType *anyType, esxVI_HostScsiTopologyTarget **item);
int esxVI_HostScsiTopologyTarget_CastListFromAnyType(esxVI_AnyType *anyType, esxVI_HostScsiTopologyTarget **list);
int esxVI_HostScsiTopologyTarget_Deserialize(xmlNodePtr node, esxVI_HostScsiTopologyTarget **item);
int esxVI_HostScsiTopologyTarget_DeserializeList(xmlNodePtr node, esxVI_HostScsiTopologyTarget **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostTargetTransport
 *            extended by HostBlockAdapterTargetTransport
 *                        HostFibreChannelTargetTransport
 *                        HostInternetScsiTargetTransport
 *                        HostParallelScsiTargetTransport
 */

struct _esxVI_HostTargetTransport {
    esxVI_HostTargetTransport *_unused;                    /* optional */
    esxVI_Type _type;                                      /* required */

    /* no properties */
};

int esxVI_HostTargetTransport_Alloc(esxVI_HostTargetTransport **item);
void esxVI_HostTargetTransport_Free(esxVI_HostTargetTransport **item);
int esxVI_HostTargetTransport_Validate(esxVI_HostTargetTransport *item);
esxVI_HostTargetTransport *esxVI_HostTargetTransport_DynamicCast(void *item);
int esxVI_HostTargetTransport_Deserialize(xmlNodePtr node, esxVI_HostTargetTransport **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostVirtualSwitch
 */

struct _esxVI_HostVirtualSwitch {
    esxVI_HostVirtualSwitch *_next;                        /* optional */
    esxVI_Type _type;                                      /* required */

    char *name;                                            /* required */
    char *key;                                             /* required */
    esxVI_Int *numPorts;                                   /* required */
    esxVI_Int *numPortsAvailable;                          /* required */
    esxVI_Int *mtu;                                        /* optional */
    esxVI_String *portgroup;                               /* optional, list */
    esxVI_String *pnic;                                    /* optional, list */
    esxVI_HostVirtualSwitchSpec *spec;                     /* required */
};

int esxVI_HostVirtualSwitch_Alloc(esxVI_HostVirtualSwitch **item);
void esxVI_HostVirtualSwitch_Free(esxVI_HostVirtualSwitch **item);
int esxVI_HostVirtualSwitch_Validate(esxVI_HostVirtualSwitch *item);
int esxVI_HostVirtualSwitch_AppendToList(esxVI_HostVirtualSwitch **list, esxVI_HostVirtualSwitch *item);
int esxVI_HostVirtualSwitch_DeepCopy(esxVI_HostVirtualSwitch **dst, esxVI_HostVirtualSwitch *src);
int esxVI_HostVirtualSwitch_DeepCopyList(esxVI_HostVirtualSwitch **dstList, esxVI_HostVirtualSwitch *srcList);
int esxVI_HostVirtualSwitch_CastFromAnyType(esxVI_AnyType *anyType, esxVI_HostVirtualSwitch **item);
int esxVI_HostVirtualSwitch_CastListFromAnyType(esxVI_AnyType *anyType, esxVI_HostVirtualSwitch **list);
int esxVI_HostVirtualSwitch_Deserialize(xmlNodePtr node, esxVI_HostVirtualSwitch **item);
int esxVI_HostVirtualSwitch_DeserializeList(xmlNodePtr node, esxVI_HostVirtualSwitch **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostVirtualSwitchAutoBridge
 *            extends HostVirtualSwitchBridge
 */

struct _esxVI_HostVirtualSwitchAutoBridge {
    esxVI_HostVirtualSwitchAutoBridge *_unused;            /* optional */
    esxVI_Type _type;                                      /* required */

    /* HostVirtualSwitchBridge */
    /* no properties */

    /* HostVirtualSwitchAutoBridge */
    esxVI_String *excludedNicDevice;                       /* optional, list */
};

int esxVI_HostVirtualSwitchAutoBridge_Alloc(esxVI_HostVirtualSwitchAutoBridge **item);
void esxVI_HostVirtualSwitchAutoBridge_Free(esxVI_HostVirtualSwitchAutoBridge **item);
int esxVI_HostVirtualSwitchAutoBridge_Validate(esxVI_HostVirtualSwitchAutoBridge *item);
esxVI_HostVirtualSwitchAutoBridge *esxVI_HostVirtualSwitchAutoBridge_DynamicCast(void *item);
int esxVI_HostVirtualSwitchAutoBridge_DeepCopy(esxVI_HostVirtualSwitchAutoBridge **dst, esxVI_HostVirtualSwitchAutoBridge *src);
int esxVI_HostVirtualSwitchAutoBridge_Serialize(esxVI_HostVirtualSwitchAutoBridge *item, const char *element, virBufferPtr output);
int esxVI_HostVirtualSwitchAutoBridge_Deserialize(xmlNodePtr node, esxVI_HostVirtualSwitchAutoBridge **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostVirtualSwitchBeaconConfig
 */

struct _esxVI_HostVirtualSwitchBeaconConfig {
    esxVI_HostVirtualSwitchBeaconConfig *_unused;          /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_Int *interval;                                   /* required */
};

int esxVI_HostVirtualSwitchBeaconConfig_Alloc(esxVI_HostVirtualSwitchBeaconConfig **item);
void esxVI_HostVirtualSwitchBeaconConfig_Free(esxVI_HostVirtualSwitchBeaconConfig **item);
int esxVI_HostVirtualSwitchBeaconConfig_Validate(esxVI_HostVirtualSwitchBeaconConfig *item);
int esxVI_HostVirtualSwitchBeaconConfig_DeepCopy(esxVI_HostVirtualSwitchBeaconConfig **dst, esxVI_HostVirtualSwitchBeaconConfig *src);
int esxVI_HostVirtualSwitchBeaconConfig_Serialize(esxVI_HostVirtualSwitchBeaconConfig *item, const char *element, virBufferPtr output);
int esxVI_HostVirtualSwitchBeaconConfig_Deserialize(xmlNodePtr node, esxVI_HostVirtualSwitchBeaconConfig **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostVirtualSwitchBondBridge
 *            extends HostVirtualSwitchBridge
 */

struct _esxVI_HostVirtualSwitchBondBridge {
    esxVI_HostVirtualSwitchBondBridge *_unused;            /* optional */
    esxVI_Type _type;                                      /* required */

    /* HostVirtualSwitchBridge */
    /* no properties */

    /* HostVirtualSwitchBondBridge */
    esxVI_String *nicDevice;                               /* required, list */
    esxVI_HostVirtualSwitchBeaconConfig *beacon;           /* optional */
    /* FIXME: linkDiscoveryProtocolConfig is currently ignored */
};

int esxVI_HostVirtualSwitchBondBridge_Alloc(esxVI_HostVirtualSwitchBondBridge **item);
void esxVI_HostVirtualSwitchBondBridge_Free(esxVI_HostVirtualSwitchBondBridge **item);
int esxVI_HostVirtualSwitchBondBridge_Validate(esxVI_HostVirtualSwitchBondBridge *item);
esxVI_HostVirtualSwitchBondBridge *esxVI_HostVirtualSwitchBondBridge_DynamicCast(void *item);
int esxVI_HostVirtualSwitchBondBridge_DeepCopy(esxVI_HostVirtualSwitchBondBridge **dst, esxVI_HostVirtualSwitchBondBridge *src);
int esxVI_HostVirtualSwitchBondBridge_Serialize(esxVI_HostVirtualSwitchBondBridge *item, const char *element, virBufferPtr output);
int esxVI_HostVirtualSwitchBondBridge_Deserialize(xmlNodePtr node, esxVI_HostVirtualSwitchBondBridge **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostVirtualSwitchBridge
 *            extended by HostVirtualSwitchAutoBridge
 *                        HostVirtualSwitchBondBridge
 *                        HostVirtualSwitchSimpleBridge
 */

struct _esxVI_HostVirtualSwitchBridge {
    esxVI_HostVirtualSwitchBridge *_unused;                /* optional */
    esxVI_Type _type;                                      /* required */

    /* no properties */
};

int esxVI_HostVirtualSwitchBridge_Alloc(esxVI_HostVirtualSwitchBridge **item);
void esxVI_HostVirtualSwitchBridge_Free(esxVI_HostVirtualSwitchBridge **item);
int esxVI_HostVirtualSwitchBridge_Validate(esxVI_HostVirtualSwitchBridge *item);
esxVI_HostVirtualSwitchBridge *esxVI_HostVirtualSwitchBridge_DynamicCast(void *item);
int esxVI_HostVirtualSwitchBridge_DeepCopy(esxVI_HostVirtualSwitchBridge **dst, esxVI_HostVirtualSwitchBridge *src);
int esxVI_HostVirtualSwitchBridge_Serialize(esxVI_HostVirtualSwitchBridge *item, const char *element, virBufferPtr output);
int esxVI_HostVirtualSwitchBridge_Deserialize(xmlNodePtr node, esxVI_HostVirtualSwitchBridge **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostVirtualSwitchSimpleBridge
 *            extends HostVirtualSwitchBridge
 */

struct _esxVI_HostVirtualSwitchSimpleBridge {
    esxVI_HostVirtualSwitchSimpleBridge *_unused;          /* optional */
    esxVI_Type _type;                                      /* required */

    /* HostVirtualSwitchBridge */
    /* no properties */

    /* HostVirtualSwitchSimpleBridge */
    char *nicDevice;                                       /* required */
};

int esxVI_HostVirtualSwitchSimpleBridge_Alloc(esxVI_HostVirtualSwitchSimpleBridge **item);
void esxVI_HostVirtualSwitchSimpleBridge_Free(esxVI_HostVirtualSwitchSimpleBridge **item);
int esxVI_HostVirtualSwitchSimpleBridge_Validate(esxVI_HostVirtualSwitchSimpleBridge *item);
esxVI_HostVirtualSwitchSimpleBridge *esxVI_HostVirtualSwitchSimpleBridge_DynamicCast(void *item);
int esxVI_HostVirtualSwitchSimpleBridge_DeepCopy(esxVI_HostVirtualSwitchSimpleBridge **dst, esxVI_HostVirtualSwitchSimpleBridge *src);
int esxVI_HostVirtualSwitchSimpleBridge_Serialize(esxVI_HostVirtualSwitchSimpleBridge *item, const char *element, virBufferPtr output);
int esxVI_HostVirtualSwitchSimpleBridge_Deserialize(xmlNodePtr node, esxVI_HostVirtualSwitchSimpleBridge **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostVirtualSwitchSpec
 */

struct _esxVI_HostVirtualSwitchSpec {
    esxVI_HostVirtualSwitchSpec *_unused;                  /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_Int *numPorts;                                   /* required */
    esxVI_HostVirtualSwitchBridge *bridge;                 /* optional */
    esxVI_HostNetworkPolicy *policy;                       /* optional */
    esxVI_Int *mtu;                                        /* optional */
};

int esxVI_HostVirtualSwitchSpec_Alloc(esxVI_HostVirtualSwitchSpec **item);
void esxVI_HostVirtualSwitchSpec_Free(esxVI_HostVirtualSwitchSpec **item);
int esxVI_HostVirtualSwitchSpec_Validate(esxVI_HostVirtualSwitchSpec *item);
int esxVI_HostVirtualSwitchSpec_DeepCopy(esxVI_HostVirtualSwitchSpec **dst, esxVI_HostVirtualSwitchSpec *src);
int esxVI_HostVirtualSwitchSpec_Serialize(esxVI_HostVirtualSwitchSpec *item, const char *element, virBufferPtr output);
int esxVI_HostVirtualSwitchSpec_Deserialize(xmlNodePtr node, esxVI_HostVirtualSwitchSpec **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: HostVmfsVolume
 *            extends HostFileSystemVolume
 */

struct _esxVI_HostVmfsVolume {
    esxVI_HostVmfsVolume *_unused;                         /* optional */
    esxVI_Type _type;                                      /* required */

    /* HostFileSystemVolume */
    char *type;                                            /* required */
    char *name;                                            /* required */
    esxVI_Long *capacity;                                  /* required */

    /* HostVmfsVolume */
    esxVI_Int *blockSizeMb;                                /* required */
    esxVI_Int *maxBlocks;                                  /* required */
    esxVI_Int *majorVersion;                               /* required */
    char *version;                                         /* required */
    char *uuid;                                            /* required */
    esxVI_HostScsiDiskPartition *extent;                   /* required, list */
    esxVI_Boolean vmfsUpgradable;                          /* required */
    /* FIXME: forceMountedInfo is currently ignored */
};

int esxVI_HostVmfsVolume_Alloc(esxVI_HostVmfsVolume **item);
void esxVI_HostVmfsVolume_Free(esxVI_HostVmfsVolume **item);
int esxVI_HostVmfsVolume_Validate(esxVI_HostVmfsVolume *item);
int esxVI_HostVmfsVolume_Deserialize(xmlNodePtr node, esxVI_HostVmfsVolume **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: IsoImageFileInfo
 *            extends FileInfo
 */

struct _esxVI_IsoImageFileInfo {
    esxVI_IsoImageFileInfo *_next;                         /* optional */
    esxVI_Type _type;                                      /* required */

    /* FileInfo */
    char *path;                                            /* required */
    esxVI_Long *fileSize;                                  /* optional */
    esxVI_DateTime *modification;                          /* optional */
    char *owner;                                           /* optional */

    /* IsoImageFileInfo */
    /* no properties */
};

int esxVI_IsoImageFileInfo_Alloc(esxVI_IsoImageFileInfo **item);
void esxVI_IsoImageFileInfo_Free(esxVI_IsoImageFileInfo **item);
int esxVI_IsoImageFileInfo_Validate(esxVI_IsoImageFileInfo *item);
esxVI_IsoImageFileInfo *esxVI_IsoImageFileInfo_DynamicCast(void *item);
int esxVI_IsoImageFileInfo_AppendToList(esxVI_IsoImageFileInfo **list, esxVI_IsoImageFileInfo *item);
int esxVI_IsoImageFileInfo_Deserialize(xmlNodePtr node, esxVI_IsoImageFileInfo **item);
int esxVI_IsoImageFileInfo_DeserializeList(xmlNodePtr node, esxVI_IsoImageFileInfo **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: IsoImageFileQuery
 *            extends FileQuery
 */

struct _esxVI_IsoImageFileQuery {
    esxVI_IsoImageFileQuery *_next;                        /* optional */
    esxVI_Type _type;                                      /* required */

    /* FileQuery */
    /* no properties */

    /* IsoImageFileQuery */
    /* no properties */
};

int esxVI_IsoImageFileQuery_Alloc(esxVI_IsoImageFileQuery **item);
void esxVI_IsoImageFileQuery_Free(esxVI_IsoImageFileQuery **item);
int esxVI_IsoImageFileQuery_Validate(esxVI_IsoImageFileQuery *item);
esxVI_IsoImageFileQuery *esxVI_IsoImageFileQuery_DynamicCast(void *item);
int esxVI_IsoImageFileQuery_AppendToList(esxVI_IsoImageFileQuery **list, esxVI_IsoImageFileQuery *item);
int esxVI_IsoImageFileQuery_Serialize(esxVI_IsoImageFileQuery *item, const char *element, virBufferPtr output);
int esxVI_IsoImageFileQuery_SerializeList(esxVI_IsoImageFileQuery *list, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: KeyAnyValue
 */

struct _esxVI_KeyAnyValue {
    esxVI_KeyAnyValue *_next;                              /* optional */
    esxVI_Type _type;                                      /* required */

    char *key;                                             /* required */
    esxVI_AnyType *value;                                  /* required */
};

int esxVI_KeyAnyValue_Alloc(esxVI_KeyAnyValue **item);
void esxVI_KeyAnyValue_Free(esxVI_KeyAnyValue **item);
int esxVI_KeyAnyValue_Validate(esxVI_KeyAnyValue *item);
int esxVI_KeyAnyValue_AppendToList(esxVI_KeyAnyValue **list, esxVI_KeyAnyValue *item);
int esxVI_KeyAnyValue_Deserialize(xmlNodePtr node, esxVI_KeyAnyValue **item);
int esxVI_KeyAnyValue_DeserializeList(xmlNodePtr node, esxVI_KeyAnyValue **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: LocalDatastoreInfo
 *            extends DatastoreInfo
 */

struct _esxVI_LocalDatastoreInfo {
    esxVI_LocalDatastoreInfo *_unused;                     /* optional */
    esxVI_Type _type;                                      /* required */

    /* DatastoreInfo */
    char *name;                                            /* required */
    char *url;                                             /* required */
    esxVI_Long *freeSpace;                                 /* required */
    esxVI_Long *maxFileSize;                               /* required */
    esxVI_DateTime *timestamp;                             /* optional */

    /* LocalDatastoreInfo */
    char *path;                                            /* optional */
};

int esxVI_LocalDatastoreInfo_Alloc(esxVI_LocalDatastoreInfo **item);
void esxVI_LocalDatastoreInfo_Free(esxVI_LocalDatastoreInfo **item);
int esxVI_LocalDatastoreInfo_Validate(esxVI_LocalDatastoreInfo *item);
esxVI_LocalDatastoreInfo *esxVI_LocalDatastoreInfo_DynamicCast(void *item);
int esxVI_LocalDatastoreInfo_CastFromAnyType(esxVI_AnyType *anyType, esxVI_LocalDatastoreInfo **item);
int esxVI_LocalDatastoreInfo_Deserialize(xmlNodePtr node, esxVI_LocalDatastoreInfo **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: LocalizedMethodFault
 */

struct _esxVI_LocalizedMethodFault {
    esxVI_LocalizedMethodFault *_unused;                   /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_MethodFault *fault;                              /* required */
    char *localizedMessage;                                /* optional */
};

int esxVI_LocalizedMethodFault_Alloc(esxVI_LocalizedMethodFault **item);
void esxVI_LocalizedMethodFault_Free(esxVI_LocalizedMethodFault **item);
int esxVI_LocalizedMethodFault_Validate(esxVI_LocalizedMethodFault *item);
int esxVI_LocalizedMethodFault_Deserialize(xmlNodePtr node, esxVI_LocalizedMethodFault **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: NasDatastoreInfo
 *            extends DatastoreInfo
 */

struct _esxVI_NasDatastoreInfo {
    esxVI_NasDatastoreInfo *_unused;                       /* optional */
    esxVI_Type _type;                                      /* required */

    /* DatastoreInfo */
    char *name;                                            /* required */
    char *url;                                             /* required */
    esxVI_Long *freeSpace;                                 /* required */
    esxVI_Long *maxFileSize;                               /* required */
    esxVI_DateTime *timestamp;                             /* optional */

    /* NasDatastoreInfo */
    esxVI_HostNasVolume *nas;                              /* optional */
};

int esxVI_NasDatastoreInfo_Alloc(esxVI_NasDatastoreInfo **item);
void esxVI_NasDatastoreInfo_Free(esxVI_NasDatastoreInfo **item);
int esxVI_NasDatastoreInfo_Validate(esxVI_NasDatastoreInfo *item);
esxVI_NasDatastoreInfo *esxVI_NasDatastoreInfo_DynamicCast(void *item);
int esxVI_NasDatastoreInfo_CastFromAnyType(esxVI_AnyType *anyType, esxVI_NasDatastoreInfo **item);
int esxVI_NasDatastoreInfo_Deserialize(xmlNodePtr node, esxVI_NasDatastoreInfo **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: ObjectContent
 */

struct _esxVI_ObjectContent {
    esxVI_ObjectContent *_next;                            /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_ManagedObjectReference *obj;                     /* required */
    esxVI_DynamicProperty *propSet;                        /* optional, list */
    /* FIXME: missingSet is currently ignored */
};

int esxVI_ObjectContent_Alloc(esxVI_ObjectContent **item);
void esxVI_ObjectContent_Free(esxVI_ObjectContent **item);
int esxVI_ObjectContent_Validate(esxVI_ObjectContent *item);
int esxVI_ObjectContent_AppendToList(esxVI_ObjectContent **list, esxVI_ObjectContent *item);
int esxVI_ObjectContent_DeepCopy(esxVI_ObjectContent **dst, esxVI_ObjectContent *src);
int esxVI_ObjectContent_DeepCopyList(esxVI_ObjectContent **dstList, esxVI_ObjectContent *srcList);
int esxVI_ObjectContent_Deserialize(xmlNodePtr node, esxVI_ObjectContent **item);
int esxVI_ObjectContent_DeserializeList(xmlNodePtr node, esxVI_ObjectContent **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: ObjectSpec
 */

struct _esxVI_ObjectSpec {
    esxVI_ObjectSpec *_next;                               /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_ManagedObjectReference *obj;                     /* required */
    esxVI_Boolean skip;                                    /* optional */
    esxVI_SelectionSpec *selectSet;                        /* optional, list */
};

int esxVI_ObjectSpec_Alloc(esxVI_ObjectSpec **item);
void esxVI_ObjectSpec_Free(esxVI_ObjectSpec **item);
int esxVI_ObjectSpec_Validate(esxVI_ObjectSpec *item);
int esxVI_ObjectSpec_AppendToList(esxVI_ObjectSpec **list, esxVI_ObjectSpec *item);
int esxVI_ObjectSpec_Serialize(esxVI_ObjectSpec *item, const char *element, virBufferPtr output);
int esxVI_ObjectSpec_SerializeList(esxVI_ObjectSpec *list, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: ObjectUpdate
 */

struct _esxVI_ObjectUpdate {
    esxVI_ObjectUpdate *_next;                             /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_ObjectUpdateKind kind;                           /* required */
    esxVI_ManagedObjectReference *obj;                     /* required */
    esxVI_PropertyChange *changeSet;                       /* optional, list */
    /* FIXME: missingSet is currently ignored */
};

int esxVI_ObjectUpdate_Alloc(esxVI_ObjectUpdate **item);
void esxVI_ObjectUpdate_Free(esxVI_ObjectUpdate **item);
int esxVI_ObjectUpdate_Validate(esxVI_ObjectUpdate *item);
int esxVI_ObjectUpdate_AppendToList(esxVI_ObjectUpdate **list, esxVI_ObjectUpdate *item);
int esxVI_ObjectUpdate_Deserialize(xmlNodePtr node, esxVI_ObjectUpdate **item);
int esxVI_ObjectUpdate_DeserializeList(xmlNodePtr node, esxVI_ObjectUpdate **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: OptionType
 *            extended by ChoiceOption
 */

struct _esxVI_OptionType {
    esxVI_OptionType *_unused;                             /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_Boolean valueIsReadonly;                         /* optional */
};

int esxVI_OptionType_Alloc(esxVI_OptionType **item);
void esxVI_OptionType_Free(esxVI_OptionType **item);
int esxVI_OptionType_Validate(esxVI_OptionType *item);
int esxVI_OptionType_Deserialize(xmlNodePtr node, esxVI_OptionType **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: OptionValue
 *            extended by HostInternetScsiHbaParamValue
 */

struct _esxVI_OptionValue {
    esxVI_OptionValue *_next;                              /* optional */
    esxVI_Type _type;                                      /* required */

    char *key;                                             /* required */
    esxVI_AnyType *value;                                  /* optional */
};

int esxVI_OptionValue_Alloc(esxVI_OptionValue **item);
void esxVI_OptionValue_Free(esxVI_OptionValue **item);
int esxVI_OptionValue_Validate(esxVI_OptionValue *item);
esxVI_OptionValue *esxVI_OptionValue_DynamicCast(void *item);
int esxVI_OptionValue_AppendToList(esxVI_OptionValue **list, esxVI_OptionValue *item);
int esxVI_OptionValue_DeepCopy(esxVI_OptionValue **dst, esxVI_OptionValue *src);
int esxVI_OptionValue_DeepCopyList(esxVI_OptionValue **dstList, esxVI_OptionValue *srcList);
int esxVI_OptionValue_Deserialize(xmlNodePtr node, esxVI_OptionValue **item);
int esxVI_OptionValue_DeserializeList(xmlNodePtr node, esxVI_OptionValue **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: PerfCounterInfo
 */

struct _esxVI_PerfCounterInfo {
    esxVI_PerfCounterInfo *_next;                          /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_Int *key;                                        /* required */
    esxVI_ElementDescription *nameInfo;                    /* required */
    esxVI_ElementDescription *groupInfo;                   /* required */
    esxVI_ElementDescription *unitInfo;                    /* required */
    esxVI_PerfSummaryType rollupType;                      /* required */
    esxVI_PerfStatsType statsType;                         /* required */
    esxVI_Int *level;                                      /* optional */
    esxVI_Int *associatedCounterId;                        /* optional, list */
};

int esxVI_PerfCounterInfo_Alloc(esxVI_PerfCounterInfo **item);
void esxVI_PerfCounterInfo_Free(esxVI_PerfCounterInfo **item);
int esxVI_PerfCounterInfo_Validate(esxVI_PerfCounterInfo *item);
int esxVI_PerfCounterInfo_AppendToList(esxVI_PerfCounterInfo **list, esxVI_PerfCounterInfo *item);
int esxVI_PerfCounterInfo_Deserialize(xmlNodePtr node, esxVI_PerfCounterInfo **item);
int esxVI_PerfCounterInfo_DeserializeList(xmlNodePtr node, esxVI_PerfCounterInfo **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: PerfEntityMetric
 *            extends PerfEntityMetricBase
 */

struct _esxVI_PerfEntityMetric {
    esxVI_PerfEntityMetric *_next;                         /* optional */
    esxVI_Type _type;                                      /* required */

    /* PerfEntityMetricBase */
    esxVI_ManagedObjectReference *entity;                  /* required */

    /* PerfEntityMetric */
    esxVI_PerfSampleInfo *sampleInfo;                      /* optional, list */
    esxVI_PerfMetricSeries *value;                         /* optional, list */
};

int esxVI_PerfEntityMetric_Alloc(esxVI_PerfEntityMetric **item);
void esxVI_PerfEntityMetric_Free(esxVI_PerfEntityMetric **item);
int esxVI_PerfEntityMetric_Validate(esxVI_PerfEntityMetric *item);
esxVI_PerfEntityMetric *esxVI_PerfEntityMetric_DynamicCast(void *item);
int esxVI_PerfEntityMetric_AppendToList(esxVI_PerfEntityMetric **list, esxVI_PerfEntityMetric *item);
int esxVI_PerfEntityMetric_Deserialize(xmlNodePtr node, esxVI_PerfEntityMetric **item);
int esxVI_PerfEntityMetric_DeserializeList(xmlNodePtr node, esxVI_PerfEntityMetric **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: PerfEntityMetricBase
 *            extended by PerfEntityMetric
 */

struct _esxVI_PerfEntityMetricBase {
    esxVI_PerfEntityMetricBase *_next;                     /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_ManagedObjectReference *entity;                  /* required */
};

int esxVI_PerfEntityMetricBase_Alloc(esxVI_PerfEntityMetricBase **item);
void esxVI_PerfEntityMetricBase_Free(esxVI_PerfEntityMetricBase **item);
int esxVI_PerfEntityMetricBase_Validate(esxVI_PerfEntityMetricBase *item);
esxVI_PerfEntityMetricBase *esxVI_PerfEntityMetricBase_DynamicCast(void *item);
int esxVI_PerfEntityMetricBase_AppendToList(esxVI_PerfEntityMetricBase **list, esxVI_PerfEntityMetricBase *item);
int esxVI_PerfEntityMetricBase_Deserialize(xmlNodePtr node, esxVI_PerfEntityMetricBase **item);
int esxVI_PerfEntityMetricBase_DeserializeList(xmlNodePtr node, esxVI_PerfEntityMetricBase **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: PerfMetricId
 */

struct _esxVI_PerfMetricId {
    esxVI_PerfMetricId *_next;                             /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_Int *counterId;                                  /* required */
    char *instance;                                        /* required */
};

int esxVI_PerfMetricId_Alloc(esxVI_PerfMetricId **item);
void esxVI_PerfMetricId_Free(esxVI_PerfMetricId **item);
int esxVI_PerfMetricId_Validate(esxVI_PerfMetricId *item);
int esxVI_PerfMetricId_AppendToList(esxVI_PerfMetricId **list, esxVI_PerfMetricId *item);
int esxVI_PerfMetricId_Serialize(esxVI_PerfMetricId *item, const char *element, virBufferPtr output);
int esxVI_PerfMetricId_SerializeList(esxVI_PerfMetricId *list, const char *element, virBufferPtr output);
int esxVI_PerfMetricId_Deserialize(xmlNodePtr node, esxVI_PerfMetricId **item);
int esxVI_PerfMetricId_DeserializeList(xmlNodePtr node, esxVI_PerfMetricId **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: PerfMetricIntSeries
 *            extends PerfMetricSeries
 */

struct _esxVI_PerfMetricIntSeries {
    esxVI_PerfMetricIntSeries *_next;                      /* optional */
    esxVI_Type _type;                                      /* required */

    /* PerfMetricSeries */
    esxVI_PerfMetricId *id;                                /* required */

    /* PerfMetricIntSeries */
    esxVI_Long *value;                                     /* optional, list */
};

int esxVI_PerfMetricIntSeries_Alloc(esxVI_PerfMetricIntSeries **item);
void esxVI_PerfMetricIntSeries_Free(esxVI_PerfMetricIntSeries **item);
int esxVI_PerfMetricIntSeries_Validate(esxVI_PerfMetricIntSeries *item);
esxVI_PerfMetricIntSeries *esxVI_PerfMetricIntSeries_DynamicCast(void *item);
int esxVI_PerfMetricIntSeries_AppendToList(esxVI_PerfMetricIntSeries **list, esxVI_PerfMetricIntSeries *item);
int esxVI_PerfMetricIntSeries_Deserialize(xmlNodePtr node, esxVI_PerfMetricIntSeries **item);
int esxVI_PerfMetricIntSeries_DeserializeList(xmlNodePtr node, esxVI_PerfMetricIntSeries **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: PerfMetricSeries
 *            extended by PerfMetricIntSeries
 */

struct _esxVI_PerfMetricSeries {
    esxVI_PerfMetricSeries *_next;                         /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_PerfMetricId *id;                                /* required */
};

int esxVI_PerfMetricSeries_Alloc(esxVI_PerfMetricSeries **item);
void esxVI_PerfMetricSeries_Free(esxVI_PerfMetricSeries **item);
int esxVI_PerfMetricSeries_Validate(esxVI_PerfMetricSeries *item);
esxVI_PerfMetricSeries *esxVI_PerfMetricSeries_DynamicCast(void *item);
int esxVI_PerfMetricSeries_AppendToList(esxVI_PerfMetricSeries **list, esxVI_PerfMetricSeries *item);
int esxVI_PerfMetricSeries_Deserialize(xmlNodePtr node, esxVI_PerfMetricSeries **item);
int esxVI_PerfMetricSeries_DeserializeList(xmlNodePtr node, esxVI_PerfMetricSeries **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: PerfQuerySpec
 */

struct _esxVI_PerfQuerySpec {
    esxVI_PerfQuerySpec *_next;                            /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_ManagedObjectReference *entity;                  /* required */
    esxVI_DateTime *startTime;                             /* optional */
    esxVI_DateTime *endTime;                               /* optional */
    esxVI_Int *maxSample;                                  /* optional */
    esxVI_PerfMetricId *metricId;                          /* optional, list */
    esxVI_Int *intervalId;                                 /* optional */
    char *format;                                          /* optional */
};

int esxVI_PerfQuerySpec_Alloc(esxVI_PerfQuerySpec **item);
void esxVI_PerfQuerySpec_Free(esxVI_PerfQuerySpec **item);
int esxVI_PerfQuerySpec_Validate(esxVI_PerfQuerySpec *item);
int esxVI_PerfQuerySpec_AppendToList(esxVI_PerfQuerySpec **list, esxVI_PerfQuerySpec *item);
int esxVI_PerfQuerySpec_Serialize(esxVI_PerfQuerySpec *item, const char *element, virBufferPtr output);
int esxVI_PerfQuerySpec_SerializeList(esxVI_PerfQuerySpec *list, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: PerfSampleInfo
 */

struct _esxVI_PerfSampleInfo {
    esxVI_PerfSampleInfo *_next;                           /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_DateTime *timestamp;                             /* required */
    esxVI_Int *interval;                                   /* required */
};

int esxVI_PerfSampleInfo_Alloc(esxVI_PerfSampleInfo **item);
void esxVI_PerfSampleInfo_Free(esxVI_PerfSampleInfo **item);
int esxVI_PerfSampleInfo_Validate(esxVI_PerfSampleInfo *item);
int esxVI_PerfSampleInfo_AppendToList(esxVI_PerfSampleInfo **list, esxVI_PerfSampleInfo *item);
int esxVI_PerfSampleInfo_Deserialize(xmlNodePtr node, esxVI_PerfSampleInfo **item);
int esxVI_PerfSampleInfo_DeserializeList(xmlNodePtr node, esxVI_PerfSampleInfo **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: PhysicalNic
 */

struct _esxVI_PhysicalNic {
    esxVI_PhysicalNic *_next;                              /* optional */
    esxVI_Type _type;                                      /* required */

    char *key;                                             /* optional */
    char *device;                                          /* required */
    char *pci;                                             /* required */
    char *driver;                                          /* optional */
    esxVI_PhysicalNicLinkInfo *linkSpeed;                  /* optional */
    esxVI_PhysicalNicLinkInfo *validLinkSpecification;     /* optional, list */
    esxVI_PhysicalNicSpec *spec;                           /* required */
    esxVI_Boolean wakeOnLanSupported;                      /* required */
    char *mac;                                             /* required */
};

int esxVI_PhysicalNic_Alloc(esxVI_PhysicalNic **item);
void esxVI_PhysicalNic_Free(esxVI_PhysicalNic **item);
int esxVI_PhysicalNic_Validate(esxVI_PhysicalNic *item);
int esxVI_PhysicalNic_AppendToList(esxVI_PhysicalNic **list, esxVI_PhysicalNic *item);
int esxVI_PhysicalNic_DeepCopy(esxVI_PhysicalNic **dst, esxVI_PhysicalNic *src);
int esxVI_PhysicalNic_DeepCopyList(esxVI_PhysicalNic **dstList, esxVI_PhysicalNic *srcList);
int esxVI_PhysicalNic_CastFromAnyType(esxVI_AnyType *anyType, esxVI_PhysicalNic **item);
int esxVI_PhysicalNic_CastListFromAnyType(esxVI_AnyType *anyType, esxVI_PhysicalNic **list);
int esxVI_PhysicalNic_Deserialize(xmlNodePtr node, esxVI_PhysicalNic **item);
int esxVI_PhysicalNic_DeserializeList(xmlNodePtr node, esxVI_PhysicalNic **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: PhysicalNicLinkInfo
 */

struct _esxVI_PhysicalNicLinkInfo {
    esxVI_PhysicalNicLinkInfo *_next;                      /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_Int *speedMb;                                    /* required */
    esxVI_Boolean duplex;                                  /* required */
};

int esxVI_PhysicalNicLinkInfo_Alloc(esxVI_PhysicalNicLinkInfo **item);
void esxVI_PhysicalNicLinkInfo_Free(esxVI_PhysicalNicLinkInfo **item);
int esxVI_PhysicalNicLinkInfo_Validate(esxVI_PhysicalNicLinkInfo *item);
int esxVI_PhysicalNicLinkInfo_AppendToList(esxVI_PhysicalNicLinkInfo **list, esxVI_PhysicalNicLinkInfo *item);
int esxVI_PhysicalNicLinkInfo_DeepCopy(esxVI_PhysicalNicLinkInfo **dst, esxVI_PhysicalNicLinkInfo *src);
int esxVI_PhysicalNicLinkInfo_DeepCopyList(esxVI_PhysicalNicLinkInfo **dstList, esxVI_PhysicalNicLinkInfo *srcList);
int esxVI_PhysicalNicLinkInfo_Deserialize(xmlNodePtr node, esxVI_PhysicalNicLinkInfo **item);
int esxVI_PhysicalNicLinkInfo_DeserializeList(xmlNodePtr node, esxVI_PhysicalNicLinkInfo **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: PhysicalNicSpec
 */

struct _esxVI_PhysicalNicSpec {
    esxVI_PhysicalNicSpec *_unused;                        /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_HostIpConfig *ip;                                /* optional */
    esxVI_PhysicalNicLinkInfo *linkSpeed;                  /* optional */
};

int esxVI_PhysicalNicSpec_Alloc(esxVI_PhysicalNicSpec **item);
void esxVI_PhysicalNicSpec_Free(esxVI_PhysicalNicSpec **item);
int esxVI_PhysicalNicSpec_Validate(esxVI_PhysicalNicSpec *item);
int esxVI_PhysicalNicSpec_DeepCopy(esxVI_PhysicalNicSpec **dst, esxVI_PhysicalNicSpec *src);
int esxVI_PhysicalNicSpec_Deserialize(xmlNodePtr node, esxVI_PhysicalNicSpec **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: PropertyChange
 */

struct _esxVI_PropertyChange {
    esxVI_PropertyChange *_next;                           /* optional */
    esxVI_Type _type;                                      /* required */

    char *name;                                            /* required */
    esxVI_PropertyChangeOp op;                             /* required */
    esxVI_AnyType *val;                                    /* optional */
};

int esxVI_PropertyChange_Alloc(esxVI_PropertyChange **item);
void esxVI_PropertyChange_Free(esxVI_PropertyChange **item);
int esxVI_PropertyChange_Validate(esxVI_PropertyChange *item);
int esxVI_PropertyChange_AppendToList(esxVI_PropertyChange **list, esxVI_PropertyChange *item);
int esxVI_PropertyChange_Deserialize(xmlNodePtr node, esxVI_PropertyChange **item);
int esxVI_PropertyChange_DeserializeList(xmlNodePtr node, esxVI_PropertyChange **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: PropertyFilterSpec
 */

struct _esxVI_PropertyFilterSpec {
    esxVI_PropertyFilterSpec *_next;                       /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_PropertySpec *propSet;                           /* required, list */
    esxVI_ObjectSpec *objectSet;                           /* required, list */
};

int esxVI_PropertyFilterSpec_Alloc(esxVI_PropertyFilterSpec **item);
void esxVI_PropertyFilterSpec_Free(esxVI_PropertyFilterSpec **item);
int esxVI_PropertyFilterSpec_Validate(esxVI_PropertyFilterSpec *item);
int esxVI_PropertyFilterSpec_AppendToList(esxVI_PropertyFilterSpec **list, esxVI_PropertyFilterSpec *item);
int esxVI_PropertyFilterSpec_Serialize(esxVI_PropertyFilterSpec *item, const char *element, virBufferPtr output);
int esxVI_PropertyFilterSpec_SerializeList(esxVI_PropertyFilterSpec *list, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: PropertyFilterUpdate
 */

struct _esxVI_PropertyFilterUpdate {
    esxVI_PropertyFilterUpdate *_next;                     /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_ManagedObjectReference *filter;                  /* required */
    esxVI_ObjectUpdate *objectSet;                         /* optional, list */
    /* FIXME: missingSet is currently ignored */
};

int esxVI_PropertyFilterUpdate_Alloc(esxVI_PropertyFilterUpdate **item);
void esxVI_PropertyFilterUpdate_Free(esxVI_PropertyFilterUpdate **item);
int esxVI_PropertyFilterUpdate_Validate(esxVI_PropertyFilterUpdate *item);
int esxVI_PropertyFilterUpdate_AppendToList(esxVI_PropertyFilterUpdate **list, esxVI_PropertyFilterUpdate *item);
int esxVI_PropertyFilterUpdate_Deserialize(xmlNodePtr node, esxVI_PropertyFilterUpdate **item);
int esxVI_PropertyFilterUpdate_DeserializeList(xmlNodePtr node, esxVI_PropertyFilterUpdate **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: PropertySpec
 */

struct _esxVI_PropertySpec {
    esxVI_PropertySpec *_next;                             /* optional */
    esxVI_Type _type;                                      /* required */

    char *type;                                            /* required */
    esxVI_Boolean all;                                     /* optional */
    esxVI_String *pathSet;                                 /* optional, list */
};

int esxVI_PropertySpec_Alloc(esxVI_PropertySpec **item);
void esxVI_PropertySpec_Free(esxVI_PropertySpec **item);
int esxVI_PropertySpec_Validate(esxVI_PropertySpec *item);
int esxVI_PropertySpec_AppendToList(esxVI_PropertySpec **list, esxVI_PropertySpec *item);
int esxVI_PropertySpec_Serialize(esxVI_PropertySpec *item, const char *element, virBufferPtr output);
int esxVI_PropertySpec_SerializeList(esxVI_PropertySpec *list, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: ResourceAllocationInfo
 */

struct _esxVI_ResourceAllocationInfo {
    esxVI_ResourceAllocationInfo *_unused;                 /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_Long *reservation;                               /* optional */
    esxVI_Boolean expandableReservation;                   /* optional */
    esxVI_Long *limit;                                     /* optional */
    esxVI_SharesInfo *shares;                              /* optional */
    esxVI_Long *overheadLimit;                             /* optional */
};

int esxVI_ResourceAllocationInfo_Alloc(esxVI_ResourceAllocationInfo **item);
void esxVI_ResourceAllocationInfo_Free(esxVI_ResourceAllocationInfo **item);
int esxVI_ResourceAllocationInfo_Validate(esxVI_ResourceAllocationInfo *item);
int esxVI_ResourceAllocationInfo_Serialize(esxVI_ResourceAllocationInfo *item, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: ResourcePoolResourceUsage
 */

struct _esxVI_ResourcePoolResourceUsage {
    esxVI_ResourcePoolResourceUsage *_unused;              /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_Long *reservationUsed;                           /* required */
    esxVI_Long *reservationUsedForVm;                      /* required */
    esxVI_Long *unreservedForPool;                         /* required */
    esxVI_Long *unreservedForVm;                           /* required */
    esxVI_Long *overallUsage;                              /* required */
    esxVI_Long *maxUsage;                                  /* required */
};

int esxVI_ResourcePoolResourceUsage_Alloc(esxVI_ResourcePoolResourceUsage **item);
void esxVI_ResourcePoolResourceUsage_Free(esxVI_ResourcePoolResourceUsage **item);
int esxVI_ResourcePoolResourceUsage_Validate(esxVI_ResourcePoolResourceUsage *item);
int esxVI_ResourcePoolResourceUsage_CastFromAnyType(esxVI_AnyType *anyType, esxVI_ResourcePoolResourceUsage **item);
int esxVI_ResourcePoolResourceUsage_Deserialize(xmlNodePtr node, esxVI_ResourcePoolResourceUsage **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: ScsiLun
 *            extends HostDevice
 *            extended by HostScsiDisk
 */

struct _esxVI_ScsiLun {
    esxVI_ScsiLun *_next;                                  /* optional */
    esxVI_Type _type;                                      /* required */

    /* HostDevice */
    char *deviceName;                                      /* required */
    char *deviceType;                                      /* required */

    /* ScsiLun */
    char *key;                                             /* optional */
    char *uuid;                                            /* required */
    esxVI_ScsiLunDescriptor *descriptor;                   /* optional, list */
    char *canonicalName;                                   /* optional */
    char *displayName;                                     /* optional */
    char *lunType;                                         /* required */
    char *vendor;                                          /* optional */
    char *model;                                           /* optional */
    char *revision;                                        /* optional */
    esxVI_Int *scsiLevel;                                  /* optional */
    char *serialNumber;                                    /* optional */
    esxVI_ScsiLunDurableName *durableName;                 /* optional */
    esxVI_ScsiLunDurableName *alternateName;               /* optional, list */
    esxVI_Byte *standardInquiry;                           /* optional, list */
    esxVI_Int *queueDepth;                                 /* optional */
    esxVI_String *operationalState;                        /* required, list */
    esxVI_ScsiLunCapabilities *capabilities;               /* optional */
};

int esxVI_ScsiLun_Alloc(esxVI_ScsiLun **item);
void esxVI_ScsiLun_Free(esxVI_ScsiLun **item);
int esxVI_ScsiLun_Validate(esxVI_ScsiLun *item);
esxVI_ScsiLun *esxVI_ScsiLun_DynamicCast(void *item);
int esxVI_ScsiLun_AppendToList(esxVI_ScsiLun **list, esxVI_ScsiLun *item);
int esxVI_ScsiLun_DeepCopy(esxVI_ScsiLun **dst, esxVI_ScsiLun *src);
int esxVI_ScsiLun_DeepCopyList(esxVI_ScsiLun **dstList, esxVI_ScsiLun *srcList);
int esxVI_ScsiLun_CastFromAnyType(esxVI_AnyType *anyType, esxVI_ScsiLun **item);
int esxVI_ScsiLun_CastListFromAnyType(esxVI_AnyType *anyType, esxVI_ScsiLun **list);
int esxVI_ScsiLun_Deserialize(xmlNodePtr node, esxVI_ScsiLun **item);
int esxVI_ScsiLun_DeserializeList(xmlNodePtr node, esxVI_ScsiLun **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: ScsiLunCapabilities
 */

struct _esxVI_ScsiLunCapabilities {
    esxVI_ScsiLunCapabilities *_unused;                    /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_Boolean updateDisplayNameSupported;              /* required */
};

int esxVI_ScsiLunCapabilities_Alloc(esxVI_ScsiLunCapabilities **item);
void esxVI_ScsiLunCapabilities_Free(esxVI_ScsiLunCapabilities **item);
int esxVI_ScsiLunCapabilities_Validate(esxVI_ScsiLunCapabilities *item);
int esxVI_ScsiLunCapabilities_DeepCopy(esxVI_ScsiLunCapabilities **dst, esxVI_ScsiLunCapabilities *src);
int esxVI_ScsiLunCapabilities_Deserialize(xmlNodePtr node, esxVI_ScsiLunCapabilities **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: ScsiLunDescriptor
 */

struct _esxVI_ScsiLunDescriptor {
    esxVI_ScsiLunDescriptor *_next;                        /* optional */
    esxVI_Type _type;                                      /* required */

    char *quality;                                         /* required */
    char *id;                                              /* required */
};

int esxVI_ScsiLunDescriptor_Alloc(esxVI_ScsiLunDescriptor **item);
void esxVI_ScsiLunDescriptor_Free(esxVI_ScsiLunDescriptor **item);
int esxVI_ScsiLunDescriptor_Validate(esxVI_ScsiLunDescriptor *item);
int esxVI_ScsiLunDescriptor_AppendToList(esxVI_ScsiLunDescriptor **list, esxVI_ScsiLunDescriptor *item);
int esxVI_ScsiLunDescriptor_DeepCopy(esxVI_ScsiLunDescriptor **dst, esxVI_ScsiLunDescriptor *src);
int esxVI_ScsiLunDescriptor_DeepCopyList(esxVI_ScsiLunDescriptor **dstList, esxVI_ScsiLunDescriptor *srcList);
int esxVI_ScsiLunDescriptor_Deserialize(xmlNodePtr node, esxVI_ScsiLunDescriptor **item);
int esxVI_ScsiLunDescriptor_DeserializeList(xmlNodePtr node, esxVI_ScsiLunDescriptor **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: ScsiLunDurableName
 */

struct _esxVI_ScsiLunDurableName {
    esxVI_ScsiLunDurableName *_next;                       /* optional */
    esxVI_Type _type;                                      /* required */

    char *namespace;                                       /* required */
    esxVI_Byte *namespaceId;                               /* required */
    esxVI_Byte *data;                                      /* optional, list */
};

int esxVI_ScsiLunDurableName_Alloc(esxVI_ScsiLunDurableName **item);
void esxVI_ScsiLunDurableName_Free(esxVI_ScsiLunDurableName **item);
int esxVI_ScsiLunDurableName_Validate(esxVI_ScsiLunDurableName *item);
int esxVI_ScsiLunDurableName_AppendToList(esxVI_ScsiLunDurableName **list, esxVI_ScsiLunDurableName *item);
int esxVI_ScsiLunDurableName_DeepCopy(esxVI_ScsiLunDurableName **dst, esxVI_ScsiLunDurableName *src);
int esxVI_ScsiLunDurableName_DeepCopyList(esxVI_ScsiLunDurableName **dstList, esxVI_ScsiLunDurableName *srcList);
int esxVI_ScsiLunDurableName_Deserialize(xmlNodePtr node, esxVI_ScsiLunDurableName **item);
int esxVI_ScsiLunDurableName_DeserializeList(xmlNodePtr node, esxVI_ScsiLunDurableName **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: SelectionSpec
 *            extended by TraversalSpec
 */

struct _esxVI_SelectionSpec {
    esxVI_SelectionSpec *_next;                            /* optional */
    esxVI_Type _type;                                      /* required */

    char *name;                                            /* optional */
};

int esxVI_SelectionSpec_Alloc(esxVI_SelectionSpec **item);
void esxVI_SelectionSpec_Free(esxVI_SelectionSpec **item);
int esxVI_SelectionSpec_Validate(esxVI_SelectionSpec *item);
esxVI_SelectionSpec *esxVI_SelectionSpec_DynamicCast(void *item);
int esxVI_SelectionSpec_AppendToList(esxVI_SelectionSpec **list, esxVI_SelectionSpec *item);
int esxVI_SelectionSpec_Serialize(esxVI_SelectionSpec *item, const char *element, virBufferPtr output);
int esxVI_SelectionSpec_SerializeList(esxVI_SelectionSpec *list, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: ServiceContent
 */

struct _esxVI_ServiceContent {
    esxVI_ServiceContent *_unused;                         /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_ManagedObjectReference *rootFolder;              /* required */
    esxVI_ManagedObjectReference *propertyCollector;       /* required */
    esxVI_ManagedObjectReference *viewManager;             /* optional */
    esxVI_AboutInfo *about;                                /* required */
    esxVI_ManagedObjectReference *setting;                 /* optional */
    esxVI_ManagedObjectReference *userDirectory;           /* optional */
    esxVI_ManagedObjectReference *sessionManager;          /* optional */
    esxVI_ManagedObjectReference *authorizationManager;    /* optional */
    esxVI_ManagedObjectReference *perfManager;             /* optional */
    esxVI_ManagedObjectReference *scheduledTaskManager;    /* optional */
    esxVI_ManagedObjectReference *alarmManager;            /* optional */
    esxVI_ManagedObjectReference *eventManager;            /* optional */
    esxVI_ManagedObjectReference *taskManager;             /* optional */
    esxVI_ManagedObjectReference *extensionManager;        /* optional */
    esxVI_ManagedObjectReference *customizationSpecManager; /* optional */
    esxVI_ManagedObjectReference *customFieldsManager;     /* optional */
    esxVI_ManagedObjectReference *accountManager;          /* optional */
    esxVI_ManagedObjectReference *diagnosticManager;       /* optional */
    esxVI_ManagedObjectReference *licenseManager;          /* optional */
    esxVI_ManagedObjectReference *searchIndex;             /* optional */
    esxVI_ManagedObjectReference *fileManager;             /* optional */
    esxVI_ManagedObjectReference *virtualDiskManager;      /* optional */
    esxVI_ManagedObjectReference *virtualizationManager;   /* optional */
    esxVI_ManagedObjectReference *snmpSystem;              /* optional */
    esxVI_ManagedObjectReference *vmProvisioningChecker;   /* optional */
    esxVI_ManagedObjectReference *vmCompatibilityChecker;  /* optional */
    esxVI_ManagedObjectReference *ovfManager;              /* optional */
    esxVI_ManagedObjectReference *ipPoolManager;           /* optional */
    esxVI_ManagedObjectReference *dvSwitchManager;         /* optional */
    esxVI_ManagedObjectReference *hostProfileManager;      /* optional */
    esxVI_ManagedObjectReference *clusterProfileManager;   /* optional */
    esxVI_ManagedObjectReference *complianceManager;       /* optional */
    esxVI_ManagedObjectReference *localizationManager;     /* optional */
};

int esxVI_ServiceContent_Alloc(esxVI_ServiceContent **item);
void esxVI_ServiceContent_Free(esxVI_ServiceContent **item);
int esxVI_ServiceContent_Validate(esxVI_ServiceContent *item);
int esxVI_ServiceContent_Deserialize(xmlNodePtr node, esxVI_ServiceContent **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: SharesInfo
 */

struct _esxVI_SharesInfo {
    esxVI_SharesInfo *_unused;                             /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_Int *shares;                                     /* required */
    esxVI_SharesLevel level;                               /* required */
};

int esxVI_SharesInfo_Alloc(esxVI_SharesInfo **item);
void esxVI_SharesInfo_Free(esxVI_SharesInfo **item);
int esxVI_SharesInfo_Validate(esxVI_SharesInfo *item);
int esxVI_SharesInfo_CastFromAnyType(esxVI_AnyType *anyType, esxVI_SharesInfo **item);
int esxVI_SharesInfo_Serialize(esxVI_SharesInfo *item, const char *element, virBufferPtr output);
int esxVI_SharesInfo_Deserialize(xmlNodePtr node, esxVI_SharesInfo **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: TaskInfo
 */

struct _esxVI_TaskInfo {
    esxVI_TaskInfo *_next;                                 /* optional */
    esxVI_Type _type;                                      /* required */

    char *key;                                             /* required */
    esxVI_ManagedObjectReference *task;                    /* required */
    /* FIXME: description is currently ignored */
    char *name;                                            /* optional */
    char *descriptionId;                                   /* required */
    esxVI_ManagedObjectReference *entity;                  /* optional */
    char *entityName;                                      /* optional */
    esxVI_ManagedObjectReference *locked;                  /* optional, list */
    esxVI_TaskInfoState state;                             /* required */
    esxVI_Boolean cancelled;                               /* required */
    esxVI_Boolean cancelable;                              /* required */
    esxVI_LocalizedMethodFault *error;                     /* optional */
    esxVI_AnyType *result;                                 /* optional */
    esxVI_Int *progress;                                   /* optional */
    /* FIXME: reason is currently ignored */
    esxVI_DateTime *queueTime;                             /* required */
    esxVI_DateTime *startTime;                             /* optional */
    esxVI_DateTime *completeTime;                          /* optional */
    esxVI_Int *eventChainId;                               /* required */
    char *changeTag;                                       /* optional */
    char *parentTaskKey;                                   /* optional */
    char *rootTaskKey;                                     /* optional */
};

int esxVI_TaskInfo_Alloc(esxVI_TaskInfo **item);
void esxVI_TaskInfo_Free(esxVI_TaskInfo **item);
int esxVI_TaskInfo_Validate(esxVI_TaskInfo *item);
int esxVI_TaskInfo_AppendToList(esxVI_TaskInfo **list, esxVI_TaskInfo *item);
int esxVI_TaskInfo_CastFromAnyType(esxVI_AnyType *anyType, esxVI_TaskInfo **item);
int esxVI_TaskInfo_CastListFromAnyType(esxVI_AnyType *anyType, esxVI_TaskInfo **list);
int esxVI_TaskInfo_Deserialize(xmlNodePtr node, esxVI_TaskInfo **item);
int esxVI_TaskInfo_DeserializeList(xmlNodePtr node, esxVI_TaskInfo **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: TemplateConfigFileInfo
 *            extends VmConfigFileInfo
 */

struct _esxVI_TemplateConfigFileInfo {
    esxVI_TemplateConfigFileInfo *_next;                   /* optional */
    esxVI_Type _type;                                      /* required */

    /* FileInfo */
    char *path;                                            /* required */
    esxVI_Long *fileSize;                                  /* optional */
    esxVI_DateTime *modification;                          /* optional */
    char *owner;                                           /* optional */

    /* VmConfigFileInfo */
    esxVI_Int *configVersion;                              /* optional */

    /* TemplateConfigFileInfo */
    /* no properties */
};

int esxVI_TemplateConfigFileInfo_Alloc(esxVI_TemplateConfigFileInfo **item);
void esxVI_TemplateConfigFileInfo_Free(esxVI_TemplateConfigFileInfo **item);
int esxVI_TemplateConfigFileInfo_Validate(esxVI_TemplateConfigFileInfo *item);
esxVI_TemplateConfigFileInfo *esxVI_TemplateConfigFileInfo_DynamicCast(void *item);
int esxVI_TemplateConfigFileInfo_AppendToList(esxVI_TemplateConfigFileInfo **list, esxVI_TemplateConfigFileInfo *item);
int esxVI_TemplateConfigFileInfo_Deserialize(xmlNodePtr node, esxVI_TemplateConfigFileInfo **item);
int esxVI_TemplateConfigFileInfo_DeserializeList(xmlNodePtr node, esxVI_TemplateConfigFileInfo **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: TemplateConfigFileQuery
 *            extends VmConfigFileQuery
 */

struct _esxVI_TemplateConfigFileQuery {
    esxVI_TemplateConfigFileQuery *_next;                  /* optional */
    esxVI_Type _type;                                      /* required */

    /* FileQuery */
    /* no properties */

    /* VmConfigFileQuery */
    esxVI_VmConfigFileQueryFilter *filter;                 /* optional */
    esxVI_VmConfigFileQueryFlags *details;                 /* optional */

    /* TemplateConfigFileQuery */
    /* no properties */
};

int esxVI_TemplateConfigFileQuery_Alloc(esxVI_TemplateConfigFileQuery **item);
void esxVI_TemplateConfigFileQuery_Free(esxVI_TemplateConfigFileQuery **item);
int esxVI_TemplateConfigFileQuery_Validate(esxVI_TemplateConfigFileQuery *item);
esxVI_TemplateConfigFileQuery *esxVI_TemplateConfigFileQuery_DynamicCast(void *item);
int esxVI_TemplateConfigFileQuery_AppendToList(esxVI_TemplateConfigFileQuery **list, esxVI_TemplateConfigFileQuery *item);
int esxVI_TemplateConfigFileQuery_Serialize(esxVI_TemplateConfigFileQuery *item, const char *element, virBufferPtr output);
int esxVI_TemplateConfigFileQuery_SerializeList(esxVI_TemplateConfigFileQuery *list, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: TraversalSpec
 *            extends SelectionSpec
 */

struct _esxVI_TraversalSpec {
    esxVI_TraversalSpec *_next;                            /* optional */
    esxVI_Type _type;                                      /* required */

    /* SelectionSpec */
    char *name;                                            /* optional */

    /* TraversalSpec */
    char *type;                                            /* required */
    char *path;                                            /* required */
    esxVI_Boolean skip;                                    /* optional */
    esxVI_SelectionSpec *selectSet;                        /* optional, list */
};

int esxVI_TraversalSpec_Alloc(esxVI_TraversalSpec **item);
void esxVI_TraversalSpec_Free(esxVI_TraversalSpec **item);
int esxVI_TraversalSpec_Validate(esxVI_TraversalSpec *item);
esxVI_TraversalSpec *esxVI_TraversalSpec_DynamicCast(void *item);
int esxVI_TraversalSpec_AppendToList(esxVI_TraversalSpec **list, esxVI_TraversalSpec *item);
int esxVI_TraversalSpec_Serialize(esxVI_TraversalSpec *item, const char *element, virBufferPtr output);
int esxVI_TraversalSpec_SerializeList(esxVI_TraversalSpec *list, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: UpdateSet
 */

struct _esxVI_UpdateSet {
    esxVI_UpdateSet *_unused;                              /* optional */
    esxVI_Type _type;                                      /* required */

    char *version;                                         /* required */
    esxVI_PropertyFilterUpdate *filterSet;                 /* optional, list */
};

int esxVI_UpdateSet_Alloc(esxVI_UpdateSet **item);
void esxVI_UpdateSet_Free(esxVI_UpdateSet **item);
int esxVI_UpdateSet_Validate(esxVI_UpdateSet *item);
int esxVI_UpdateSet_Deserialize(xmlNodePtr node, esxVI_UpdateSet **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: UserSession
 */

struct _esxVI_UserSession {
    esxVI_UserSession *_unused;                            /* optional */
    esxVI_Type _type;                                      /* required */

    char *key;                                             /* required */
    char *userName;                                        /* required */
    char *fullName;                                        /* required */
    esxVI_DateTime *loginTime;                             /* required */
    esxVI_DateTime *lastActiveTime;                        /* required */
    char *locale;                                          /* required */
    char *messageLocale;                                   /* required */
};

int esxVI_UserSession_Alloc(esxVI_UserSession **item);
void esxVI_UserSession_Free(esxVI_UserSession **item);
int esxVI_UserSession_Validate(esxVI_UserSession *item);
int esxVI_UserSession_CastFromAnyType(esxVI_AnyType *anyType, esxVI_UserSession **item);
int esxVI_UserSession_Deserialize(xmlNodePtr node, esxVI_UserSession **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: VirtualDiskSpec
 *            extended by DeviceBackedVirtualDiskSpec
 *                        FileBackedVirtualDiskSpec
 */

struct _esxVI_VirtualDiskSpec {
    esxVI_VirtualDiskSpec *_unused;                        /* optional */
    esxVI_Type _type;                                      /* required */

    char *diskType;                                        /* required */
    char *adapterType;                                     /* required */
};

int esxVI_VirtualDiskSpec_Alloc(esxVI_VirtualDiskSpec **item);
void esxVI_VirtualDiskSpec_Free(esxVI_VirtualDiskSpec **item);
int esxVI_VirtualDiskSpec_Validate(esxVI_VirtualDiskSpec *item);
esxVI_VirtualDiskSpec *esxVI_VirtualDiskSpec_DynamicCast(void *item);
int esxVI_VirtualDiskSpec_Serialize(esxVI_VirtualDiskSpec *item, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: VirtualMachineConfigSpec
 */

struct _esxVI_VirtualMachineConfigSpec {
    esxVI_VirtualMachineConfigSpec *_unused;               /* optional */
    esxVI_Type _type;                                      /* required */

    char *changeVersion;                                   /* optional */
    char *name;                                            /* optional */
    char *version;                                         /* optional */
    char *uuid;                                            /* optional */
    char *instanceUuid;                                    /* optional */
    esxVI_Long *npivNodeWorldWideName;                     /* optional, list */
    esxVI_Long *npivPortWorldWideName;                     /* optional, list */
    char *npivWorldWideNameType;                           /* optional */
    /* FIXME: npivDesiredNodeWwns is currently ignored */
    /* FIXME: npivDesiredPortWwns is currently ignored */
    esxVI_Boolean npivTemporaryDisabled;                   /* optional */
    esxVI_Boolean npivOnNonRdmDisks;                       /* optional */
    char *npivWorldWideNameOp;                             /* optional */
    char *locationId;                                      /* optional */
    char *guestId;                                         /* optional */
    char *alternateGuestName;                              /* optional */
    char *annotation;                                      /* optional */
    /* FIXME: files is currently ignored */
    /* FIXME: tools is currently ignored */
    /* FIXME: flags is currently ignored */
    /* FIXME: consolePreferences is currently ignored */
    /* FIXME: powerOpInfo is currently ignored */
    esxVI_Int *numCPUs;                                    /* optional */
    esxVI_Long *memoryMB;                                  /* optional */
    esxVI_Boolean memoryHotAddEnabled;                     /* optional */
    esxVI_Boolean cpuHotAddEnabled;                        /* optional */
    esxVI_Boolean cpuHotRemoveEnabled;                     /* optional */
    /* FIXME: deviceChange is currently ignored */
    esxVI_ResourceAllocationInfo *cpuAllocation;           /* optional */
    esxVI_ResourceAllocationInfo *memoryAllocation;        /* optional */
    /* FIXME: cpuAffinity is currently ignored */
    /* FIXME: memoryAffinity is currently ignored */
    /* FIXME: networkShaper is currently ignored */
    /* FIXME: cpuFeatureMask is currently ignored */
    /* FIXME: extraConfig is currently ignored */
    char *swapPlacement;                                   /* optional */
    /* FIXME: bootOptions is currently ignored */
    /* FIXME: vAppConfig is currently ignored */
    /* FIXME: ftInfo is currently ignored */
    esxVI_Boolean vAppConfigRemoved;                       /* optional */
    esxVI_Boolean vAssertsEnabled;                         /* optional */
    esxVI_Boolean changeTrackingEnabled;                   /* optional */
};

int esxVI_VirtualMachineConfigSpec_Alloc(esxVI_VirtualMachineConfigSpec **item);
void esxVI_VirtualMachineConfigSpec_Free(esxVI_VirtualMachineConfigSpec **item);
int esxVI_VirtualMachineConfigSpec_Validate(esxVI_VirtualMachineConfigSpec *item);
int esxVI_VirtualMachineConfigSpec_Serialize(esxVI_VirtualMachineConfigSpec *item, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: VirtualMachineQuestionInfo
 */

struct _esxVI_VirtualMachineQuestionInfo {
    esxVI_VirtualMachineQuestionInfo *_unused;             /* optional */
    esxVI_Type _type;                                      /* required */

    char *id;                                              /* required */
    char *text;                                            /* required */
    esxVI_ChoiceOption *choice;                            /* required */
    /* FIXME: message is currently ignored */
};

int esxVI_VirtualMachineQuestionInfo_Alloc(esxVI_VirtualMachineQuestionInfo **item);
void esxVI_VirtualMachineQuestionInfo_Free(esxVI_VirtualMachineQuestionInfo **item);
int esxVI_VirtualMachineQuestionInfo_Validate(esxVI_VirtualMachineQuestionInfo *item);
int esxVI_VirtualMachineQuestionInfo_CastFromAnyType(esxVI_AnyType *anyType, esxVI_VirtualMachineQuestionInfo **item);
int esxVI_VirtualMachineQuestionInfo_Deserialize(xmlNodePtr node, esxVI_VirtualMachineQuestionInfo **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: VirtualMachineSnapshotTree
 */

struct _esxVI_VirtualMachineSnapshotTree {
    esxVI_VirtualMachineSnapshotTree *_next;               /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_ManagedObjectReference *snapshot;                /* required */
    esxVI_ManagedObjectReference *vm;                      /* required */
    char *name;                                            /* required */
    char *description;                                     /* required */
    esxVI_Int *id;                                         /* optional */
    esxVI_DateTime *createTime;                            /* required */
    esxVI_VirtualMachinePowerState state;                  /* required */
    esxVI_Boolean quiesced;                                /* required */
    char *backupManifest;                                  /* optional */
    esxVI_VirtualMachineSnapshotTree *childSnapshotList;   /* optional, list */
    esxVI_Boolean replaySupported;                         /* optional */
};

int esxVI_VirtualMachineSnapshotTree_Alloc(esxVI_VirtualMachineSnapshotTree **item);
void esxVI_VirtualMachineSnapshotTree_Free(esxVI_VirtualMachineSnapshotTree **item);
int esxVI_VirtualMachineSnapshotTree_Validate(esxVI_VirtualMachineSnapshotTree *item);
int esxVI_VirtualMachineSnapshotTree_AppendToList(esxVI_VirtualMachineSnapshotTree **list, esxVI_VirtualMachineSnapshotTree *item);
int esxVI_VirtualMachineSnapshotTree_DeepCopy(esxVI_VirtualMachineSnapshotTree **dst, esxVI_VirtualMachineSnapshotTree *src);
int esxVI_VirtualMachineSnapshotTree_DeepCopyList(esxVI_VirtualMachineSnapshotTree **dstList, esxVI_VirtualMachineSnapshotTree *srcList);
int esxVI_VirtualMachineSnapshotTree_CastFromAnyType(esxVI_AnyType *anyType, esxVI_VirtualMachineSnapshotTree **item);
int esxVI_VirtualMachineSnapshotTree_CastListFromAnyType(esxVI_AnyType *anyType, esxVI_VirtualMachineSnapshotTree **list);
int esxVI_VirtualMachineSnapshotTree_Deserialize(xmlNodePtr node, esxVI_VirtualMachineSnapshotTree **item);
int esxVI_VirtualMachineSnapshotTree_DeserializeList(xmlNodePtr node, esxVI_VirtualMachineSnapshotTree **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: VmConfigFileInfo
 *            extends FileInfo
 *            extended by TemplateConfigFileInfo
 */

struct _esxVI_VmConfigFileInfo {
    esxVI_VmConfigFileInfo *_next;                         /* optional */
    esxVI_Type _type;                                      /* required */

    /* FileInfo */
    char *path;                                            /* required */
    esxVI_Long *fileSize;                                  /* optional */
    esxVI_DateTime *modification;                          /* optional */
    char *owner;                                           /* optional */

    /* VmConfigFileInfo */
    esxVI_Int *configVersion;                              /* optional */
};

int esxVI_VmConfigFileInfo_Alloc(esxVI_VmConfigFileInfo **item);
void esxVI_VmConfigFileInfo_Free(esxVI_VmConfigFileInfo **item);
int esxVI_VmConfigFileInfo_Validate(esxVI_VmConfigFileInfo *item);
esxVI_VmConfigFileInfo *esxVI_VmConfigFileInfo_DynamicCast(void *item);
int esxVI_VmConfigFileInfo_AppendToList(esxVI_VmConfigFileInfo **list, esxVI_VmConfigFileInfo *item);
int esxVI_VmConfigFileInfo_Deserialize(xmlNodePtr node, esxVI_VmConfigFileInfo **item);
int esxVI_VmConfigFileInfo_DeserializeList(xmlNodePtr node, esxVI_VmConfigFileInfo **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: VmConfigFileQuery
 *            extends FileQuery
 *            extended by TemplateConfigFileQuery
 */

struct _esxVI_VmConfigFileQuery {
    esxVI_VmConfigFileQuery *_next;                        /* optional */
    esxVI_Type _type;                                      /* required */

    /* FileQuery */
    /* no properties */

    /* VmConfigFileQuery */
    esxVI_VmConfigFileQueryFilter *filter;                 /* optional */
    esxVI_VmConfigFileQueryFlags *details;                 /* optional */
};

int esxVI_VmConfigFileQuery_Alloc(esxVI_VmConfigFileQuery **item);
void esxVI_VmConfigFileQuery_Free(esxVI_VmConfigFileQuery **item);
int esxVI_VmConfigFileQuery_Validate(esxVI_VmConfigFileQuery *item);
esxVI_VmConfigFileQuery *esxVI_VmConfigFileQuery_DynamicCast(void *item);
int esxVI_VmConfigFileQuery_AppendToList(esxVI_VmConfigFileQuery **list, esxVI_VmConfigFileQuery *item);
int esxVI_VmConfigFileQuery_Serialize(esxVI_VmConfigFileQuery *item, const char *element, virBufferPtr output);
int esxVI_VmConfigFileQuery_SerializeList(esxVI_VmConfigFileQuery *list, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: VmConfigFileQueryFilter
 */

struct _esxVI_VmConfigFileQueryFilter {
    esxVI_VmConfigFileQueryFilter *_unused;                /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_Int *matchConfigVersion;                         /* optional, list */
};

int esxVI_VmConfigFileQueryFilter_Alloc(esxVI_VmConfigFileQueryFilter **item);
void esxVI_VmConfigFileQueryFilter_Free(esxVI_VmConfigFileQueryFilter **item);
int esxVI_VmConfigFileQueryFilter_Validate(esxVI_VmConfigFileQueryFilter *item);
int esxVI_VmConfigFileQueryFilter_Serialize(esxVI_VmConfigFileQueryFilter *item, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: VmConfigFileQueryFlags
 */

struct _esxVI_VmConfigFileQueryFlags {
    esxVI_VmConfigFileQueryFlags *_unused;                 /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_Boolean configVersion;                           /* required */
};

int esxVI_VmConfigFileQueryFlags_Alloc(esxVI_VmConfigFileQueryFlags **item);
void esxVI_VmConfigFileQueryFlags_Free(esxVI_VmConfigFileQueryFlags **item);
int esxVI_VmConfigFileQueryFlags_Validate(esxVI_VmConfigFileQueryFlags *item);
int esxVI_VmConfigFileQueryFlags_Serialize(esxVI_VmConfigFileQueryFlags *item, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: VmDiskFileInfo
 *            extends FileInfo
 */

struct _esxVI_VmDiskFileInfo {
    esxVI_VmDiskFileInfo *_next;                           /* optional */
    esxVI_Type _type;                                      /* required */

    /* FileInfo */
    char *path;                                            /* required */
    esxVI_Long *fileSize;                                  /* optional */
    esxVI_DateTime *modification;                          /* optional */
    char *owner;                                           /* optional */

    /* VmDiskFileInfo */
    char *diskType;                                        /* optional */
    esxVI_Long *capacityKb;                                /* optional */
    esxVI_Int *hardwareVersion;                            /* optional */
    char *controllerType;                                  /* optional */
    esxVI_String *diskExtents;                             /* optional, list */
    esxVI_Boolean thin;                                    /* optional */
};

int esxVI_VmDiskFileInfo_Alloc(esxVI_VmDiskFileInfo **item);
void esxVI_VmDiskFileInfo_Free(esxVI_VmDiskFileInfo **item);
int esxVI_VmDiskFileInfo_Validate(esxVI_VmDiskFileInfo *item);
esxVI_VmDiskFileInfo *esxVI_VmDiskFileInfo_DynamicCast(void *item);
int esxVI_VmDiskFileInfo_AppendToList(esxVI_VmDiskFileInfo **list, esxVI_VmDiskFileInfo *item);
int esxVI_VmDiskFileInfo_Deserialize(xmlNodePtr node, esxVI_VmDiskFileInfo **item);
int esxVI_VmDiskFileInfo_DeserializeList(xmlNodePtr node, esxVI_VmDiskFileInfo **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: VmDiskFileQuery
 *            extends FileQuery
 */

struct _esxVI_VmDiskFileQuery {
    esxVI_VmDiskFileQuery *_next;                          /* optional */
    esxVI_Type _type;                                      /* required */

    /* FileQuery */
    /* no properties */

    /* VmDiskFileQuery */
    esxVI_VmDiskFileQueryFilter *filter;                   /* optional */
    esxVI_VmDiskFileQueryFlags *details;                   /* optional */
};

int esxVI_VmDiskFileQuery_Alloc(esxVI_VmDiskFileQuery **item);
void esxVI_VmDiskFileQuery_Free(esxVI_VmDiskFileQuery **item);
int esxVI_VmDiskFileQuery_Validate(esxVI_VmDiskFileQuery *item);
esxVI_VmDiskFileQuery *esxVI_VmDiskFileQuery_DynamicCast(void *item);
int esxVI_VmDiskFileQuery_AppendToList(esxVI_VmDiskFileQuery **list, esxVI_VmDiskFileQuery *item);
int esxVI_VmDiskFileQuery_Serialize(esxVI_VmDiskFileQuery *item, const char *element, virBufferPtr output);
int esxVI_VmDiskFileQuery_SerializeList(esxVI_VmDiskFileQuery *list, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: VmDiskFileQueryFilter
 */

struct _esxVI_VmDiskFileQueryFilter {
    esxVI_VmDiskFileQueryFilter *_unused;                  /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_String *diskType;                                /* optional, list */
    esxVI_Int *matchHardwareVersion;                       /* optional, list */
    esxVI_String *controllerType;                          /* optional, list */
    esxVI_Boolean thin;                                    /* optional */
};

int esxVI_VmDiskFileQueryFilter_Alloc(esxVI_VmDiskFileQueryFilter **item);
void esxVI_VmDiskFileQueryFilter_Free(esxVI_VmDiskFileQueryFilter **item);
int esxVI_VmDiskFileQueryFilter_Validate(esxVI_VmDiskFileQueryFilter *item);
int esxVI_VmDiskFileQueryFilter_Serialize(esxVI_VmDiskFileQueryFilter *item, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: VmDiskFileQueryFlags
 */

struct _esxVI_VmDiskFileQueryFlags {
    esxVI_VmDiskFileQueryFlags *_unused;                   /* optional */
    esxVI_Type _type;                                      /* required */

    esxVI_Boolean diskType;                                /* required */
    esxVI_Boolean capacityKb;                              /* required */
    esxVI_Boolean hardwareVersion;                         /* required */
    esxVI_Boolean controllerType;                          /* optional */
    esxVI_Boolean diskExtents;                             /* optional */
    esxVI_Boolean thin;                                    /* optional */
};

int esxVI_VmDiskFileQueryFlags_Alloc(esxVI_VmDiskFileQueryFlags **item);
void esxVI_VmDiskFileQueryFlags_Free(esxVI_VmDiskFileQueryFlags **item);
int esxVI_VmDiskFileQueryFlags_Validate(esxVI_VmDiskFileQueryFlags *item);
int esxVI_VmDiskFileQueryFlags_Serialize(esxVI_VmDiskFileQueryFlags *item, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: VmEventArgument
 *            extends EntityEventArgument
 */

struct _esxVI_VmEventArgument {
    esxVI_VmEventArgument *_unused;                        /* optional */
    esxVI_Type _type;                                      /* required */

    /* EventArgument */
    /* no properties */

    /* EntityEventArgument */
    char *name;                                            /* required */

    /* VmEventArgument */
    esxVI_ManagedObjectReference *vm;                      /* required */
};

int esxVI_VmEventArgument_Alloc(esxVI_VmEventArgument **item);
void esxVI_VmEventArgument_Free(esxVI_VmEventArgument **item);
int esxVI_VmEventArgument_Validate(esxVI_VmEventArgument *item);
int esxVI_VmEventArgument_Deserialize(xmlNodePtr node, esxVI_VmEventArgument **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: VmLogFileInfo
 *            extends FileInfo
 */

struct _esxVI_VmLogFileInfo {
    esxVI_VmLogFileInfo *_next;                            /* optional */
    esxVI_Type _type;                                      /* required */

    /* FileInfo */
    char *path;                                            /* required */
    esxVI_Long *fileSize;                                  /* optional */
    esxVI_DateTime *modification;                          /* optional */
    char *owner;                                           /* optional */

    /* VmLogFileInfo */
    /* no properties */
};

int esxVI_VmLogFileInfo_Alloc(esxVI_VmLogFileInfo **item);
void esxVI_VmLogFileInfo_Free(esxVI_VmLogFileInfo **item);
int esxVI_VmLogFileInfo_Validate(esxVI_VmLogFileInfo *item);
esxVI_VmLogFileInfo *esxVI_VmLogFileInfo_DynamicCast(void *item);
int esxVI_VmLogFileInfo_AppendToList(esxVI_VmLogFileInfo **list, esxVI_VmLogFileInfo *item);
int esxVI_VmLogFileInfo_Deserialize(xmlNodePtr node, esxVI_VmLogFileInfo **item);
int esxVI_VmLogFileInfo_DeserializeList(xmlNodePtr node, esxVI_VmLogFileInfo **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: VmLogFileQuery
 *            extends FileQuery
 */

struct _esxVI_VmLogFileQuery {
    esxVI_VmLogFileQuery *_next;                           /* optional */
    esxVI_Type _type;                                      /* required */

    /* FileQuery */
    /* no properties */

    /* VmLogFileQuery */
    /* no properties */
};

int esxVI_VmLogFileQuery_Alloc(esxVI_VmLogFileQuery **item);
void esxVI_VmLogFileQuery_Free(esxVI_VmLogFileQuery **item);
int esxVI_VmLogFileQuery_Validate(esxVI_VmLogFileQuery *item);
esxVI_VmLogFileQuery *esxVI_VmLogFileQuery_DynamicCast(void *item);
int esxVI_VmLogFileQuery_AppendToList(esxVI_VmLogFileQuery **list, esxVI_VmLogFileQuery *item);
int esxVI_VmLogFileQuery_Serialize(esxVI_VmLogFileQuery *item, const char *element, virBufferPtr output);
int esxVI_VmLogFileQuery_SerializeList(esxVI_VmLogFileQuery *list, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: VmNvramFileInfo
 *            extends FileInfo
 */

struct _esxVI_VmNvramFileInfo {
    esxVI_VmNvramFileInfo *_next;                          /* optional */
    esxVI_Type _type;                                      /* required */

    /* FileInfo */
    char *path;                                            /* required */
    esxVI_Long *fileSize;                                  /* optional */
    esxVI_DateTime *modification;                          /* optional */
    char *owner;                                           /* optional */

    /* VmNvramFileInfo */
    /* no properties */
};

int esxVI_VmNvramFileInfo_Alloc(esxVI_VmNvramFileInfo **item);
void esxVI_VmNvramFileInfo_Free(esxVI_VmNvramFileInfo **item);
int esxVI_VmNvramFileInfo_Validate(esxVI_VmNvramFileInfo *item);
esxVI_VmNvramFileInfo *esxVI_VmNvramFileInfo_DynamicCast(void *item);
int esxVI_VmNvramFileInfo_AppendToList(esxVI_VmNvramFileInfo **list, esxVI_VmNvramFileInfo *item);
int esxVI_VmNvramFileInfo_Deserialize(xmlNodePtr node, esxVI_VmNvramFileInfo **item);
int esxVI_VmNvramFileInfo_DeserializeList(xmlNodePtr node, esxVI_VmNvramFileInfo **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: VmNvramFileQuery
 *            extends FileQuery
 */

struct _esxVI_VmNvramFileQuery {
    esxVI_VmNvramFileQuery *_next;                         /* optional */
    esxVI_Type _type;                                      /* required */

    /* FileQuery */
    /* no properties */

    /* VmNvramFileQuery */
    /* no properties */
};

int esxVI_VmNvramFileQuery_Alloc(esxVI_VmNvramFileQuery **item);
void esxVI_VmNvramFileQuery_Free(esxVI_VmNvramFileQuery **item);
int esxVI_VmNvramFileQuery_Validate(esxVI_VmNvramFileQuery *item);
esxVI_VmNvramFileQuery *esxVI_VmNvramFileQuery_DynamicCast(void *item);
int esxVI_VmNvramFileQuery_AppendToList(esxVI_VmNvramFileQuery **list, esxVI_VmNvramFileQuery *item);
int esxVI_VmNvramFileQuery_Serialize(esxVI_VmNvramFileQuery *item, const char *element, virBufferPtr output);
int esxVI_VmNvramFileQuery_SerializeList(esxVI_VmNvramFileQuery *list, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: VmSnapshotFileInfo
 *            extends FileInfo
 */

struct _esxVI_VmSnapshotFileInfo {
    esxVI_VmSnapshotFileInfo *_next;                       /* optional */
    esxVI_Type _type;                                      /* required */

    /* FileInfo */
    char *path;                                            /* required */
    esxVI_Long *fileSize;                                  /* optional */
    esxVI_DateTime *modification;                          /* optional */
    char *owner;                                           /* optional */

    /* VmSnapshotFileInfo */
    /* no properties */
};

int esxVI_VmSnapshotFileInfo_Alloc(esxVI_VmSnapshotFileInfo **item);
void esxVI_VmSnapshotFileInfo_Free(esxVI_VmSnapshotFileInfo **item);
int esxVI_VmSnapshotFileInfo_Validate(esxVI_VmSnapshotFileInfo *item);
esxVI_VmSnapshotFileInfo *esxVI_VmSnapshotFileInfo_DynamicCast(void *item);
int esxVI_VmSnapshotFileInfo_AppendToList(esxVI_VmSnapshotFileInfo **list, esxVI_VmSnapshotFileInfo *item);
int esxVI_VmSnapshotFileInfo_Deserialize(xmlNodePtr node, esxVI_VmSnapshotFileInfo **item);
int esxVI_VmSnapshotFileInfo_DeserializeList(xmlNodePtr node, esxVI_VmSnapshotFileInfo **list);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: VmSnapshotFileQuery
 *            extends FileQuery
 */

struct _esxVI_VmSnapshotFileQuery {
    esxVI_VmSnapshotFileQuery *_next;                      /* optional */
    esxVI_Type _type;                                      /* required */

    /* FileQuery */
    /* no properties */

    /* VmSnapshotFileQuery */
    /* no properties */
};

int esxVI_VmSnapshotFileQuery_Alloc(esxVI_VmSnapshotFileQuery **item);
void esxVI_VmSnapshotFileQuery_Free(esxVI_VmSnapshotFileQuery **item);
int esxVI_VmSnapshotFileQuery_Validate(esxVI_VmSnapshotFileQuery *item);
esxVI_VmSnapshotFileQuery *esxVI_VmSnapshotFileQuery_DynamicCast(void *item);
int esxVI_VmSnapshotFileQuery_AppendToList(esxVI_VmSnapshotFileQuery **list, esxVI_VmSnapshotFileQuery *item);
int esxVI_VmSnapshotFileQuery_Serialize(esxVI_VmSnapshotFileQuery *item, const char *element, virBufferPtr output);
int esxVI_VmSnapshotFileQuery_SerializeList(esxVI_VmSnapshotFileQuery *list, const char *element, virBufferPtr output);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Object: VmfsDatastoreInfo
 *            extends DatastoreInfo
 */

struct _esxVI_VmfsDatastoreInfo {
    esxVI_VmfsDatastoreInfo *_unused;                      /* optional */
    esxVI_Type _type;                                      /* required */

    /* DatastoreInfo */
    char *name;                                            /* required */
    char *url;                                             /* required */
    esxVI_Long *freeSpace;                                 /* required */
    esxVI_Long *maxFileSize;                               /* required */
    esxVI_DateTime *timestamp;                             /* optional */

    /* VmfsDatastoreInfo */
    esxVI_HostVmfsVolume *vmfs;                            /* optional */
};

int esxVI_VmfsDatastoreInfo_Alloc(esxVI_VmfsDatastoreInfo **item);
void esxVI_VmfsDatastoreInfo_Free(esxVI_VmfsDatastoreInfo **item);
int esxVI_VmfsDatastoreInfo_Validate(esxVI_VmfsDatastoreInfo *item);
esxVI_VmfsDatastoreInfo *esxVI_VmfsDatastoreInfo_DynamicCast(void *item);
int esxVI_VmfsDatastoreInfo_CastFromAnyType(esxVI_AnyType *anyType, esxVI_VmfsDatastoreInfo **item);
int esxVI_VmfsDatastoreInfo_Deserialize(xmlNodePtr node, esxVI_VmfsDatastoreInfo **item);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Managed Object: ComputeResource
 *                    extends ManagedEntity
 */

struct _esxVI_ComputeResource {
    esxVI_ComputeResource *_unused;                        /* optional */
    esxVI_Type _type;                                      /* required */
    esxVI_ManagedObjectReference *_reference;              /* required */

    /* ManagedEntity */
    char *name;                                            /* required */

    /* ComputeResource */
    esxVI_ManagedObjectReference *host;                    /* optional, list */
    esxVI_ManagedObjectReference *resourcePool;            /* optional */
};

int esxVI_ComputeResource_Alloc(esxVI_ComputeResource **item);
void esxVI_ComputeResource_Free(esxVI_ComputeResource **item);
int esxVI_ComputeResource_Validate(esxVI_ComputeResource *item, esxVI_String *selectedPropertyNameList);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Managed Object: Datacenter
 *                    extends ManagedEntity
 */

struct _esxVI_Datacenter {
    esxVI_Datacenter *_unused;                             /* optional */
    esxVI_Type _type;                                      /* required */
    esxVI_ManagedObjectReference *_reference;              /* required */

    /* ManagedEntity */
    char *name;                                            /* required */

    /* Datacenter */
    esxVI_ManagedObjectReference *hostFolder;              /* required */
    esxVI_ManagedObjectReference *vmFolder;                /* required */
};

int esxVI_Datacenter_Alloc(esxVI_Datacenter **item);
void esxVI_Datacenter_Free(esxVI_Datacenter **item);
int esxVI_Datacenter_Validate(esxVI_Datacenter *item, esxVI_String *selectedPropertyNameList);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Managed Object: Folder
 *                    extends ManagedEntity
 */

struct _esxVI_Folder {
    esxVI_Folder *_unused;                                 /* optional */
    esxVI_Type _type;                                      /* required */
    esxVI_ManagedObjectReference *_reference;              /* required */

    /* ManagedEntity */
    char *name;                                            /* required */

    /* Folder */
    /* no properties */
};

int esxVI_Folder_Alloc(esxVI_Folder **item);
void esxVI_Folder_Free(esxVI_Folder **item);
int esxVI_Folder_Validate(esxVI_Folder *item, esxVI_String *selectedPropertyNameList);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Managed Object: HostSystem
 *                    extends ManagedEntity
 */

struct _esxVI_HostSystem {
    esxVI_HostSystem *_unused;                             /* optional */
    esxVI_Type _type;                                      /* required */
    esxVI_ManagedObjectReference *_reference;              /* required */

    /* ManagedEntity */
    char *name;                                            /* required */

    /* HostSystem */
    esxVI_HostConfigManager *configManager;                /* required */
};

int esxVI_HostSystem_Alloc(esxVI_HostSystem **item);
void esxVI_HostSystem_Free(esxVI_HostSystem **item);
int esxVI_HostSystem_Validate(esxVI_HostSystem *item, esxVI_String *selectedPropertyNameList);



/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * VI Managed Object: ManagedEntity
 *                    extended by ComputeResource
 *                                Datacenter
 *                                Folder
 *                                HostSystem
 */

struct _esxVI_ManagedEntity {
    esxVI_ManagedEntity *_unused;                          /* optional */
    esxVI_Type _type;                                      /* required */
    esxVI_ManagedObjectReference *_reference;              /* required */

    char *name;                                            /* required */
};

int esxVI_ManagedEntity_Alloc(esxVI_ManagedEntity **item);
void esxVI_ManagedEntity_Free(esxVI_ManagedEntity **item);
int esxVI_ManagedEntity_Validate(esxVI_ManagedEntity *item, esxVI_String *selectedPropertyNameList);



