github.com/vmware/govmomi@v0.37.2/vslm/types/types.go

/*
Copyright (c) 2014-2023 VMware, Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package types

import (
	"reflect"
	"time"

	"github.com/vmware/govmomi/vim25/types"
)

// A boxed array of `VslmDatastoreSyncStatus`. To be used in `Any` placeholders.
type ArrayOfVslmDatastoreSyncStatus struct {
	VslmDatastoreSyncStatus []VslmDatastoreSyncStatus `xml:"VslmDatastoreSyncStatus,omitempty" json:"_value"`
}

func init() {
	types.Add("vslm:ArrayOfVslmDatastoreSyncStatus", reflect.TypeOf((*ArrayOfVslmDatastoreSyncStatus)(nil)).Elem())
}

// A boxed array of `VslmQueryDatastoreInfoResult`. To be used in `Any` placeholders.
type ArrayOfVslmQueryDatastoreInfoResult struct {
	VslmQueryDatastoreInfoResult []VslmQueryDatastoreInfoResult `xml:"VslmQueryDatastoreInfoResult,omitempty" json:"_value"`
}

func init() {
	types.Add("vslm:ArrayOfVslmQueryDatastoreInfoResult", reflect.TypeOf((*ArrayOfVslmQueryDatastoreInfoResult)(nil)).Elem())
}

// A boxed array of `VslmVsoVStorageObjectAssociations`. To be used in `Any` placeholders.
type ArrayOfVslmVsoVStorageObjectAssociations struct {
	VslmVsoVStorageObjectAssociations []VslmVsoVStorageObjectAssociations `xml:"VslmVsoVStorageObjectAssociations,omitempty" json:"_value"`
}

func init() {
	types.Add("vslm:ArrayOfVslmVsoVStorageObjectAssociations", reflect.TypeOf((*ArrayOfVslmVsoVStorageObjectAssociations)(nil)).Elem())
}

// A boxed array of `VslmVsoVStorageObjectAssociationsVmDiskAssociation`. To be used in `Any` placeholders.
type ArrayOfVslmVsoVStorageObjectAssociationsVmDiskAssociation struct {
	VslmVsoVStorageObjectAssociationsVmDiskAssociation []VslmVsoVStorageObjectAssociationsVmDiskAssociation `xml:"VslmVsoVStorageObjectAssociationsVmDiskAssociation,omitempty" json:"_value"`
}

func init() {
	types.Add("vslm:ArrayOfVslmVsoVStorageObjectAssociationsVmDiskAssociation", reflect.TypeOf((*ArrayOfVslmVsoVStorageObjectAssociationsVmDiskAssociation)(nil)).Elem())
}

// A boxed array of `VslmVsoVStorageObjectQuerySpec`. To be used in `Any` placeholders.
type ArrayOfVslmVsoVStorageObjectQuerySpec struct {
	VslmVsoVStorageObjectQuerySpec []VslmVsoVStorageObjectQuerySpec `xml:"VslmVsoVStorageObjectQuerySpec,omitempty" json:"_value"`
}

func init() {
	types.Add("vslm:ArrayOfVslmVsoVStorageObjectQuerySpec", reflect.TypeOf((*ArrayOfVslmVsoVStorageObjectQuerySpec)(nil)).Elem())
}

// A boxed array of `VslmVsoVStorageObjectResult`. To be used in `Any` placeholders.
type ArrayOfVslmVsoVStorageObjectResult struct {
	VslmVsoVStorageObjectResult []VslmVsoVStorageObjectResult `xml:"VslmVsoVStorageObjectResult,omitempty" json:"_value"`
}

func init() {
	types.Add("vslm:ArrayOfVslmVsoVStorageObjectResult", reflect.TypeOf((*ArrayOfVslmVsoVStorageObjectResult)(nil)).Elem())
}

// A boxed array of `VslmVsoVStorageObjectSnapshotResult`. To be used in `Any` placeholders.
type ArrayOfVslmVsoVStorageObjectSnapshotResult struct {
	VslmVsoVStorageObjectSnapshotResult []VslmVsoVStorageObjectSnapshotResult `xml:"VslmVsoVStorageObjectSnapshotResult,omitempty" json:"_value"`
}

func init() {
	types.Add("vslm:ArrayOfVslmVsoVStorageObjectSnapshotResult", reflect.TypeOf((*ArrayOfVslmVsoVStorageObjectSnapshotResult)(nil)).Elem())
}

type RetrieveContent RetrieveContentRequestType

func init() {
	types.Add("vslm:RetrieveContent", reflect.TypeOf((*RetrieveContent)(nil)).Elem())
}

type RetrieveContentRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
}

func init() {
	types.Add("vslm:RetrieveContentRequestType", reflect.TypeOf((*RetrieveContentRequestType)(nil)).Elem())
}

type RetrieveContentResponse struct {
	Returnval VslmServiceInstanceContent `xml:"returnval" json:"returnval"`
}

// This data object type describes system information.
//
// This structure may be used only with operations rendered under `/vslm`.
type VslmAboutInfo struct {
	types.DynamicData

	Name         string `xml:"name" json:"name"`
	FullName     string `xml:"fullName" json:"fullName"`
	Vendor       string `xml:"vendor" json:"vendor"`
	ApiVersion   string `xml:"apiVersion" json:"apiVersion"`
	InstanceUuid string `xml:"instanceUuid" json:"instanceUuid"`
}

func init() {
	types.Add("vslm:VslmAboutInfo", reflect.TypeOf((*VslmAboutInfo)(nil)).Elem())
}

// The parameters of `VslmVStorageObjectManager.VslmAttachDisk_Task`.
type VslmAttachDiskRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The ID of the virtual disk to be operated. See
	// `ID`
	Id types.ID `xml:"id" json:"id"`
	// The virtual machine where the virtual disk is to be attached.
	//
	// Refers instance of `VirtualMachine`.
	Vm types.ManagedObjectReference `xml:"vm" json:"vm"`
	// Key of the controller the disk will connect to.
	// It can be unset if there is only one controller
	// (SCSI or SATA) with the available slot in the
	// virtual machine. If there are multiple SCSI or
	// SATA controllers available, user must specify
	// the controller; if there is no available
	// controllers, a `MissingController`
	// fault will be thrown.
	ControllerKey int32 `xml:"controllerKey,omitempty" json:"controllerKey,omitempty"`
	// The unit number of the attached disk on its controller.
	// If unset, the next available slot on the specified
	// controller or the only available controller will be
	// assigned to the attached disk.
	UnitNumber *int32 `xml:"unitNumber" json:"unitNumber,omitempty"`
}

func init() {
	types.Add("vslm:VslmAttachDiskRequestType", reflect.TypeOf((*VslmAttachDiskRequestType)(nil)).Elem())
}

type VslmAttachDisk_Task VslmAttachDiskRequestType

func init() {
	types.Add("vslm:VslmAttachDisk_Task", reflect.TypeOf((*VslmAttachDisk_Task)(nil)).Elem())
}

type VslmAttachDisk_TaskResponse struct {
	Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"`
}

type VslmAttachTagToVStorageObject VslmAttachTagToVStorageObjectRequestType

func init() {
	types.Add("vslm:VslmAttachTagToVStorageObject", reflect.TypeOf((*VslmAttachTagToVStorageObject)(nil)).Elem())
}

// The parameters of `VslmVStorageObjectManager.VslmAttachTagToVStorageObject`.
type VslmAttachTagToVStorageObjectRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The identifier(ID) of the virtual storage object.
	Id types.ID `xml:"id" json:"id"`
	// The category to which the tag belongs.
	Category string `xml:"category" json:"category"`
	// The tag which has to be associated with the virtual storage
	// object.
	Tag string `xml:"tag" json:"tag"`
}

func init() {
	types.Add("vslm:VslmAttachTagToVStorageObjectRequestType", reflect.TypeOf((*VslmAttachTagToVStorageObjectRequestType)(nil)).Elem())
}

type VslmAttachTagToVStorageObjectResponse struct {
}

type VslmCancelTask VslmCancelTaskRequestType

func init() {
	types.Add("vslm:VslmCancelTask", reflect.TypeOf((*VslmCancelTask)(nil)).Elem())
}

type VslmCancelTaskRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
}

func init() {
	types.Add("vslm:VslmCancelTaskRequestType", reflect.TypeOf((*VslmCancelTaskRequestType)(nil)).Elem())
}

type VslmCancelTaskResponse struct {
}

type VslmClearVStorageObjectControlFlags VslmClearVStorageObjectControlFlagsRequestType

func init() {
	types.Add("vslm:VslmClearVStorageObjectControlFlags", reflect.TypeOf((*VslmClearVStorageObjectControlFlags)(nil)).Elem())
}

// The parameters of `VslmVStorageObjectManager.VslmClearVStorageObjectControlFlags`.
type VslmClearVStorageObjectControlFlagsRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The ID of the virtual storage object.
	Id types.ID `xml:"id" json:"id"`
	// control flags enum array to be cleared on the
	// VStorageObject. All control flags not included
	// in the array remain intact.
	ControlFlags []string `xml:"controlFlags,omitempty" json:"controlFlags,omitempty"`
}

func init() {
	types.Add("vslm:VslmClearVStorageObjectControlFlagsRequestType", reflect.TypeOf((*VslmClearVStorageObjectControlFlagsRequestType)(nil)).Elem())
}

type VslmClearVStorageObjectControlFlagsResponse struct {
}

// The parameters of `VslmVStorageObjectManager.VslmCloneVStorageObject_Task`.
type VslmCloneVStorageObjectRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The ID of the virtual storage object.
	Id types.ID `xml:"id" json:"id"`
	// The specification for cloning the virtual storage
	// object.
	Spec types.VslmCloneSpec `xml:"spec" json:"spec"`
}

func init() {
	types.Add("vslm:VslmCloneVStorageObjectRequestType", reflect.TypeOf((*VslmCloneVStorageObjectRequestType)(nil)).Elem())
}

type VslmCloneVStorageObject_Task VslmCloneVStorageObjectRequestType

func init() {
	types.Add("vslm:VslmCloneVStorageObject_Task", reflect.TypeOf((*VslmCloneVStorageObject_Task)(nil)).Elem())
}

type VslmCloneVStorageObject_TaskResponse struct {
	Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"`
}

// The parameters of `VslmVStorageObjectManager.VslmCreateDiskFromSnapshot_Task`.
type VslmCreateDiskFromSnapshotRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The ID of the virtual storage object.
	Id types.ID `xml:"id" json:"id"`
	// The ID of the snapshot of the virtual storage object.
	SnapshotId types.ID `xml:"snapshotId" json:"snapshotId"`
	// A user friendly name to be associated with the new disk.
	Name string `xml:"name" json:"name"`
	// SPBM Profile requirement on the new virtual storage object.
	// If not specified datastore default policy would be
	// assigned.
	Profile []types.VirtualMachineProfileSpec `xml:"profile,omitempty" json:"profile,omitempty"`
	// Crypto information of the new disk.
	Crypto *types.CryptoSpec `xml:"crypto,omitempty" json:"crypto,omitempty"`
	// Relative location in the specified datastore where disk needs
	// to be created. If not specified disk gets created at the
	// defualt VStorageObject location on the specified datastore.
	Path string `xml:"path,omitempty" json:"path,omitempty"`
}

func init() {
	types.Add("vslm:VslmCreateDiskFromSnapshotRequestType", reflect.TypeOf((*VslmCreateDiskFromSnapshotRequestType)(nil)).Elem())
}

type VslmCreateDiskFromSnapshot_Task VslmCreateDiskFromSnapshotRequestType

func init() {
	types.Add("vslm:VslmCreateDiskFromSnapshot_Task", reflect.TypeOf((*VslmCreateDiskFromSnapshot_Task)(nil)).Elem())
}

type VslmCreateDiskFromSnapshot_TaskResponse struct {
	Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"`
}

// The parameters of `VslmVStorageObjectManager.VslmCreateDisk_Task`.
type VslmCreateDiskRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The specification of the virtual storage object
	// to be created.
	Spec types.VslmCreateSpec `xml:"spec" json:"spec"`
}

func init() {
	types.Add("vslm:VslmCreateDiskRequestType", reflect.TypeOf((*VslmCreateDiskRequestType)(nil)).Elem())
}

type VslmCreateDisk_Task VslmCreateDiskRequestType

func init() {
	types.Add("vslm:VslmCreateDisk_Task", reflect.TypeOf((*VslmCreateDisk_Task)(nil)).Elem())
}

type VslmCreateDisk_TaskResponse struct {
	Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"`
}

// The parameters of `VslmVStorageObjectManager.VslmCreateSnapshot_Task`.
type VslmCreateSnapshotRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The ID of the virtual storage object.
	Id types.ID `xml:"id" json:"id"`
	// A short description to be associated with the snapshot.
	Description string `xml:"description" json:"description"`
}

func init() {
	types.Add("vslm:VslmCreateSnapshotRequestType", reflect.TypeOf((*VslmCreateSnapshotRequestType)(nil)).Elem())
}

type VslmCreateSnapshot_Task VslmCreateSnapshotRequestType

func init() {
	types.Add("vslm:VslmCreateSnapshot_Task", reflect.TypeOf((*VslmCreateSnapshot_Task)(nil)).Elem())
}

type VslmCreateSnapshot_TaskResponse struct {
	Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"`
}

// DatastoreSyncStatus shows the catalog sync status of a datastore
// and is returned as a result of the VStorageObjectManager
// getGlobalCatalogSyncStatus API.
//
// When syncVClock == objectVClock the global catalog is in sync with the
// local catalog
//
// This structure may be used only with operations rendered under `/vslm`.
type VslmDatastoreSyncStatus struct {
	types.DynamicData

	// The datastore URL as specified in `DatastoreInfo.url`
	DatastoreURL string `xml:"datastoreURL" json:"datastoreURL"`
	ObjectVClock int64  `xml:"objectVClock" json:"objectVClock"`
	SyncVClock   int64  `xml:"syncVClock" json:"syncVClock"`
	// The time representing the last successfull sync of the datastore.
	SyncTime *time.Time `xml:"syncTime" json:"syncTime,omitempty"`
	// The number of retries for the Datastore synchronization in failure
	// cases.
	NumberOfRetries int32 `xml:"numberOfRetries,omitempty" json:"numberOfRetries,omitempty"`
	// The fault is set in case of error conditions.
	//
	// If the fault is set,
	// the objectVClock and syncVClock will be set to -1L.
	// Possible Faults:
	// SyncFault If specified datastoreURL failed to sync.
	Error *types.LocalizedMethodFault `xml:"error,omitempty" json:"error,omitempty"`
}

func init() {
	types.Add("vslm:VslmDatastoreSyncStatus", reflect.TypeOf((*VslmDatastoreSyncStatus)(nil)).Elem())
}

// The parameters of `VslmVStorageObjectManager.VslmDeleteSnapshot_Task`.
type VslmDeleteSnapshotRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The ID of the virtual storage object.
	Id types.ID `xml:"id" json:"id"`
	// The ID of the snapshot of a virtual storage object.
	SnapshotId types.ID `xml:"snapshotId" json:"snapshotId"`
}

func init() {
	types.Add("vslm:VslmDeleteSnapshotRequestType", reflect.TypeOf((*VslmDeleteSnapshotRequestType)(nil)).Elem())
}

type VslmDeleteSnapshot_Task VslmDeleteSnapshotRequestType

func init() {
	types.Add("vslm:VslmDeleteSnapshot_Task", reflect.TypeOf((*VslmDeleteSnapshot_Task)(nil)).Elem())
}

type VslmDeleteSnapshot_TaskResponse struct {
	Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"`
}

// The parameters of `VslmVStorageObjectManager.VslmDeleteVStorageObject_Task`.
type VslmDeleteVStorageObjectRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The ID of the virtual storage object to be deleted.
	Id types.ID `xml:"id" json:"id"`
}

func init() {
	types.Add("vslm:VslmDeleteVStorageObjectRequestType", reflect.TypeOf((*VslmDeleteVStorageObjectRequestType)(nil)).Elem())
}

type VslmDeleteVStorageObject_Task VslmDeleteVStorageObjectRequestType

func init() {
	types.Add("vslm:VslmDeleteVStorageObject_Task", reflect.TypeOf((*VslmDeleteVStorageObject_Task)(nil)).Elem())
}

type VslmDeleteVStorageObject_TaskResponse struct {
	Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"`
}

type VslmDetachTagFromVStorageObject VslmDetachTagFromVStorageObjectRequestType

func init() {
	types.Add("vslm:VslmDetachTagFromVStorageObject", reflect.TypeOf((*VslmDetachTagFromVStorageObject)(nil)).Elem())
}

// The parameters of `VslmVStorageObjectManager.VslmDetachTagFromVStorageObject`.
type VslmDetachTagFromVStorageObjectRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The identifier(ID) of the virtual storage object.
	Id types.ID `xml:"id" json:"id"`
	// The category to which the tag belongs.
	Category string `xml:"category" json:"category"`
	// The tag which has to be disassociated with the virtual storage
	// object.
	Tag string `xml:"tag" json:"tag"`
}

func init() {
	types.Add("vslm:VslmDetachTagFromVStorageObjectRequestType", reflect.TypeOf((*VslmDetachTagFromVStorageObjectRequestType)(nil)).Elem())
}

type VslmDetachTagFromVStorageObjectResponse struct {
}

// The parameters of `VslmVStorageObjectManager.VslmExtendDisk_Task`.
type VslmExtendDiskRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The ID of the virtual disk to be extended.
	Id types.ID `xml:"id" json:"id"`
	// The new capacity of the virtual disk in MB.
	NewCapacityInMB int64 `xml:"newCapacityInMB" json:"newCapacityInMB"`
}

func init() {
	types.Add("vslm:VslmExtendDiskRequestType", reflect.TypeOf((*VslmExtendDiskRequestType)(nil)).Elem())
}

type VslmExtendDisk_Task VslmExtendDiskRequestType

func init() {
	types.Add("vslm:VslmExtendDisk_Task", reflect.TypeOf((*VslmExtendDisk_Task)(nil)).Elem())
}

type VslmExtendDisk_TaskResponse struct {
	Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"`
}

// The super class for all VSLM Faults.
//
// This structure may be used only with operations rendered under `/vslm`.
type VslmFault struct {
	types.MethodFault

	// The fault message if available.
	Msg string `xml:"msg,omitempty" json:"msg,omitempty"`
}

func init() {
	types.Add("vslm:VslmFault", reflect.TypeOf((*VslmFault)(nil)).Elem())
}

type VslmFaultFault BaseVslmFault

func init() {
	types.Add("vslm:VslmFaultFault", reflect.TypeOf((*VslmFaultFault)(nil)).Elem())
}

// The parameters of `VslmVStorageObjectManager.VslmInflateDisk_Task`.
type VslmInflateDiskRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The ID of the virtual disk to be inflated.
	Id types.ID `xml:"id" json:"id"`
}

func init() {
	types.Add("vslm:VslmInflateDiskRequestType", reflect.TypeOf((*VslmInflateDiskRequestType)(nil)).Elem())
}

type VslmInflateDisk_Task VslmInflateDiskRequestType

func init() {
	types.Add("vslm:VslmInflateDisk_Task", reflect.TypeOf((*VslmInflateDisk_Task)(nil)).Elem())
}

type VslmInflateDisk_TaskResponse struct {
	Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"`
}

type VslmListTagsAttachedToVStorageObject VslmListTagsAttachedToVStorageObjectRequestType

func init() {
	types.Add("vslm:VslmListTagsAttachedToVStorageObject", reflect.TypeOf((*VslmListTagsAttachedToVStorageObject)(nil)).Elem())
}

// The parameters of `VslmVStorageObjectManager.VslmListTagsAttachedToVStorageObject`.
type VslmListTagsAttachedToVStorageObjectRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The ID of the virtual storage object.
	Id types.ID `xml:"id" json:"id"`
}

func init() {
	types.Add("vslm:VslmListTagsAttachedToVStorageObjectRequestType", reflect.TypeOf((*VslmListTagsAttachedToVStorageObjectRequestType)(nil)).Elem())
}

type VslmListTagsAttachedToVStorageObjectResponse struct {
	Returnval []types.VslmTagEntry `xml:"returnval,omitempty" json:"returnval,omitempty"`
}

type VslmListVStorageObjectForSpec VslmListVStorageObjectForSpecRequestType

func init() {
	types.Add("vslm:VslmListVStorageObjectForSpec", reflect.TypeOf((*VslmListVStorageObjectForSpec)(nil)).Elem())
}

// The parameters of `VslmVStorageObjectManager.VslmListVStorageObjectForSpec`.
type VslmListVStorageObjectForSpecRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// Query defined using array of
	// `VslmVsoVStorageObjectQuerySpec` objects.
	Query []VslmVsoVStorageObjectQuerySpec `xml:"query,omitempty" json:"query,omitempty"`
	// Maximum number of virtual storage object IDs to return.
	MaxResult int32 `xml:"maxResult" json:"maxResult"`
}

func init() {
	types.Add("vslm:VslmListVStorageObjectForSpecRequestType", reflect.TypeOf((*VslmListVStorageObjectForSpecRequestType)(nil)).Elem())
}

type VslmListVStorageObjectForSpecResponse struct {
	Returnval *VslmVsoVStorageObjectQueryResult `xml:"returnval,omitempty" json:"returnval,omitempty"`
}

type VslmListVStorageObjectsAttachedToTag VslmListVStorageObjectsAttachedToTagRequestType

func init() {
	types.Add("vslm:VslmListVStorageObjectsAttachedToTag", reflect.TypeOf((*VslmListVStorageObjectsAttachedToTag)(nil)).Elem())
}

// The parameters of `VslmVStorageObjectManager.VslmListVStorageObjectsAttachedToTag`.
type VslmListVStorageObjectsAttachedToTagRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The category to which the tag belongs.
	Category string `xml:"category" json:"category"`
	// The tag to be queried.
	Tag string `xml:"tag" json:"tag"`
}

func init() {
	types.Add("vslm:VslmListVStorageObjectsAttachedToTagRequestType", reflect.TypeOf((*VslmListVStorageObjectsAttachedToTagRequestType)(nil)).Elem())
}

type VslmListVStorageObjectsAttachedToTagResponse struct {
	Returnval []types.ID `xml:"returnval,omitempty" json:"returnval,omitempty"`
}

type VslmLoginByToken VslmLoginByTokenRequestType

func init() {
	types.Add("vslm:VslmLoginByToken", reflect.TypeOf((*VslmLoginByToken)(nil)).Elem())
}

// The parameters of `VslmSessionManager.VslmLoginByToken`.
type VslmLoginByTokenRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The delegated token will be retrieved by the
	// client and delegated to VSLM. VSLM will use this token, on user's
	// behalf, to login to VC for authorization purposes. It is necessary
	// to convert the token to XML because the SAML token itself is
	// not a VMODL Data Object and cannot be used as a parameter.
	DelegatedTokenXml string `xml:"delegatedTokenXml" json:"delegatedTokenXml"`
}

func init() {
	types.Add("vslm:VslmLoginByTokenRequestType", reflect.TypeOf((*VslmLoginByTokenRequestType)(nil)).Elem())
}

type VslmLoginByTokenResponse struct {
}

type VslmLogout VslmLogoutRequestType

func init() {
	types.Add("vslm:VslmLogout", reflect.TypeOf((*VslmLogout)(nil)).Elem())
}

type VslmLogoutRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
}

func init() {
	types.Add("vslm:VslmLogoutRequestType", reflect.TypeOf((*VslmLogoutRequestType)(nil)).Elem())
}

type VslmLogoutResponse struct {
}

type VslmQueryChangedDiskAreas VslmQueryChangedDiskAreasRequestType

func init() {
	types.Add("vslm:VslmQueryChangedDiskAreas", reflect.TypeOf((*VslmQueryChangedDiskAreas)(nil)).Elem())
}

// The parameters of `VslmVStorageObjectManager.VslmQueryChangedDiskAreas`.
type VslmQueryChangedDiskAreasRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The ID of the virtual storage object.
	Id types.ID `xml:"id" json:"id"`
	// The ID of the snapshot of a virtual storage object for
	// which changes that have been made since "changeId"
	// should be computed.
	SnapshotId types.ID `xml:"snapshotId" json:"snapshotId"`
	// Start Offset in bytes at which to start computing
	// changes. Typically, callers will make multiple calls
	// to this function, starting with startOffset 0 and then
	// examine the "length" property in the returned
	// DiskChangeInfo structure, repeatedly calling
	// queryChangedDiskAreas until a map for the entire
	// virtual disk has been obtained.
	StartOffset int64 `xml:"startOffset" json:"startOffset"`
	// Identifier referring to a point in the past that should
	// be used as the point in time at which to begin including
	// changes to the disk in the result. A typical use case
	// would be a backup application obtaining a changeId from
	// a virtual disk's backing info when performing a backup.
	// When a subsequent incremental backup is to be performed,
	// this change Id can be used to obtain a list of changed
	// areas on disk.
	ChangeId string `xml:"changeId" json:"changeId"`
}

func init() {
	types.Add("vslm:VslmQueryChangedDiskAreasRequestType", reflect.TypeOf((*VslmQueryChangedDiskAreasRequestType)(nil)).Elem())
}

type VslmQueryChangedDiskAreasResponse struct {
	Returnval types.DiskChangeInfo `xml:"returnval" json:"returnval"`
}

type VslmQueryDatastoreInfo VslmQueryDatastoreInfoRequestType

func init() {
	types.Add("vslm:VslmQueryDatastoreInfo", reflect.TypeOf((*VslmQueryDatastoreInfo)(nil)).Elem())
}

// The parameters of `VslmStorageLifecycleManager.VslmQueryDatastoreInfo`.
type VslmQueryDatastoreInfoRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The datastore URL as specified in
	// `DatastoreInfo.url`
	DatastoreUrl string `xml:"datastoreUrl" json:"datastoreUrl"`
}

func init() {
	types.Add("vslm:VslmQueryDatastoreInfoRequestType", reflect.TypeOf((*VslmQueryDatastoreInfoRequestType)(nil)).Elem())
}

type VslmQueryDatastoreInfoResponse struct {
	Returnval []VslmQueryDatastoreInfoResult `xml:"returnval,omitempty" json:"returnval,omitempty"`
}

// The `VslmQueryDatastoreInfoResult` provides mapping information
// between `Datacenter` and `Datastore`.
//
// This API is returned as a result of
// `VslmStorageLifecycleManager.VslmQueryDatastoreInfo` invocation.
//
// This structure may be used only with operations rendered under `/vslm`.
type VslmQueryDatastoreInfoResult struct {
	types.DynamicData

	// Indicates the datacenter containing the
	// `VslmQueryDatastoreInfoResult.datastore`.
	//
	// Refers instance of `Datacenter`.
	Datacenter types.ManagedObjectReference `xml:"datacenter" json:"datacenter"`
	// Indicates the datastore which is contained within the
	// `VslmQueryDatastoreInfoResult.datacenter`.
	//
	// Refers instance of `Datastore`.
	Datastore types.ManagedObjectReference `xml:"datastore" json:"datastore"`
}

func init() {
	types.Add("vslm:VslmQueryDatastoreInfoResult", reflect.TypeOf((*VslmQueryDatastoreInfoResult)(nil)).Elem())
}

type VslmQueryGlobalCatalogSyncStatus VslmQueryGlobalCatalogSyncStatusRequestType

func init() {
	types.Add("vslm:VslmQueryGlobalCatalogSyncStatus", reflect.TypeOf((*VslmQueryGlobalCatalogSyncStatus)(nil)).Elem())
}

type VslmQueryGlobalCatalogSyncStatusForDatastore VslmQueryGlobalCatalogSyncStatusForDatastoreRequestType

func init() {
	types.Add("vslm:VslmQueryGlobalCatalogSyncStatusForDatastore", reflect.TypeOf((*VslmQueryGlobalCatalogSyncStatusForDatastore)(nil)).Elem())
}

// The parameters of `VslmVStorageObjectManager.VslmQueryGlobalCatalogSyncStatusForDatastore`.
type VslmQueryGlobalCatalogSyncStatusForDatastoreRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// URL of the datastore to check synchronization status for
	DatastoreURL string `xml:"datastoreURL" json:"datastoreURL"`
}

func init() {
	types.Add("vslm:VslmQueryGlobalCatalogSyncStatusForDatastoreRequestType", reflect.TypeOf((*VslmQueryGlobalCatalogSyncStatusForDatastoreRequestType)(nil)).Elem())
}

type VslmQueryGlobalCatalogSyncStatusForDatastoreResponse struct {
	Returnval *VslmDatastoreSyncStatus `xml:"returnval,omitempty" json:"returnval,omitempty"`
}

type VslmQueryGlobalCatalogSyncStatusRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
}

func init() {
	types.Add("vslm:VslmQueryGlobalCatalogSyncStatusRequestType", reflect.TypeOf((*VslmQueryGlobalCatalogSyncStatusRequestType)(nil)).Elem())
}

type VslmQueryGlobalCatalogSyncStatusResponse struct {
	Returnval []VslmDatastoreSyncStatus `xml:"returnval,omitempty" json:"returnval,omitempty"`
}

type VslmQueryInfo VslmQueryInfoRequestType

func init() {
	types.Add("vslm:VslmQueryInfo", reflect.TypeOf((*VslmQueryInfo)(nil)).Elem())
}

type VslmQueryInfoRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
}

func init() {
	types.Add("vslm:VslmQueryInfoRequestType", reflect.TypeOf((*VslmQueryInfoRequestType)(nil)).Elem())
}

type VslmQueryInfoResponse struct {
	Returnval VslmTaskInfo `xml:"returnval" json:"returnval"`
}

type VslmQueryTaskResult VslmQueryTaskResultRequestType

func init() {
	types.Add("vslm:VslmQueryTaskResult", reflect.TypeOf((*VslmQueryTaskResult)(nil)).Elem())
}

type VslmQueryTaskResultRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
}

func init() {
	types.Add("vslm:VslmQueryTaskResultRequestType", reflect.TypeOf((*VslmQueryTaskResultRequestType)(nil)).Elem())
}

type VslmQueryTaskResultResponse struct {
	Returnval types.AnyType `xml:"returnval,omitempty,typeattr" json:"returnval,omitempty"`
}

// The parameters of `VslmVStorageObjectManager.VslmReconcileDatastoreInventory_Task`.
type VslmReconcileDatastoreInventoryRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The datastore that needs to be reconciled.
	//
	// Refers instance of `Datastore`.
	Datastore types.ManagedObjectReference `xml:"datastore" json:"datastore"`
}

func init() {
	types.Add("vslm:VslmReconcileDatastoreInventoryRequestType", reflect.TypeOf((*VslmReconcileDatastoreInventoryRequestType)(nil)).Elem())
}

type VslmReconcileDatastoreInventory_Task VslmReconcileDatastoreInventoryRequestType

func init() {
	types.Add("vslm:VslmReconcileDatastoreInventory_Task", reflect.TypeOf((*VslmReconcileDatastoreInventory_Task)(nil)).Elem())
}

type VslmReconcileDatastoreInventory_TaskResponse struct {
	Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"`
}

type VslmRegisterDisk VslmRegisterDiskRequestType

func init() {
	types.Add("vslm:VslmRegisterDisk", reflect.TypeOf((*VslmRegisterDisk)(nil)).Elem())
}

// The parameters of `VslmVStorageObjectManager.VslmRegisterDisk`.
type VslmRegisterDiskRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// URL path to the virtual disk.
	Path string `xml:"path" json:"path"`
	// The descriptive name of the disk object. If
	// unset the name will be automatically determined
	// from the path. @see vim.vslm.BaseConfigInfo.name
	Name string `xml:"name,omitempty" json:"name,omitempty"`
}

func init() {
	types.Add("vslm:VslmRegisterDiskRequestType", reflect.TypeOf((*VslmRegisterDiskRequestType)(nil)).Elem())
}

type VslmRegisterDiskResponse struct {
	Returnval types.VStorageObject `xml:"returnval" json:"returnval"`
}

// The parameters of `VslmVStorageObjectManager.VslmRelocateVStorageObject_Task`.
type VslmRelocateVStorageObjectRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The ID of the virtual storage object.
	Id types.ID `xml:"id" json:"id"`
	// The specification for relocation of the virtual
	// storage object.
	Spec types.VslmRelocateSpec `xml:"spec" json:"spec"`
}

func init() {
	types.Add("vslm:VslmRelocateVStorageObjectRequestType", reflect.TypeOf((*VslmRelocateVStorageObjectRequestType)(nil)).Elem())
}

type VslmRelocateVStorageObject_Task VslmRelocateVStorageObjectRequestType

func init() {
	types.Add("vslm:VslmRelocateVStorageObject_Task", reflect.TypeOf((*VslmRelocateVStorageObject_Task)(nil)).Elem())
}

type VslmRelocateVStorageObject_TaskResponse struct {
	Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"`
}

type VslmRenameVStorageObject VslmRenameVStorageObjectRequestType

func init() {
	types.Add("vslm:VslmRenameVStorageObject", reflect.TypeOf((*VslmRenameVStorageObject)(nil)).Elem())
}

// The parameters of `VslmVStorageObjectManager.VslmRenameVStorageObject`.
type VslmRenameVStorageObjectRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The ID of the virtual storage object to be renamed.
	Id types.ID `xml:"id" json:"id"`
	// The new name for the virtual storage object.
	Name string `xml:"name" json:"name"`
}

func init() {
	types.Add("vslm:VslmRenameVStorageObjectRequestType", reflect.TypeOf((*VslmRenameVStorageObjectRequestType)(nil)).Elem())
}

type VslmRenameVStorageObjectResponse struct {
}

type VslmRetrieveSnapshotDetails VslmRetrieveSnapshotDetailsRequestType

func init() {
	types.Add("vslm:VslmRetrieveSnapshotDetails", reflect.TypeOf((*VslmRetrieveSnapshotDetails)(nil)).Elem())
}

// The parameters of `VslmVStorageObjectManager.VslmRetrieveSnapshotDetails`.
type VslmRetrieveSnapshotDetailsRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The ID of the virtual storage object.
	Id types.ID `xml:"id" json:"id"`
	// The ID of the snapshot of a virtual storage object.
	SnapshotId types.ID `xml:"snapshotId" json:"snapshotId"`
}

func init() {
	types.Add("vslm:VslmRetrieveSnapshotDetailsRequestType", reflect.TypeOf((*VslmRetrieveSnapshotDetailsRequestType)(nil)).Elem())
}

type VslmRetrieveSnapshotDetailsResponse struct {
	Returnval types.VStorageObjectSnapshotDetails `xml:"returnval" json:"returnval"`
}

type VslmRetrieveSnapshotInfo VslmRetrieveSnapshotInfoRequestType

func init() {
	types.Add("vslm:VslmRetrieveSnapshotInfo", reflect.TypeOf((*VslmRetrieveSnapshotInfo)(nil)).Elem())
}

// The parameters of `VslmVStorageObjectManager.VslmRetrieveSnapshotInfo`.
type VslmRetrieveSnapshotInfoRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The ID of the virtual storage object.
	Id types.ID `xml:"id" json:"id"`
}

func init() {
	types.Add("vslm:VslmRetrieveSnapshotInfoRequestType", reflect.TypeOf((*VslmRetrieveSnapshotInfoRequestType)(nil)).Elem())
}

type VslmRetrieveSnapshotInfoResponse struct {
	Returnval types.VStorageObjectSnapshotInfo `xml:"returnval" json:"returnval"`
}

type VslmRetrieveVStorageInfrastructureObjectPolicy VslmRetrieveVStorageInfrastructureObjectPolicyRequestType

func init() {
	types.Add("vslm:VslmRetrieveVStorageInfrastructureObjectPolicy", reflect.TypeOf((*VslmRetrieveVStorageInfrastructureObjectPolicy)(nil)).Elem())
}

// The parameters of `VslmVStorageObjectManager.VslmRetrieveVStorageInfrastructureObjectPolicy`.
type VslmRetrieveVStorageInfrastructureObjectPolicyRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// Datastore on which policy needs to be retrieved.
	//
	// Refers instance of `Datastore`.
	Datastore types.ManagedObjectReference `xml:"datastore" json:"datastore"`
}

func init() {
	types.Add("vslm:VslmRetrieveVStorageInfrastructureObjectPolicyRequestType", reflect.TypeOf((*VslmRetrieveVStorageInfrastructureObjectPolicyRequestType)(nil)).Elem())
}

type VslmRetrieveVStorageInfrastructureObjectPolicyResponse struct {
	Returnval []types.VslmInfrastructureObjectPolicy `xml:"returnval,omitempty" json:"returnval,omitempty"`
}

type VslmRetrieveVStorageObject VslmRetrieveVStorageObjectRequestType

func init() {
	types.Add("vslm:VslmRetrieveVStorageObject", reflect.TypeOf((*VslmRetrieveVStorageObject)(nil)).Elem())
}

type VslmRetrieveVStorageObjectAssociations VslmRetrieveVStorageObjectAssociationsRequestType

func init() {
	types.Add("vslm:VslmRetrieveVStorageObjectAssociations", reflect.TypeOf((*VslmRetrieveVStorageObjectAssociations)(nil)).Elem())
}

// The parameters of `VslmVStorageObjectManager.VslmRetrieveVStorageObjectAssociations`.
type VslmRetrieveVStorageObjectAssociationsRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The IDs of the virtual storage objects of the query.
	Ids []types.ID `xml:"ids,omitempty" json:"ids,omitempty"`
}

func init() {
	types.Add("vslm:VslmRetrieveVStorageObjectAssociationsRequestType", reflect.TypeOf((*VslmRetrieveVStorageObjectAssociationsRequestType)(nil)).Elem())
}

type VslmRetrieveVStorageObjectAssociationsResponse struct {
	Returnval []VslmVsoVStorageObjectAssociations `xml:"returnval,omitempty" json:"returnval,omitempty"`
}

type VslmRetrieveVStorageObjectMetadata VslmRetrieveVStorageObjectMetadataRequestType

func init() {
	types.Add("vslm:VslmRetrieveVStorageObjectMetadata", reflect.TypeOf((*VslmRetrieveVStorageObjectMetadata)(nil)).Elem())
}

// The parameters of `VslmVStorageObjectManager.VslmRetrieveVStorageObjectMetadata`.
type VslmRetrieveVStorageObjectMetadataRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The ID of the virtual storage object.
	Id types.ID `xml:"id" json:"id"`
	// The ID of the snapshot of virtual storage object.
	SnapshotId *types.ID `xml:"snapshotId,omitempty" json:"snapshotId,omitempty"`
	// The prefix of the metadata key that needs to be retrieved
	Prefix string `xml:"prefix,omitempty" json:"prefix,omitempty"`
}

func init() {
	types.Add("vslm:VslmRetrieveVStorageObjectMetadataRequestType", reflect.TypeOf((*VslmRetrieveVStorageObjectMetadataRequestType)(nil)).Elem())
}

type VslmRetrieveVStorageObjectMetadataResponse struct {
	Returnval []types.KeyValue `xml:"returnval,omitempty" json:"returnval,omitempty"`
}

type VslmRetrieveVStorageObjectMetadataValue VslmRetrieveVStorageObjectMetadataValueRequestType

func init() {
	types.Add("vslm:VslmRetrieveVStorageObjectMetadataValue", reflect.TypeOf((*VslmRetrieveVStorageObjectMetadataValue)(nil)).Elem())
}

// The parameters of `VslmVStorageObjectManager.VslmRetrieveVStorageObjectMetadataValue`.
type VslmRetrieveVStorageObjectMetadataValueRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The ID of the virtual storage object.
	Id types.ID `xml:"id" json:"id"`
	// The ID of the snapshot of virtual storage object.
	SnapshotId *types.ID `xml:"snapshotId,omitempty" json:"snapshotId,omitempty"`
	// The key for the the virtual storage object
	Key string `xml:"key" json:"key"`
}

func init() {
	types.Add("vslm:VslmRetrieveVStorageObjectMetadataValueRequestType", reflect.TypeOf((*VslmRetrieveVStorageObjectMetadataValueRequestType)(nil)).Elem())
}

type VslmRetrieveVStorageObjectMetadataValueResponse struct {
	Returnval string `xml:"returnval" json:"returnval"`
}

// The parameters of `VslmVStorageObjectManager.VslmRetrieveVStorageObject`.
type VslmRetrieveVStorageObjectRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The ID of the virtual storage object to be retrieved.
	Id types.ID `xml:"id" json:"id"`
}

func init() {
	types.Add("vslm:VslmRetrieveVStorageObjectRequestType", reflect.TypeOf((*VslmRetrieveVStorageObjectRequestType)(nil)).Elem())
}

type VslmRetrieveVStorageObjectResponse struct {
	Returnval types.VStorageObject `xml:"returnval" json:"returnval"`
}

type VslmRetrieveVStorageObjectState VslmRetrieveVStorageObjectStateRequestType

func init() {
	types.Add("vslm:VslmRetrieveVStorageObjectState", reflect.TypeOf((*VslmRetrieveVStorageObjectState)(nil)).Elem())
}

// The parameters of `VslmVStorageObjectManager.VslmRetrieveVStorageObjectState`.
type VslmRetrieveVStorageObjectStateRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The ID of the virtual storage object the state to be retrieved.
	Id types.ID `xml:"id" json:"id"`
}

func init() {
	types.Add("vslm:VslmRetrieveVStorageObjectStateRequestType", reflect.TypeOf((*VslmRetrieveVStorageObjectStateRequestType)(nil)).Elem())
}

type VslmRetrieveVStorageObjectStateResponse struct {
	Returnval types.VStorageObjectStateInfo `xml:"returnval" json:"returnval"`
}

type VslmRetrieveVStorageObjects VslmRetrieveVStorageObjectsRequestType

func init() {
	types.Add("vslm:VslmRetrieveVStorageObjects", reflect.TypeOf((*VslmRetrieveVStorageObjects)(nil)).Elem())
}

// The parameters of `VslmVStorageObjectManager.VslmRetrieveVStorageObjects`.
type VslmRetrieveVStorageObjectsRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The array of IDs of the virtual storage object to be
	// retrieved.
	Ids []types.ID `xml:"ids,omitempty" json:"ids,omitempty"`
}

func init() {
	types.Add("vslm:VslmRetrieveVStorageObjectsRequestType", reflect.TypeOf((*VslmRetrieveVStorageObjectsRequestType)(nil)).Elem())
}

type VslmRetrieveVStorageObjectsResponse struct {
	Returnval []VslmVsoVStorageObjectResult `xml:"returnval,omitempty" json:"returnval,omitempty"`
}

// The parameters of `VslmVStorageObjectManager.VslmRevertVStorageObject_Task`.
type VslmRevertVStorageObjectRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The ID of the virtual storage object.
	Id types.ID `xml:"id" json:"id"`
	// The ID of the snapshot of a virtual storage object.
	SnapshotId types.ID `xml:"snapshotId" json:"snapshotId"`
}

func init() {
	types.Add("vslm:VslmRevertVStorageObjectRequestType", reflect.TypeOf((*VslmRevertVStorageObjectRequestType)(nil)).Elem())
}

type VslmRevertVStorageObject_Task VslmRevertVStorageObjectRequestType

func init() {
	types.Add("vslm:VslmRevertVStorageObject_Task", reflect.TypeOf((*VslmRevertVStorageObject_Task)(nil)).Elem())
}

type VslmRevertVStorageObject_TaskResponse struct {
	Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"`
}

type VslmScheduleReconcileDatastoreInventory VslmScheduleReconcileDatastoreInventoryRequestType

func init() {
	types.Add("vslm:VslmScheduleReconcileDatastoreInventory", reflect.TypeOf((*VslmScheduleReconcileDatastoreInventory)(nil)).Elem())
}

// The parameters of `VslmVStorageObjectManager.VslmScheduleReconcileDatastoreInventory`.
type VslmScheduleReconcileDatastoreInventoryRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The datastore that needs to be reconciled.
	//
	// Refers instance of `Datastore`.
	Datastore types.ManagedObjectReference `xml:"datastore" json:"datastore"`
}

func init() {
	types.Add("vslm:VslmScheduleReconcileDatastoreInventoryRequestType", reflect.TypeOf((*VslmScheduleReconcileDatastoreInventoryRequestType)(nil)).Elem())
}

type VslmScheduleReconcileDatastoreInventoryResponse struct {
}

// The `VslmServiceInstanceContent` data object defines properties for the
// `VslmServiceInstance` managed object.
//
// This structure may be used only with operations rendered under `/vslm`.
type VslmServiceInstanceContent struct {
	types.DynamicData

	// Contains information that identifies the Storage Lifecycle Management
	// service.
	AboutInfo VslmAboutInfo `xml:"aboutInfo" json:"aboutInfo"`
	// `VslmSessionManager` contains login APIs to connect to VSLM
	// service.
	//
	// Refers instance of `VslmSessionManager`.
	SessionManager types.ManagedObjectReference `xml:"sessionManager" json:"sessionManager"`
	// `VslmVStorageObjectManager` contains virtual storage object
	// APIs.
	//
	// Refers instance of `VslmVStorageObjectManager`.
	VStorageObjectManager types.ManagedObjectReference `xml:"vStorageObjectManager" json:"vStorageObjectManager"`
	// `VslmStorageLifecycleManager` contains callback APIs to VSLM
	// service.
	//
	// Refers instance of `VslmStorageLifecycleManager`.
	StorageLifecycleManager types.ManagedObjectReference `xml:"storageLifecycleManager" json:"storageLifecycleManager"`
}

func init() {
	types.Add("vslm:VslmServiceInstanceContent", reflect.TypeOf((*VslmServiceInstanceContent)(nil)).Elem())
}

type VslmSetVStorageObjectControlFlags VslmSetVStorageObjectControlFlagsRequestType

func init() {
	types.Add("vslm:VslmSetVStorageObjectControlFlags", reflect.TypeOf((*VslmSetVStorageObjectControlFlags)(nil)).Elem())
}

// The parameters of `VslmVStorageObjectManager.VslmSetVStorageObjectControlFlags`.
type VslmSetVStorageObjectControlFlagsRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The ID of the virtual storage object.
	Id types.ID `xml:"id" json:"id"`
	// control flags enum array to be set on the
	// VStorageObject. All control flags not included
	// in the array remain intact.
	ControlFlags []string `xml:"controlFlags,omitempty" json:"controlFlags,omitempty"`
}

func init() {
	types.Add("vslm:VslmSetVStorageObjectControlFlagsRequestType", reflect.TypeOf((*VslmSetVStorageObjectControlFlagsRequestType)(nil)).Elem())
}

type VslmSetVStorageObjectControlFlagsResponse struct {
}

type VslmSyncDatastore VslmSyncDatastoreRequestType

func init() {
	types.Add("vslm:VslmSyncDatastore", reflect.TypeOf((*VslmSyncDatastore)(nil)).Elem())
}

// The parameters of `VslmStorageLifecycleManager.VslmSyncDatastore`.
type VslmSyncDatastoreRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The datastore URL as specified in
	// `DatastoreInfo.url`
	DatastoreUrl string `xml:"datastoreUrl" json:"datastoreUrl"`
	// If this is set to true, all information for this datastore
	// will be discarded from the catalog and reloaded from the
	// datastore's catalog
	FullSync bool `xml:"fullSync" json:"fullSync"`
	// If set, this call blocks until fcdId is persisited into db
	// if this fcdId is not found in queue, assume persisted and return
	FcdId *types.ID `xml:"fcdId,omitempty" json:"fcdId,omitempty"`
}

func init() {
	types.Add("vslm:VslmSyncDatastoreRequestType", reflect.TypeOf((*VslmSyncDatastoreRequestType)(nil)).Elem())
}

type VslmSyncDatastoreResponse struct {
}

// An SyncFault fault is thrown when there is a failure to synchronize
// the FCD global catalog information with the local catalog information.
//
// Pandora synchronizes the datastore periodically in the background, it
// recovers from any transient failures affecting the datastore or
// individual FCDs. In cases where the sync fault needs to be resolved
// immediately, explicitly triggering a
// `vslm.vso.StorageLifecycleManager#syncDatastore` should resolve the
// issue, unless there are underlying infrastructure issues affecting the
// datastore or FCD. If the fault is ignored there is
// a possibility that the FCD is unrecognized by Pandora or Pandora
// DB having stale information, consequently, affecting the return of
// `VslmVStorageObjectManager.VslmListVStorageObjectForSpec` and
// `VslmVStorageObjectManager.VslmRetrieveVStorageObjects` APIs.
// In cases where the `VslmSyncFault.id` is specified,
// the client can explicitly trigger
// `vslm.vso.StorageLifecycleManager#syncDatastore` to resolve
// the issue, else, could ignore the fault in anticipation of Pandora
// automatically resolving the error.
//
// This structure may be used only with operations rendered under `/vslm`.
type VslmSyncFault struct {
	VslmFault

	Id *types.ID `xml:"id,omitempty" json:"id,omitempty"`
}

func init() {
	types.Add("vslm:VslmSyncFault", reflect.TypeOf((*VslmSyncFault)(nil)).Elem())
}

type VslmSyncFaultFault VslmSyncFault

func init() {
	types.Add("vslm:VslmSyncFaultFault", reflect.TypeOf((*VslmSyncFaultFault)(nil)).Elem())
}

// This data object type contains all information about a VSLM task.
//
// A task represents an operation performed by VirtualCenter or ESX.
//
// This structure may be used only with operations rendered under `/vslm`.
type VslmTaskInfo struct {
	types.DynamicData

	// The unique key for the task.
	Key string `xml:"key" json:"key"`
	// The managed object that represents this task.
	//
	// Refers instance of `VslmTask`.
	Task types.ManagedObjectReference `xml:"task" json:"task"`
	// The description field of the task describes the current phase of
	// operation of the task.
	//
	// For a task that does a single monolithic
	// activity, this will be fixed and unchanging.
	// For tasks that have various substeps, this field will change
	// as the task progresses from one phase to another.
	Description *types.LocalizableMessage `xml:"description,omitempty" json:"description,omitempty"`
	// The name of the operation that created the task.
	//
	// This is not set
	// for internal tasks.
	Name string `xml:"name,omitempty" json:"name,omitempty"`
	// An identifier for this operation.
	//
	// This includes publicly visible
	// internal tasks and is a lookup in the TaskDescription methodInfo
	// data object.
	DescriptionId string `xml:"descriptionId" json:"descriptionId"`
	// Managed entity to which the operation applies.
	//
	// Refers instance of `ManagedEntity`.
	Entity *types.ManagedObjectReference `xml:"entity,omitempty" json:"entity,omitempty"`
	// The name of the managed entity, locale-specific, retained for the
	// history collector database.
	EntityName string `xml:"entityName,omitempty" json:"entityName,omitempty"`
	// If the state of the task is "running", then this property is a list of
	// managed entities that the operation has locked, with a shared lock.
	//
	// Refers instances of `ManagedEntity`.
	Locked []types.ManagedObjectReference `xml:"locked,omitempty" json:"locked,omitempty"`
	// Runtime status of the task.
	State VslmTaskInfoState `xml:"state" json:"state"`
	// Flag to indicate whether or not the client requested
	// cancellation of the task.
	Cancelled bool `xml:"cancelled" json:"cancelled"`
	// Flag to indicate whether or not the cancel task operation is supported.
	Cancelable bool `xml:"cancelable" json:"cancelable"`
	// If the task state is "error", then this property contains the fault code.
	Error *types.LocalizedMethodFault `xml:"error,omitempty" json:"error,omitempty"`
	// If the task state is "success", then this property may be used
	// to hold a return value.
	Result types.AnyType `xml:"result,omitempty,typeattr" json:"result,omitempty"`
	// If the task state is "running", then this property contains a
	// progress measurement, expressed as percentage completed, from 0 to 100.
	//
	// If this property is not set, then the command does not report progress.
	Progress int32 `xml:"progress,omitempty" json:"progress,omitempty"`
	// Kind of entity responsible for creating this task.
	Reason BaseVslmTaskReason `xml:"reason,typeattr" json:"reason"`
	// Time stamp when the task was created.
	QueueTime time.Time `xml:"queueTime" json:"queueTime"`
	// Time stamp when the task started running.
	StartTime *time.Time `xml:"startTime" json:"startTime,omitempty"`
	// Time stamp when the task was completed (whether success or failure).
	CompleteTime *time.Time `xml:"completeTime" json:"completeTime,omitempty"`
	// Event chain ID that leads to the corresponding events.
	EventChainId int32 `xml:"eventChainId" json:"eventChainId"`
	// The user entered tag to identify the operations and their side effects
	ChangeTag string `xml:"changeTag,omitempty" json:"changeTag,omitempty"`
	// Tasks can be created by another task.
	//
	// This shows `VslmTaskInfo.key` of the task spun off this task. This is to
	// track causality between tasks.
	ParentTaskKey string `xml:"parentTaskKey,omitempty" json:"parentTaskKey,omitempty"`
	// Tasks can be created by another task and such creation can go on for
	// multiple levels.
	//
	// This is the `VslmTaskInfo.key` of the task
	// that started the chain of tasks.
	RootTaskKey string `xml:"rootTaskKey,omitempty" json:"rootTaskKey,omitempty"`
	// The activation Id is a client-provided token to link an API call with a task.
	ActivationId string `xml:"activationId,omitempty" json:"activationId,omitempty"`
}

func init() {
	types.Add("vslm:VslmTaskInfo", reflect.TypeOf((*VslmTaskInfo)(nil)).Elem())
}

// Base type for all task reasons.
//
// Task reasons represent the kind of entity responsible for a task's creation.
//
// This structure may be used only with operations rendered under `/vslm`.
type VslmTaskReason struct {
	types.DynamicData
}

func init() {
	types.Add("vslm:VslmTaskReason", reflect.TypeOf((*VslmTaskReason)(nil)).Elem())
}

// Indicates that the task was queued by an alarm.
//
// This structure may be used only with operations rendered under `/vslm`.
type VslmTaskReasonAlarm struct {
	VslmTaskReason

	// The name of the alarm that queued the task, retained in the history
	// collector database.
	AlarmName string `xml:"alarmName" json:"alarmName"`
	// The alarm object that queued the task.
	//
	// Refers instance of `Alarm`.
	Alarm types.ManagedObjectReference `xml:"alarm" json:"alarm"`
	// The name of the managed entity on which the alarm is triggered,
	// retained in the history collector database.
	EntityName string `xml:"entityName" json:"entityName"`
	// The managed entity object on which the alarm is triggered.
	//
	// Refers instance of `ManagedEntity`.
	Entity types.ManagedObjectReference `xml:"entity" json:"entity"`
}

func init() {
	types.Add("vslm:VslmTaskReasonAlarm", reflect.TypeOf((*VslmTaskReasonAlarm)(nil)).Elem())
}

// Indicates that the task was queued by a scheduled task.
//
// This structure may be used only with operations rendered under `/vslm`.
type VslmTaskReasonSchedule struct {
	VslmTaskReason

	// The name of the scheduled task that queued this task.
	Name string `xml:"name" json:"name"`
	// The scheduledTask object that queued this task.
	//
	// Refers instance of `ScheduledTask`.
	ScheduledTask types.ManagedObjectReference `xml:"scheduledTask" json:"scheduledTask"`
}

func init() {
	types.Add("vslm:VslmTaskReasonSchedule", reflect.TypeOf((*VslmTaskReasonSchedule)(nil)).Elem())
}

// Indicates that the task was started by the system (a default task).
//
// This structure may be used only with operations rendered under `/vslm`.
type VslmTaskReasonSystem struct {
	VslmTaskReason
}

func init() {
	types.Add("vslm:VslmTaskReasonSystem", reflect.TypeOf((*VslmTaskReasonSystem)(nil)).Elem())
}

// Indicates that the task was queued by a specific user.
//
// This structure may be used only with operations rendered under `/vslm`.
type VslmTaskReasonUser struct {
	VslmTaskReason

	// Name of the user that queued the task.
	UserName string `xml:"userName" json:"userName"`
}

func init() {
	types.Add("vslm:VslmTaskReasonUser", reflect.TypeOf((*VslmTaskReasonUser)(nil)).Elem())
}

// The parameters of `VslmVStorageObjectManager.VslmUpdateVStorageInfrastructureObjectPolicy_Task`.
type VslmUpdateVStorageInfrastructureObjectPolicyRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// specification to assign a SPBM policy to FCD infrastructure
	// object.
	Spec types.VslmInfrastructureObjectPolicySpec `xml:"spec" json:"spec"`
}

func init() {
	types.Add("vslm:VslmUpdateVStorageInfrastructureObjectPolicyRequestType", reflect.TypeOf((*VslmUpdateVStorageInfrastructureObjectPolicyRequestType)(nil)).Elem())
}

type VslmUpdateVStorageInfrastructureObjectPolicy_Task VslmUpdateVStorageInfrastructureObjectPolicyRequestType

func init() {
	types.Add("vslm:VslmUpdateVStorageInfrastructureObjectPolicy_Task", reflect.TypeOf((*VslmUpdateVStorageInfrastructureObjectPolicy_Task)(nil)).Elem())
}

type VslmUpdateVStorageInfrastructureObjectPolicy_TaskResponse struct {
	Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"`
}

// The parameters of `VslmVStorageObjectManager.VslmUpdateVStorageObjectMetadata_Task`.
type VslmUpdateVStorageObjectMetadataRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The ID of the virtual storage object.
	Id types.ID `xml:"id" json:"id"`
	// array of key/value strings. (keys must be unique
	// within the list)
	Metadata []types.KeyValue `xml:"metadata,omitempty" json:"metadata,omitempty"`
	// array of keys need to be deleted
	DeleteKeys []string `xml:"deleteKeys,omitempty" json:"deleteKeys,omitempty"`
}

func init() {
	types.Add("vslm:VslmUpdateVStorageObjectMetadataRequestType", reflect.TypeOf((*VslmUpdateVStorageObjectMetadataRequestType)(nil)).Elem())
}

type VslmUpdateVStorageObjectMetadata_Task VslmUpdateVStorageObjectMetadataRequestType

func init() {
	types.Add("vslm:VslmUpdateVStorageObjectMetadata_Task", reflect.TypeOf((*VslmUpdateVStorageObjectMetadata_Task)(nil)).Elem())
}

type VslmUpdateVStorageObjectMetadata_TaskResponse struct {
	Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"`
}

// The parameters of `VslmVStorageObjectManager.VslmUpdateVstorageObjectCrypto_Task`.
type VslmUpdateVstorageObjectCryptoRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The ID of the virtual storage object.
	Id types.ID `xml:"id" json:"id"`
	// New profile requirement on the virtual storage object.
	Profile []types.VirtualMachineProfileSpec `xml:"profile,omitempty" json:"profile,omitempty"`
	// The crypto information of each disk on the chain.
	DisksCrypto *types.DiskCryptoSpec `xml:"disksCrypto,omitempty" json:"disksCrypto,omitempty"`
}

func init() {
	types.Add("vslm:VslmUpdateVstorageObjectCryptoRequestType", reflect.TypeOf((*VslmUpdateVstorageObjectCryptoRequestType)(nil)).Elem())
}

type VslmUpdateVstorageObjectCrypto_Task VslmUpdateVstorageObjectCryptoRequestType

func init() {
	types.Add("vslm:VslmUpdateVstorageObjectCrypto_Task", reflect.TypeOf((*VslmUpdateVstorageObjectCrypto_Task)(nil)).Elem())
}

type VslmUpdateVstorageObjectCrypto_TaskResponse struct {
	Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"`
}

// The parameters of `VslmVStorageObjectManager.VslmUpdateVstorageObjectPolicy_Task`.
type VslmUpdateVstorageObjectPolicyRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The ID of the virtual storage object.
	Id types.ID `xml:"id" json:"id"`
	// New profile requirement on the virtual storage object.
	Profile []types.VirtualMachineProfileSpec `xml:"profile,omitempty" json:"profile,omitempty"`
}

func init() {
	types.Add("vslm:VslmUpdateVstorageObjectPolicyRequestType", reflect.TypeOf((*VslmUpdateVstorageObjectPolicyRequestType)(nil)).Elem())
}

type VslmUpdateVstorageObjectPolicy_Task VslmUpdateVstorageObjectPolicyRequestType

func init() {
	types.Add("vslm:VslmUpdateVstorageObjectPolicy_Task", reflect.TypeOf((*VslmUpdateVstorageObjectPolicy_Task)(nil)).Elem())
}

type VslmUpdateVstorageObjectPolicy_TaskResponse struct {
	Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"`
}

// This data object is a key-value pair whose key is the virtual storage
// object id, and value is the vm association information.
//
// This structure may be used only with operations rendered under `/vslm`.
type VslmVsoVStorageObjectAssociations struct {
	types.DynamicData

	// ID of this virtual storage object.
	Id types.ID `xml:"id" json:"id"`
	// Array of vm associations related to the virtual storage object.
	VmDiskAssociation []VslmVsoVStorageObjectAssociationsVmDiskAssociation `xml:"vmDiskAssociation,omitempty" json:"vmDiskAssociation,omitempty"`
	// Received error while generating associations.
	Fault *types.LocalizedMethodFault `xml:"fault,omitempty" json:"fault,omitempty"`
}

func init() {
	types.Add("vslm:VslmVsoVStorageObjectAssociations", reflect.TypeOf((*VslmVsoVStorageObjectAssociations)(nil)).Elem())
}

// This data object contains infomation of a VM Disk association.
//
// This structure may be used only with operations rendered under `/vslm`.
type VslmVsoVStorageObjectAssociationsVmDiskAssociation struct {
	types.DynamicData

	// ID of the virtual machine.
	VmId string `xml:"vmId" json:"vmId"`
	// Device key of the disk attached to the VM.
	DiskKey int32 `xml:"diskKey" json:"diskKey"`
}

func init() {
	types.Add("vslm:VslmVsoVStorageObjectAssociationsVmDiskAssociation", reflect.TypeOf((*VslmVsoVStorageObjectAssociationsVmDiskAssociation)(nil)).Elem())
}

// The `VslmVsoVStorageObjectQueryResult` contains the result of
// `vslm.vso.VStorageObjectManager#listVStorageObjectForSpec` API.
//
// This structure may be used only with operations rendered under `/vslm`.
type VslmVsoVStorageObjectQueryResult struct {
	types.DynamicData

	// If set to false, more results were found than could be returned (either
	// limited by maxResult input argument in the
	// `vslm.vso.VStorageObjectManager#listVStorageObjectForSpec` API or
	// truncated because the number of results exceeded the internal limit).
	AllRecordsReturned bool `xml:"allRecordsReturned" json:"allRecordsReturned"`
	// IDs of the VStorageObjects matching the query criteria
	// NOTE: This field will be removed once the dev/qe code is refactored.
	//
	// IDs will be returned in ascending order. If
	// `VslmVsoVStorageObjectQueryResult.allRecordsReturned` is set to false,
	// to get the additional results, repeat the query with ID last ID as
	// part of the query spec `VslmVsoVStorageObjectQuerySpec`.
	Id []types.ID `xml:"id,omitempty" json:"id,omitempty"`
	// Results of the query criteria.
	//
	// `vim.vslm.VStorageObjectResult#id` IDs will be returned in
	// ascending order. If `VslmVsoVStorageObjectQueryResult.allRecordsReturned`
	// is set to false,then, to get the additional results, repeat the query
	// with ID last ID as part of the query spec
	// `VslmVsoVStorageObjectQuerySpec`.
	QueryResults []VslmVsoVStorageObjectResult `xml:"queryResults,omitempty" json:"queryResults,omitempty"`
}

func init() {
	types.Add("vslm:VslmVsoVStorageObjectQueryResult", reflect.TypeOf((*VslmVsoVStorageObjectQueryResult)(nil)).Elem())
}

// The `VslmVsoVStorageObjectQuerySpec` describes the criteria to query
// VStorageObject from global catalog.
//
// `VslmVsoVStorageObjectQuerySpec` is sent as input to
// `vslm.vso.VStorageObjectManager#listVStorageObjectForSpec` API.
//
// This structure may be used only with operations rendered under `/vslm`.
type VslmVsoVStorageObjectQuerySpec struct {
	types.DynamicData

	// This field specifies the searchable field.
	//
	// This can be one of the values from
	// `VslmVsoVStorageObjectQuerySpecQueryFieldEnum_enum`.
	QueryField string `xml:"queryField" json:"queryField"`
	// This field specifies the operator to compare the searchable field
	// `VslmVsoVStorageObjectQuerySpec.queryField` with the specified
	// value `VslmVsoVStorageObjectQuerySpec.queryValue`.
	//
	// This can be one of the values from
	// `vslm.vso.VStorageObjectQuerySpec.QueryFieldOperator`.
	QueryOperator string `xml:"queryOperator" json:"queryOperator"`
	// This field specifies the value to be compared with the searchable field.
	QueryValue []string `xml:"queryValue,omitempty" json:"queryValue,omitempty"`
}

func init() {
	types.Add("vslm:VslmVsoVStorageObjectQuerySpec", reflect.TypeOf((*VslmVsoVStorageObjectQuerySpec)(nil)).Elem())
}

// The `VslmVsoVStorageObjectResult` contains the result objects of
// `VslmVsoVStorageObjectQueryResult` which is returned as a result of
// `slm.vso.VStorageObjectManager#listVStorageObjectForSpec` and
// `slm.vso.VStorageObjectManager#retrieveVStorageObjects` APIs.
//
// This structure may be used only with operations rendered under `/vslm`.
type VslmVsoVStorageObjectResult struct {
	types.DynamicData

	// The ID of the virtual storage object.
	Id types.ID `xml:"id" json:"id"`
	// Name of FCD.
	Name string `xml:"name,omitempty" json:"name,omitempty"`
	// The size in MB of this object.
	//
	// If the faults are set,
	// then the capacityInMB will be -1
	CapacityInMB int64 `xml:"capacityInMB" json:"capacityInMB"`
	// The create time information of the FCD.
	CreateTime *time.Time `xml:"createTime" json:"createTime,omitempty"`
	// The Datastore URL containing the FCD.
	DatastoreUrl string `xml:"datastoreUrl,omitempty" json:"datastoreUrl,omitempty"`
	// The disk path of the FCD.
	DiskPath string `xml:"diskPath,omitempty" json:"diskPath,omitempty"`
	// The rolled up used capacity of the FCD and it's snapshots.
	//
	// Returns -1L if the space information is currently unavailable.
	UsedCapacityInMB int64 `xml:"usedCapacityInMB,omitempty" json:"usedCapacityInMB,omitempty"`
	// The ID of the backing object of the virtual storage object.
	BackingObjectId *types.ID `xml:"backingObjectId,omitempty" json:"backingObjectId,omitempty"`
	// VStorageObjectSnapshotResult array containing information about all the
	// snapshots of the virtual storage object.
	SnapshotInfo []VslmVsoVStorageObjectSnapshotResult `xml:"snapshotInfo,omitempty" json:"snapshotInfo,omitempty"`
	// Metadata array of key/value strings.
	Metadata []types.KeyValue `xml:"metadata,omitempty" json:"metadata,omitempty"`
	// The fault is set in case of error conditions and this property will
	// have the reason.
	//
	// Possible Faults:
	// NotFound If specified virtual storage object cannot be found.
	Error *types.LocalizedMethodFault `xml:"error,omitempty" json:"error,omitempty"`
}

func init() {
	types.Add("vslm:VslmVsoVStorageObjectResult", reflect.TypeOf((*VslmVsoVStorageObjectResult)(nil)).Elem())
}

// The `VslmVsoVStorageObjectSnapshotResult` contains brief information about a
// snapshot of the object `VslmVsoVStorageObjectResult` which is returned as a
// result of `slm.vso.VStorageObjectManager#retrieveVStorageObjects` API.
//
// This structure may be used only with operations rendered under `/vslm`.
type VslmVsoVStorageObjectSnapshotResult struct {
	types.DynamicData

	// The ID of the vsan object backing a snapshot of the virtual storage
	// object.
	BackingObjectId types.ID `xml:"backingObjectId" json:"backingObjectId"`
	// The description user passed in when creating this snapshot.
	Description string `xml:"description,omitempty" json:"description,omitempty"`
	// The ID of this snapshot, created and used in fcd layer.
	SnapshotId *types.ID `xml:"snapshotId,omitempty" json:"snapshotId,omitempty"`
	// The file path of this snapshot.
	DiskPath string `xml:"diskPath,omitempty" json:"diskPath,omitempty"`
}

func init() {
	types.Add("vslm:VslmVsoVStorageObjectSnapshotResult", reflect.TypeOf((*VslmVsoVStorageObjectSnapshotResult)(nil)).Elem())
}

type VersionURI string

func init() {
	types.Add("vslm:versionURI", reflect.TypeOf((*VersionURI)(nil)).Elem())
}